一.类
//使用OOP面向对象解决
//实例化一只猫
Cat cat1=new Cat();
cat1.name="小白";
cat1.age=3;
cat1.color="白色"；
Cat cat2=new Cat();
cat2.name="小花";
cat2.age=5;
cat2.color="黑色"；
System.out.println("第一只猫的信息"+cat1.name+" "+cat1.age+" "+cat1.color);
System.out.println("第一只猫的信息"+cat2.name+" "+cat2.age+" "+cat2.color);
class cat{
//属性
String name;
int age;
String color;}
Person p1=new Person();
p1.age=10;
p1.name="小明";
Person p2=p1; //p1赋给了p2
System.out.println(p2.age);//p2.age=10
二.方法
解读：public--表示方法是公开的
void--表示方法没有返回值
speak--方法的名称
（）--表示没有传入的变量
{}-方法体，可以写我们要执行的代码
方法写好后，如果不去调用，不会输出
先创建对象，然后调用方法
public class var{
public static void main(String[] args){
Person p1=new Person();
p1.speak();
p1.cal01();
p1.cal02(100);
int returnRes=p1.getSum(10,20);
System.out.println("returnRes"+returnRes);
}
}
//////////
class Person {
String name;
int age;
public void speak() {
System.out.println("输出");
}
////////////
public void cal01(){
int sum=0;
for (int i =1;i<=100;i++){
sum +=i;
}
System.out.println("计算结果"+sum);}
//(int n)形参列表，表示当前有一个形参，可以接收用户的输入
public void cal02(int n){
int sum=0;
for (int i =1;i<=n;i++){
sum +=i;
}
System.out.println("计算结果"+sum);}
//计算两个数的和
//int--返回一个Int类型的数据
public int getSum(int num1 ,int num2){
int res=num1+num2;
return res;
}}
方法调用机制
1.当程序执行到方法时，就会开辟一个独立的空间（栈空间）
2.当方法执行完毕，或者执行到return语句，就会返回
3.返回到调用方法的地方
4.返回后，继续执行后面方法的代码
//遍历一个数组
public class var{
public static void main(String[] args){
int[][] map={{0,0,1},{1,1,1},{1,1,3}};
int[][] map_1={{2,0,1},{2,1,1},{1,1,3}};
MyTools tool=new MyTools();
tool.printArr(map);
tool.printArr(map_1);
}
}
class MyTools{
//接收一个二维数组
public void printArr(int[][] map){
System.out.println("======");
for(int i=0;i<map.length;i++){
for(int j=0;j<map[i].length;j++){
System.out.print(map[i][j]+" ");}
System.out.println();
} }}
//如何返回多个结果 返回数组
public class var{
public static void main(String[] args){
AA tool=new AA();
int[] return_get = tool.getSumAndSub(3,2);
System.out.println(return_get[0]);
System.out.println(return_get[1]);
}
}
class AA{
public int[] getSumAndSub(int n1, int n2){
int[] resArr=new int[2];
resArr[0]=n1+n2;
resArr[1]=n1-n2;
return resArr;}}
注意事项
public double f1(){
double d1=1.1*3;
int n=100;
return n;//ok,int->double
//同一个类中的方法调用：直接调用即可
class A{
public void print(int n){
System.out.println("print(方法被调用) n="+n);
}
public void Ok(){
print(10);
}
class A{
public void print(int n){
System.out.println("print(方法被调用) n="+n);
}
public void Ok(){
print(10);}
public void m1(){
//创建B对象
B b =new B();
b.hi();}
//跨类中的方法A类调用B类方法：需要通过对象名调用
class B{
public void hi(){
System.out.println("B类中的hi（）被执行");}
//编写类AA，有一个方法：判断一个数是奇数还是偶数返回boolean
public class var{
public static void main(String[] args){
AA tool=new AA();
tool.odd(101);
}
}
class AA {
public void odd(int n){
if (n%2==0){
System.out.println(n%2==0);}else{
System.out.println(n%2==0);}
}
}
//编写类AA，有一个方法：判断一个数是奇数还是偶数返回boolean
public class var{
public static void main(String[] args){
AA tool=new AA();
boolean num2 = tool.isOdd(3);
System.out.println(num2);
}
}
class AA{
public boolean isOdd(int num){
if(num%2 == 0){
return true;}
else{return false;}
}
}
return num %2 !=0? true : false
//编写类AA，有一个方法：判断一个数是奇数还是偶数返回boolean
public class var{
public static void main(String[] args){
AA tool=new AA();
tool.isOdd(4,4,'*');
}
}
class AA {
public void isOdd(int row,int col,char c) {
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
System.out.print(c);
}
System.out.println();
}
}
}
成员方法传参机制
public class var{
public static void main(String[] args){
int a=3;
int b=4;
AA tool=new AA();
tool.swap(a,b);
System.out.println("原本的："+"a="+a+"b="+b);//a=3,b=4
}
}
class AA {
public void swap(int a,int b) {
//完成了a,b的交换
int tmp=a;
a=b;
b=tmp;
System.out.println("调用的："+"a="+a+"b="+b);
}
}
基本数据类型，传递的是值，形参的任何改变不影响实参
//引用类型的传参机制
public class var{
public static void main(String[] args){
B b=new B();
int[] arr={1,2,3};
b.test100(arr);
System.out.println("main的输出");
for (int i =0;i<arr.length;i++){
System.out.print(arr[i]+" ");}
System.out.println();
}
}
class B {
public void test100(int[] arr){
arr[0]=200;
System.out.println("类的输出");
for (int i =0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println();
}
}
引用类型传递的是地址（传递也是值，但是值是地址），可以通过形参影响实参
public class var{
public static void main(String[] args){
B b=new B();
int[] arr={1,2,3};
b.test100(arr);
System.out.println("main的输出");
for (int i =0;i<arr.length;i++){
System.out.print(arr[i]+" ");}
System.out.println();
Person p=new Person();
p.name="javk";
p.age=20;
b.test200(p);
System.out.println("main:"+p.age);
}
}
class Person{
String name;
int age;}
class B {
public void test200(Person p){
p.age=100;
}
public void test100(int[] arr){
arr[0]=200;
System.out.println("类的输出");
for (int i =0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println();
}
}
在方法中修改该对象属性，原来的对象会发生变化
输出Main中的age
Java中有俩种数据类型,其中主要有8中基本数据类型和引用数据类型，除了8中基本数据类型以外都是引用数据类型,8中基本数据类型分别是byte,short,int,long,char,boolean,float,double，具体如下：
1、boolean：数据值只有true或false，适用于逻辑计算。
2、char：char型（字符型）数据在内存中占用2个字节。char型数据用来表示通常意义上的字符，每个字符占2个字节，Java字符采用Unicode编码，它的前128字节编码与ASCII兼容字符的存储范围在\u0000~\uFFFF，在定义字符型的数据时候要注意加' '，比如 '1'表示字符'1'而不是数值1，
3、byte：byte型（字节型）数据在内存中占用1个字节，表示的存储数据范围为：-128~127。
4、short：short型（短整型）数据在内存中占用2个字节。
5、int：int型（整型）数据在内存中占用4个字节。
6、long：long型（长整型）数据在内存中占用8个字节。
7、float：float型（单精度浮点型）数据在内存中占用4个字节。（float精度为7-8位）
8、double：double型（双精度浮点型）数据在内存中占用8个字节。
下面说说java中引用数据类型：
引用数据类型分3种：类，接口，数组；
一、类Class引用
可以是我们创建的，这里我不多讲，主要是讲解几个java库中的类
Object ：Object是一个很重要的类，Object是类层次结构的根类，每个类都使用Object作为超类，所有对象（包括数组）都实现这个类的方法。用Object可以定义所有的类
如：
Object object= new Integer(1); 来定义一个Interger类
Integer i=(Integer) object; 在来把这个Object强制转换成Interger类
String ：String类代表字符串，Java 程序中的所有字符串字面值（如"abc"）都作为此类的实例来实现。检查序列的单个字符、比较字符串、搜索字符串、提取子字符串、创建字符串副本、在该副本中、所有的字符都被转换为大写或小写形式。
Date ：Date表示特定的瞬间，精确到毫秒。Date的类一般现在都被Calendar 和GregorianCalendar所有代替
Void ：Void 类是一个不可实例化的占位符类，它保持一个对代表 Java 关键字 void 的 Class 对象的引用。
同时也有对应的Class如：Integer Long Boolean Byte Character Double Float Short
public class var{
public static void main(String[] args){
B b=new B();
int[] arr={1,2,3};
b.test100(arr);
System.out.println("main的输出");
for (int i =0;i<arr.length;i++){
System.out.print(arr[i]+" ");}
System.out.println();
Person p=new Person();
p.name="javk";
p.age=20;
b.test200(p);
System.out.println("main:"+p.age);
}
}
class Person{
String name;
int age;}
class B {
public void test200(Person p){
p=new Person();
p.age=100;
p.name="kk";
//p=null;
}
public void test100(int[] arr){
arr[0]=200;
System.out.println("类的输出");
for (int i =0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println();
}
}
//编写一个方法copyPerson，可以复制一个Person对象，返回复制的对象。
//克隆对象，注意要求得到的新对象和原来的对象是两个独立的对象，只是属性相同
public class var{
public static void main(String[] args){
Person p=new Person();
p.name="milan";
p.age=100;
//创建一个对象
MyTools tools =new MyTools();
Person p2 =tools.copyPerson(p);
System.out.println("p的属性"+p.age+p.name);
System.out.println("p2的属性"+p2.age+p2.name);
System.out.println(p==p2);
}
}
class Person{
String name;
int age;
}
class MyTools{
//编写方法的思路
//1.方法的返回类型 Person
//2.方法的名字 copyperson
//3.方法的形参（Person p）
//4.方法体，创建一个新对象，并复制属性，返回即可
public Person copyPerson(Person p){
//创建一个新对象,不要改掉别人的Person
Person p2 = new Person();
p2.name=p.name;
p2.age=p.age;
return p2;
}}
标签：JAVA,--,void,System,对象,int,println,public,out From： https://www.cnblogs.com/maxzz/p/16826478.html