JavaSE| 面向对象-类的五大成员
面向对象
面向对象只是其中一种编程思想，还有很多其他的编程思想：面向过程、面向切面、面向服务编程...
面向过程的思维方式：注重步骤、过程，面向过程强调的是功能行为； 面向对象的思维方式：关注的是“对象”。面向对象，将功能封装进对象，强调具备了功能的对象。面向对象更加强调运用人类在日常的思维
逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。
类（class）、对象（object也称为实例instance）
对象：一个一个的具体事物
当很多个对象它们有共同的特性的时候，我们就可以抽象出一个类别，用一个Java类来表示。
完成需求时：
先去找具有所需功能的对象来用； 如果该对象不存在，那么创建一个具有所需功能的对象； 这样简化开发并提高复用。
java类及类的成员：java中用类class来描述事物。 类与类之间的关系：关联、继承、聚集、组合
属性：对应类中的成员变量，Field = 属性 = 成员变量；行为：对应类中的成员方法，Method = 成员方法 = 函数。
类与对象是的关系
类是对象的抽象的概念，类是体现了对象的共同的特性。类是创建对象的模板，设计图。对象是类的具体。
一、类的设计
类的成员的设计，类的成员包括：
1、属性；2、代码块；3、构造器；4、方法；5、内部类
* 类的成员的顺序： * 1、属性：包括静态的类变量和非静态的实例变量 * 2、代码块：包括静态代码块和非静态代码块 * 非静态代码块又称为构造块 * 3、构造器：包括无参构造和有参构造 * 4、方法：包括静态方法和非静态方法 * 5、内部类
二、类的声明
语法格式：
【修饰符】 class 类名{
}
注意：
（1）类名：命名规则和命名规范（见名知意，每一个单词首字母大写）
（2）建议，就算这个类不是public，我们也与“源文件名”一样
类对象的内存解析
new出来一个变量（实体），首地址赋给a1，通过栈空间a1引用变量
1. 类的成员之一：属性
1、声明属性的语法格式： 【修饰符】 数据类型 属性名； 属性也称为成员变量。
2、声明属性的位置：必须在类中，其他成员（方法、构造器等）的外面
类 {
【修饰符】 数据类型1 属性名1;
【修饰符】 数据类型2 属性名2;
【修饰符】 数据类型3 属性名3;
....
}
3、属性如何赋值？
（1）属性有默认值
基本数据类型：
byte,short,int,long：0
float,double：0.0
char：\u0000
boolean：false
引用数据类型：（类、数组、接口） null
（2）属性的赋值
在其他类中： 对象.属性名 = 值;
4、属性的特点
1）属性有默认值； 2）每一个对象的属性是独立的
变量的三要素：数据类型、变量名、变量值
变量的三要素：（1）数据类型（2）变量名（3）变量值
对象的创建：
类名（数据类型_引用数据类型） 对象名 = new 类名（）； 如 Student stu = new Student( );
属性在类里边声明，对象创建之后，要用对象来调用属性。 stu.name;
如果创建了一个类的多个对象，对于类中定义的属性，每个对象都拥有各自的一套副本，且互不干扰。
1）匿名对象
2）有名对象
类名 对象名 = new 类名( )； 数据类型 变量名 = new 类名()；
说明：类是一种数据类型，引用数据类型。
对象名也是变量名，是引用数据类型的变量，new 类名()是一个值，是一个对象。
引用数据类型的变量、元素，它应该赋值为一个“对象”
回忆：变量的声明格式 数据类型 变量名;
变量的赋值： 变量名 = 值；
注意类创建的数组与它的对象的区别：
Teacher[ ] arr = new Teacher[ 5 ] 数组； Teacher tea = new Teacher( ) 对象；
元素类型是引用数据类型的数组称为对象数组。因为元素中存储的是对象。
arr[ i ]
System.out.println(new Circle()); //new Circle()匿名对象 -->> Circle@15db9742 Circle c1 = new Circle(); //有名对象，它的名字就是c，c是对象名 c1.circle = 1.2; String name = "kris";//String也是类名,name是对象名，"张三"是一个字符串的对象 if(name.equals("kris")){ } //创建了一个java.util.Scanner的对象 //java.util.Scanner也是一种类，也是数据类型 java.util.Scanner input = new java.util.Scanner(System.in); //input是对象名 int num = input.nextInt(); int[] arr = new int[5];//创建了一个数组对象，数组的元素相当于数组的成员变量，属性 //int[] -->>数组类型 <<-->>引用数据类型 -->>默认为null //int[][] -->>int类型为基本数据类型 -->>默认为0
class TestCircle{ public static void main(String[] args){ Circle c1 = new Circle(); //创建了一个圆对象 c1.radius = 2.1; //为属性赋值； System.out.println(c1.radius); System.out.println(c1.getArea()); System.out.println(c1.getLength()); } } /* 1、声明一个类 2、用类来创建具体的对象 */ class Circle{ double radius; double getArea(){ return Math.PI * radius * radius; } double getLength(){ return 2 * Math.PI * radius; } }
变量的分类
按照变量声明的“位置”分为：
- 局部变量
- 成员变量（ 1）实例变量：没有static修饰的属性。2）类变量：使用static修饰的属性 ）
① 成员变量：（某个成员变量不能被外部类直接访问，使用private修饰符）
* 成员变量的声明的位置：类中方法、代码块等外面。
* 成员变量的初始化：1）有默认值； 2）显式初始化；（比如说给属性变量赋值private int i = 10; 用构造器进行初始化还是初始化的值，并不会累加 ）
3）构造器； 4）set方法可以再次修改值。
*成员变量：1）实例变量：堆； 2）类变量：方法区
* 成员变量：相对长，随着对象的创建而创建，随着对象被垃圾回收而消亡。每一个对象的成员变量是独立的。
* 成员变量：权限修饰符（private,缺省,protected,public）、static、final、volatile等
② 局部变量：
* 局部变量的声明的位置：1）方法的形参列表； 2）方法体中； 3）代码块。
* 局部变量的初始化：1）形参的初始化，必须在调用时，由实参赋值；2）其他的局部变量，必须手动初始化
* 局部变量：栈
* 局部变量：短，当代码执行到局部变量的声明处开始，到它的作用域结束而结束
* 局部变量：final
java可以声明局部变量而不进行初始化；
public class TestVar {
public static void main(String[] args) {
// java可以声明局部变量而不进行初始化
String str;
int zhangsan = 10;
}
}
字节码文件：
LocalVariableTable:
Start Length Slot Name Signature
0 4 0 args [Ljava/lang/String;
3 1 2 zhangsan I
LocalVariableTable 本地栈变量表，压栈时给每一个变量一个局部变量表LocalVariableTable;
没有s变量，没有初始化只是声明了，它根本不会出现了这里边；java要求变量在使用前必须初始化；
* 区别：声明的位置、初始化的方式、值的存储的位置不同、生命周期、修饰符不同
2. 类的第二个成员：方法
1、概念
方法（method），又称为函数（function），代表的是一个独立的功能。例如：
Math.sqrt(m)，这个sqrt(m)方法，返回m的平方根
System.out.println()，这个println(x)方法，打印()中的内容
把代码封装到一个方法中的目的，简单的实现功能的复用
2、方法的要求和特点
（1）必须先声明后使用
（2）不调用不执行，调用一次执行一次
（3）调用时必须遵循一定的格式
3、方法的声明
语法格式：
【修饰符】返回值类型 方法名(【形参列表】){
方法体语句块;
}
名词解释：方法 = 方法头 + 方法体 方法头：【修饰符】返回值类型 方法名(【形参列表】) 方法头在很多书或文档中也称为“方法签名”
【修饰符】 class 类名{
【修饰符】返回值类型 方法名(【形参列表】){
方法体语句块;
}
}
因此，方法的声明的位置必须在类中，方法外。
方法的声明的形式
1、无参无返回值
语法格式：
【修饰符】void 方法名(){
方法体语句块;
}
只要是void就是没有返回值的。
2、有参无返回值
语法格式：
【修饰符】void 方法名( 数据类型 形参名 ) { //有void就没有返回值，在调用时也不用写[ 变量= ] 了。 （变量 = 方法名（实参列表））
方法体语句块；
}
形参列表：形参本质上就是一个变量。它只是个形式，没有具体值。只有在方法被“调用”时，形参才能确定值。
方法的调用
1、大多数时候都是在方法体中，偶尔可能在为属性显式赋值时调用
2、格式 【变量 = 】 方法名（【实参列表】）;
调用方法时()中的参数列表我们称为“实参列表”，因为它是有具体的值，实参的作用就是给形参赋值的。
要求：
（1）调用时()中是否要写【实参列表】看声明时()中有没有【形参列表】，并且【实参列表】的个数、顺序、类型与【形参列表】一一对应。
3、无参有返回值
语法格式：
【修饰符】返回值类型 方法名(){
方法体语句块;
}
（1）返回值类型可以是任意Java类型（包括基本数据类型和引用数据类型）
（2）但是只能返回一个值，当然这个值可以是一个简单值（例如：整数5），也可以是一个复杂的值（例如：是一个对象，或者多个对象组成的集合等）
（3）方法体中，必须有“return 值;”
这种“无参有返回值”形式的方法，一般常见于，键盘输入、产生随机值、get值()等这样的功能。
方法的调用
1、大多数时候都是在方法体中，偶尔可能在为属性显式赋值时调用
2、格式 【变量 = 】 方法名（【实参列表】）;
要求：
（1）调用时()中是否要写【实参列表】看声明时()中有没有【形参列表】，并且
要求【实参列表】的个数、顺序、类型与【形参列表】一一对象
（2）前面是否需要【变量=】，看声明时方法的返回值类型是否是void，如果是void，就不能写【变量=】;
如果返回值类型不是void，就可以使用“变量=”，要求这个“变量”和被调用方法的“返回值类型”应该一致或兼容。
4、有参有返回值
语法格式：
【修饰符】返回值类型 方法名(形参列表){
方法体语句块;
}
方法的调用
1、大多数时候都是在方法体中，偶尔可能在为属性显式赋值时调用
2、格式 【变量 = 】 方法名（【实参列表】）;
（1）调用时()中是否要写【实参列表】看声明时()中有没有【形参列表】，并且
要求【实参列表】的个数、顺序、类型与【形参列表】一一对象
（2）前面是否需要【变量=】，看声明时方法的返回值类型是否是void，如果是void，就不能写【变量=】;
如果返回值类型不是void，就可以使用“变量=”，要求这个“变量”和被调用方法的“返回值类型”应该一致或兼容。
class TestMethod2{ public static void main(String[] args){ printJiuJiu();//无参无返回值 printRectangle(5,5,'*'); //有参无返回值 System.out.println(getNum()); //有参无返回值 int max = getMaxNum(7,9); System.out.println("最大值为:" + max); System.out.println("三个数最大值为:" + getThreeNum(5,9,12)); } public static void printJiuJiu(){ //无参无返回值 for(int i = 1;i <= 9;i++){ for(int j = 1;j < i;j++){ System.out.print(j + "*" + i + "=" + j*i + "\t"); }System.out.println(); } } public static void printRectangle(int m, int n, char x){ //有参无返回值 //第一轮:i=1, j=1,2,3,4,5,6循环6次; for(int i = 1;i <= m; i++ ){ for(int j = 1; j <= n; j++ ){ System.out.print(x); }System.out.println(x); } } public static int getNum(){ //无参有返回值 int num = (int)(Math.random() * 100); return num; } public static int getMaxNum(int a,int b){ //有参有返回值 if(a > b){ return a; }else{ return b; } } public static int getThreeNum(int a, int b, int c){ int max = getMaxNum(a, b); max = getMaxNum(c, max); return max; } }
class TestMethod{ public static void main(String[] args){ System.out.println("数组为:"); int[] arr = {3,6,2,9,0,8,4,5}; printShuZu(arr); for(int i = 0;i < arr.length; i++){ System.out.print(arr[i] + "\t"); } //System.out.println(printSum(1,100)); System.out.println("阶乘为:"); System.out.println(printJieCheng(10)); } //声明一个方法，可以为所有的int[]数组实现从小到大排序 //冒泡排序； 有参数没有返回值 public static void printShuZu(int[] arr){ //数组,长度为8,排序 // 第一次 i=1,j=0,1,2,3,4,5,6; for(int i = 1;i < arr.length; i++){ for(int j = 0;j < arr.length - i; j++){ if(arr[j] > arr[j+1]){ int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } } } //声明一个方法，可以累加[m,n]之间的和 //有参数有返回值的； public static int printSum(int m , int n){ int sum = 0; for(int i = m;i<=n; i++){ sum += i; } return sum; } //（3）声明一个方法，可以实现求任意正整数的阶乘 public static int printJieCheng(int m){ int jieCheng = 1; for(int i = 1;i < m; i++){ jieCheng *= i; } return jieCheng; } }
4、类的成员方法
（1）本类中方法，可以直接使用本类的属性
（2）本类中方法，可以直接调用本类的方法
（3）如果在别的类中使用，需要用“ 对象. ”调用
（4）？ static 有影响
/*声明一个圆类，有属性：半径radius 给圆类增加成员方法： (1)求圆的面积的方法 */ class Circle{ double radius; //(1)求圆的面积的方法; 返回值：面积 //形参：是否需要？这里不需要，因为对象中已经有半径值 double getArea(){ double area = Math.PI * radius * radius; return area; } double getPerimeter(){ return 2 * Math.PI * radius; } String getInfo(){ return "圆的半径是：" + radius + "，它的面积是：" + getArea() + "，它的周长：" + getPerimeter(); } } class TestCircle{ public static void main(String[] args){ //(1)先创建圆对象 Circle c1 = new Circle(); //(2)求面积，求哪个圆的面积 double d = c1.getArea(); System.out.println("面积：" + d); //(3)设置半径的值 c1.radius = 2.5; d = c1.getArea(); System.out.println("面积：" + d); System.out.println("周长：" + c1.getPerimeter()); System.out.println(c1.getInfo()); } }
5、方法的参数传递机制
实参给形参传值
形参：在声明方法的()中的参数列表，
【修饰符】 返回值类型 方法名（数据类型 形参名, 数据类型 形参名， 。。。）{}
实参：在调用方法的()中的参数列表，
【变量 = 】 方法名(值1，值2，值3, 。。。); 这个值可能是常量值，例如：(4,6)，也可能是表达式，例如：(2*3)，也可能是变量，例如(a,b)
1、形参的数据类型是基本数据类型
实参给形参传递的是“数据值”，“形参”是“实参”的一个“副本”，对形参的修改不会影响实参。
方法的参数传递机制：实参给形参传值
主方法和你所定义的方法在内存中是两个互相独立的空间，当你调用自己定义的方法执行完之后，它就会撤掉，变成垃圾准备回收了。
{ public static void main(String[] args) { int i = 0; change(i);//i=0，调用change函数,完成之后，它在内存中就会撤掉；主方法和change方法是两个独立的内存。 System.out.println("调用方法后" + i); //i=0 i = i++; //i=0,先把他load到操作栈里边，i再自增i=1,再把操作栈里的值赋值给i； //System.out.println(i++); //如果运行这一步,输出0，则下面输出i=1 System.out.println("i = " + i); //i=0 } public static void change(int i){ i++; System.out.println(i); //i=1 } }
2、形参的数据类型是引用数据类型
实参给形参传递的是“地址值”，意味着“形参”和“实参”同时指向“同一个”对象，
那么“形参”修改了它的属性，也意味着“实参”的属性也被修改了。
实参把它的地址值传给了形参，new出来的对象是放到堆里边的，主方法和自己定义的方法还是两个互相独立的内存空间，但是它们有相同的地址值，通过地址值把变量修改之后，实参和形参指向的是同一个对象，修改都会改变。它撤离之后，主方法中的那个变量还是修改之后的变量。
特殊情况：如果形参是String，Integer等不可变对象时，那么无论怎么修改形参都和实参无关的。
因为形参已经指向新的对象。
String对象是不可变的，但当它发生改变比如字符串的拼接时，它就会产生一个新的对象（y = x，跟这种是一样的，改变的是地址值，对象不一样了），新的字符串跟原来无关的，这时自己定义的方法执行完之后它还是会撤离的，新的对象跟着一起撤离，原来主方法中的字符串还是在的，它不会变。
class TestPassValue{ public static void main(String[] args){ toDouble1(3); MyDate d = new MyDate(); //把变量MyDate d放到栈里边，一个单独的内存空间,会有一个地址值如0x666； 而new产生对象是放在堆里边的,x默认为0，把它改成3； d.x = 3; toDouble2(d); //主方法和自己定义的方法是两个独立的内存空间，但有一个相同的地址值，通过myCanShu找到堆里边的x，把它改成原来的3倍大，执行完后撤走。 //System.out.println(d.x); int[] array = {3,2,5,9,1,4,0}; sort(array);//array实参把数组的首地址给形参arr，意味着arr和array指向同一个数组，对arr的排序就是对array的排序。 //发现可以实现排序 String s = "I Love"; //虽然没有new关键字，但它还是对象，它不是存在栈里边，在常量池里边，value=”I Love”，字符串的对象 change(s); //实参s把地址值给了形参String str = s；但String对象是不可变的，一旦改变如拼接、截取等，就会产生一个新的字符串对象。--> value=I LoveChina System.out.println("s = " + s); //产生新对象之后，原来的value=I Love就不要了，自己定义的方法执行完就会撤离，这时候你原来在主方法中的s=I Love还是在的。 } //产生的是新对象，跟原来的没有关系，这是个陷阱。 public static void toDouble1(double num1){ //形参为基本数据类型时,形参的改变不会影响到实参 System.out.println(num1); num1 *= 2; System.out.println(num1); } public static void toDouble2(MyDate myCanShu){ //形参为引用数据类型时,形参修改了它的属性，实参也要改变。 System.out.println(myCanShu.x); myCanShu.x *= 3; //变量MyDate myCanShu，会有一个地址值0x666,这个方法单独开一个内存空间，隐含了一个MyDate myCanShu = d ; System.out.println(myCanShu.x); } //定义一个对数组排序的方法 //假如是有3个元素的数组 //i=1, j=0,1 //i=2, j=0 public static void sort(int[] arr){ //形参为数组(数据类型+变量名) //foreach循环 for(int num : arr){ System.out.print(num); } for(int i = 1; i < arr.length; i++){ for(int j = 0; j < arr.length-i; j++){ if(arr[j] > arr[j+1]){ int temp = arr[j]; arr[j] = arr[j+1];; arr[j+1] = temp; } } } System.out.println(); for(int num : arr){ System.out.print(num); } } public static void change(String str){ //形参为String引用数据类型时 //特殊情况：如果形参是String，Integer等不可变对象时，那么无论怎么修改形参都和实参无关的。 //因为形参已经指向新的对象。 System.out.println(); str += "China"; System.out.println(str); } } class MyDate{ int x; }
6、命令行参数
/* 命令行参数：（了解） 给main()传递的实参，称为命令行参数 如果要给main()的形参传值，可以用如下的格式： java 类名 实参1 实参2 实参3... 参数： 形参 实参 命令行参数 */ class TestCommandParam{ //public static是修饰符 //void：表示main没有返回值 //main：方法名 //String[] args：形参 public static void main(String[] args){ System.out.println("参数的个数：" + args.length); //参数的个数：0 for(int i=0; i<args.length; i++){ System.out.println(args[i]); } } }
参数--可变参数
* 参数： * （1）形参 * 在方法的声明时，方法签名中()声明额参数就是形参 * 形参的形式：(数据类型 形参名) * (数据类型1 形参名1,数据类型2 形参名2) * ... * （2）实参 * 在方法的调用时，方法()中传的值、变量、表达式都是实参，作用是给形参赋值 * * 实参列表的个数、数据类型、顺序必须与形参列表一一对应 * * （3）命令行参数：给main()传递的实参，称为命令行参数 * java 类名 参数值1 参数值2 ... * * （4）可变参数： * 在声明方法时，某个形参的形式： 数据类型... 形参名 * 在调用方法时，这个形参对应的实参，可以传递0~n个值 * * 如何声明可变参数？ * 【修饰符】 返回值类型 方法名(数据类型... 可变参数名){ * } * 【修饰符】 返回值类型 方法名(其他形参列表, 数据类型... 可变参数名){ * } * * 要求： * （1）声明时： * 一个方法，只能有一个可变参数，并且可变参数必须是最后一个 * （2）调用时： * 非可变参数的部分，原来该怎么传还怎么传； * 可变参数的部分，（A）可以传对应数据类型的0~n个的值（B）还可以传对应类型的数组 * * 需求：声明一个方法，可以找出1~n个整数中的最大值
public class TestVariableParam { public static void main(String[] args) { //例如：找出5,3,2,8中的最大值 /*int[] array = {5,3,2,8}; int max = getMax(array); System.out.println("最大值：" + max);*/ int max = getMax(5,3,2,8); System.out.println("最大值：" + max); max = getMax(9); System.out.println("最大值：" + max); int[] nums = {6,7,8,2}; max = getMax(nums[0], nums); System.out.println("最大值：" + max); } //声明一个方法，可以找出1~n个整数中的最大值 //返回值类型：int，因为要返回“最大值” //形参列表： //方式二：int a, int... args //int... args，在声明它的方法中，和“数组”一样使用即可 public static int getMax(int a, int... args){ //(1)先假设a最大 int max = a; //(2)用max中与args中的值一一比较 for(int i=0; i<args.length; i++){ if(max < args[i]){ max = args[i]; } } return max; } //声明一个方法，可以找出1~n个整数中的最大值 //返回值类型：int，因为要返回“最大值” //形参列表： //方式一：int[] /* public static int getMax(int[] arr){ //判断数组不为空 if(arr!=null && arr.length>0){ //(1)假设第一个元素最大 int max = arr[0]; //(2)用max中的值与剩下的元素一一比较 for (int i = 1; i < arr.length; i++) { if(max < arr[i]){ max = arr[i]; } } //(3)返回max return max; }else{ //抛出异常 throw new RuntimeException("数组不能为空"); } }*/ }
public class TestVariableParam2 { public static void main(String[] args) { System.out.println(getSum()); System.out.println(getSum(1,2)); System.out.println(getSum(0,1,2,3,4,5,6)); int[] arr = {4,5,6,7,2}; System.out.println(getSum(arr)); } //需求：求n个整数的和，n可以是0个，也可以是很多个 public static int getSum(int... nums){ int sum = 0; for (int i = 0; i < nums.length; i++) { sum += nums[i]; } return sum; } }
/* * 按照方法的重载：不属于重载 * 编译器认为它们是一样的，int[]...和int[]是一样的 */ public class TestOverload { public static void main(String[] args) { int[] arr = {1,2,3,4}; //getSum(arr);//如果假设下面是对的， 那么这句就不知道调用哪个了 } /*public static int getSum(int... args){ return 0; } public static int getSum(int[] args){ return 0; }*/ }
/* * 非严格意义说，是重写，但不推荐这么，int[]和int...不完全等价 */ public class TestOverride { public static void main(String[] args) { Base b = new Sub(); int[] arr = {1,2,3,4,5}; b.test(arr);//如果传数组，没问题，编译时类型和运行时类型都可以处理 // b.test(1,2,3,4);//编译时按父类编译，就会报错 Sub s = new Sub(); // s.test(1,2,3,4); } } class Base{ public void test(int[] args){ System.out.println("父类的test"); } } class Sub extends Base{ public void test(int... args){ System.out.println("子类的test"); } }
方法的重载：Overload
在同一个类中，出现了两个或多个“方法名称相同”、“形参列表不同”的方法，
这些方法我们称为“方法的重载”，和返回值类型无关。
形参列表不同：个数、数据类型不同
package day05; /*一、面向对象思想的落地法则一 * 1.设计类，并设计类的成员（成员变量&成员方法） * 2.通过类，来创建类的对象（也称作类的实例化） * 3.通过“对象.属性” 或 “对象.方法”来调用，完成相应的功能 * * 二、创建的多个对象，彼此各拥有一套类的属性。当对其中一个类的对象进行修改时， * 不会影响到其他对象的属性值。 * * 三、类的属性（成员变量） * 成员变量 vs 局部变量 * 相同点：1.遵循变量声明的格式：数据类型 变量名 = 初始值 * 2.都有作用域 * 不同点：1.声明的位置的不同：成员变量：声明在类里边，方法外 * 局部变量：声明在方法内，方法的形参部分，代码块内 * 2.成员变量的修饰符有四个：public private protected 缺省 * 局部变量没有修饰符，与所在的方法修饰符相同。 * 3.初始化值：一定会有初始化值。 * 成员变量：如果在声明的时候，不显示的赋值，那么不同数据类型会有不同的默认初始值。 * byte short int long ===>>0 * float double ===>> 0.0 * char ===>空格 * boolean ==> false * 引用类型变量 ==> null * 局部变量：一定要显式的赋值。（局部变量没有默认初始值） * 4.二者在内存中存放的位置不同：成员变量存在于堆空间中；局部变量：栈空间中 * 总结： * 关于变量的分类：1）按照数据类型的不同：基本数据类型（8种） & 引用数据类型 * 2）按照声明的位置不同：成员变量 & 局部变量 * * 四：方法 * 1）实例：public void eat(){//方法体} * public String getName(){} * public void setName(String n){} * 格式：权限修饰符 返回值类型（void:无返回值/具体的返回值） 方法名（形参）{} * 2）关于返回值类型：void：表明次方法不需要返回值 * 有返回值的方法：在方法的最后一定要有return + 返回值类型对应的变量 * 记忆：void与return不可以同时出现一个方法内，像一对“冤家” * 3）方法内可以调用本类的其他方法或属性，但是不能在方法内在定义方法！ * */ public class Zoo { public static void main(String[] args){ //基本数据类型的声明：数据类型 变量名 = 初始化值 int i = 10; //类的实例化：如下的a1就是一个实实在在的对象 Animal a1 = new Animal(); //int[] arr = new int[10]; //通过对象调用属性 a1.name = "kris"; a1.age = 3; System.out.println("name:" + a1.name + "age:" + a1.age); //name:krisage:3 //通过对象调用方法 a1.eat(); //动物进食 a1.sleep(); //动物休眠 //再创建一个类的对象 Animal a2 = new Animal(); System.out.println("name:" + a2.name + " age:" + a2.age ); //name:null age:0 a2.name = "小花"; System.out.println("name:" + a1.name + " age:" + a1.age); //name:kris age:3 System.out.println("name:" + a2.name + " age:" + a2.age); //name:小花 age:0 //a3不意味着相较于a1重新创建的一个对象，而是a1与a3共同一个对象的实体。 Animal a3 = a1; System.out.println("name:" + a3.name + " age:" + a3.age);//与a1一样 name:kris age:3 a3.name = "小熊熊"; System.out.println("name:" + a1.name + " age:" + a1.age); //name:小熊熊 age:3 System.out.println(a2.getName()); //a2.name; System.out.println(a2.desc()); } } class Animal{ //1.属性 String name; int age; //2.方法 public void eat(){ System.out.println("动物进食"); } public void sleep(){ System.out.println("动物休眠"); } public String getName(){ return name; } public int getAge(){ return age; //它后边不能声明语句了如System.out.println("hello"); } //当通过对象调用此方法时，会将方法的方法的返回值提供给方法的调用者，也就是当前的对象。 public String desc(){ if(age > 2){ return "洽同学少年"; }else{ return "回去看电视吧"; } } public void setName(String n){ //局部变量 name = n; } public void addAge(){ int i = 2; //局部变量 age += i; } public void info(){ //可以在方法内调用本类的其他方法，但是不可以在方法内定义新的方法 eat(); sleep(); } // System.out.println("hello"); 不能在类里边单独语句输出，要输出也得在方法内 }
3. 类的第三个成员：构造器
类的成员：属性、方法、构造器、代码块、内部类 构造器，又称为构造方法 构造器的作用： （1）和new一起使用时，创建对象用 （2）可以在创建对象的同时，为属性初始化，或赋初始值。 构造器的特点： （1）所有的类都有构造器， 如果你自己没有声明，那么编译器将会自动生成一个默认的无参构造器。 如果你手动声明了构造器，那么编译器就不会再自动生成无参构造了，如果你需要无参构造，必须自己写。 （2）构造器可以重载 （3）构造器的名称必须与类名相同，并且没有返回值类型，也不写void 构造器的声明语法格式 【修饰符】 class 类名{ 【修饰符】 类名(){ .... } 【修饰符】 类名(形参列表){ .... } } */
标准的get/set: public xxx的类型 getXxx(){ return xxx; } public void setXxx(xxx的类型 xxx){ this.xxx = xxx; } 这里xxx表示属性名
构造器的标准格式： //无参构造 public 类名(){ } //有参构造 public 类名(属性1的数据类型 属性1的名称，属性2的数据类型 属性2的名称，.。。){ this.属性1 = 属性1; this.属性2 = 属性2; .... }
this关键字
this关键字：当前对象 用法： （1）this.属性 为了解决，局部变量（例如，形参）和成员变量（例如：属性）重名时， 可以在成员变量的前面加“this.”用于区别 （2）this.方法 基本不用，但是可以这样用；表示访问当前对象的方法 （3）this()或this(实参列表) 表示访问本类的其他的构造器 要求：this()或this(实参列表)必须在构造器的首行
class TestThis{ public static void main(String[] args){ Employee emp1 = new Employee(); //无参构造创建对象 System.out.println(emp1.getInfo()); Employee emp2 = new Employee(1002,"李四"); //两个参数的创建对象 System.out.println(emp2.getInfo()); Employee emp3 = new Employee(1003,"王五",25,"1111","1245555","beijing"); //6个参数的创建对象 System.out.println(emp3.getInfo()); } } class Employee{ private int eid; private String name; private int age; private String tel; private String cid;//身份证号 private String address; public Employee(){ System.out.println("一个新员工入职了！"); //不管我从下面两个哪个构造器进来，我都想执行下这句话，则在下面两个构造器下面加this()；而this(eid,name)是先 } //去找它上边的构造器，它再去执行这句话；不能跳过这一步。 public Employee(int eid, String name){ //创建对象的时候我不想要这么多，比如说eid和name是员工必填的 this();//它必须在构造器的首行 this.eid = eid; this.name = name; } public Employee(int eid, String name, int age, String tel, String cid, String address){ //要么用无参构造，要么就要用6个参数构造 //this.eid = eid; //this.name = name; //这两句跟前边两句是一样的 this(eid,name);//调用自己的另一个构造器为属性赋值，//它必须在构造器的首行；；把它俩写一块，先传给eid、name，然后它再传给上边的int eid和String name;它再赋值 this.age = age; this.tel = tel; this.cid = cid; this.address = address; } public String getInfo(){ return eid + "\t" + name + "\t" + age + "\t" + tel + "\t" + cid + "\t" + address; } }
static关键字
static方法不可以访问非static的变量；不可以从一个static方法内部发出对非static方法的调用。
* 类的成员：属性、方法、构造器、代码块、内部类 * * 关键字：static * * static是一个修饰符 * 一、static可以用来修饰什么？ * 可以修饰成员（属性、方法、代码块、成员内部类），不能修饰最外面的类，也不能修饰构造器； * * 二、用它修饰后有什么不同？ * 1、static修饰属性 * （1）static修饰的属性是该类所有对象“共享”的 * * 为了区别，把static修饰的属性，称为“类变量”，没有static修饰的属性，称为“实例变量” ; 类变量是共享的，实例变量是独立的 * * （2）static修饰的静态变量的值存储在“方法区”； 类变量是存储在“方法区”，实例变量存储在“堆”，局部变量存储在“栈”
static修饰的成员变量和成员方法独立于该类的任何对象。 * * （3）static修饰的属性，初始化的时机不同，在“类初始化”时初始化的，比创建对象要早，并且只初始化一次 * （4）static修饰的属性，它的get/set也是static的； * * 如何学习修饰符？ * （1）它可以用来修饰什么？ * （2）用它修饰后有什么不同？ * * 权限修饰符： * private：可以修饰成员（属性、方法、构造器、成员内部类），不能修饰最外面的类 * 缺省：可以修饰外部类和成员（属性、方法、构造器、成员内部类） * protected：可以修饰成员（属性、方法、构造器、成员内部类），不能修饰最外面的类 * public：可以修饰外部类和成员（属性、方法、构造器、成员内部类） * * 范围不同： * ..... *
* 2、static修饰方法 * （1）可以不用“对象."就可以调用，可以使用"类名.”进行调用 * 例如：java.lang.Math * public static double sqrt(double a)：double d = Math.sqrt(x); * public static double random()：double d = Math.random(); * * 例如：java.util.Arrays * public static void sort(int[] a)：Arrays.sort(数组); * public static int[] copyOf(int[] original,int newLength)： 新数组名 = Arrays.copyOf(数组,新数组的长度) * * 例如：java.util.Scanner * public String next()：没有static，所以不能用“类名." * 发现Scanner没有无参构造 * * Scanner input = new Scanner(System.in); * String name = input.next(); * * （2）static修饰的方法中，不能使用this,super关键字 * （3）static修饰的方法中，不能直接使用非static的属性和方法 * （4）static修饰的方法，不能被重写
public static void main(String[] args){ Teacher tea = new Teacher(); System.out.println(this.name);//编译错误，this不能在static方法中使用的 }
4. 类的第四个成员：代码块
* 类的成员： * 1、属性：存储对象的数据、信息 * 2、方法：代表对象的功能、行为特征 * 3、构造器：（1）和new一起创建对象(2)在创建对象时给属性赋值 * * 类的第四个成员：代码块 * 1、代码块的作用：为属性初始化 ① 非静态代码块：为非静态属性初始化，或者说辅助实例（对象）初始化 ② 静态代码块：为静态属性初始化，或者说辅助类初始化 * * 2、语法格式 * * 【修饰符】 class 类名{ { //非静态代码块 } static{ //静态代码块 } } * * 3、什么时候执行代码块 * （1）静态代码块：在类初始化时执行，只执行一次 * （2）非静态代码块：在实例初始化时执行，创建一个对象，执行一次 * （3）子类的初始化时，如果父类没有初始化，会先初始化父类 * （4）子类的实例初始化会导致父类的实例初始化 * 先执行父类的<init>，然后执行子类的<init> * * * 类初始化：每一个类，编译器会自动生成一个<clinit>()，称为类初始化方法。这个方法的方法体由以下两部分组成： * （1）静态变量的显式赋值语句 * （2）静态代码块中的语句 * 这两个部分，谁在上面谁先执行。 * * 实例初始化：每一个构造器，编译器会自动生成一个对应的<init>()，称为实例初始化方法。这个方法的方法体由以下三部分组成： * （1）非静态变量的显式赋值语句 * （2）非静态代码块中的语句 * （3）对应构造器的语句 * （1）和（2）仍然是谁在上面谁先执行，构造器永远是最后执行 * * 成员变量：我们通常说的属性，它分为实例变量和类变量，大多数人在说成员变量时，一般他说的是实例变量。
父类初始化< clinit >---->>>子类初始化< clinit >--->> 父类的实例初始化< init > --->>子类的实例初始化< init >；一开始都是静态的先初始化。
* 类初始化和实例初始化 * （1）先类初始化 * A：如果父类没有初始化，会先初始化父类 * B：类的初始化执行的是<clinit>方法，它由两部分组成： * (a)静态变量的显式赋值语句(b)静态代码块的语句,(a)(b)谁在上谁先执行 * * （2）实例初始化 * A：创建子类对象时，也会导致父类的实例初始化方法执行 * B：每一个构造器都会有对应的实例初始化方法 * C：每一个实例初始化有三部分组成： * (a)非静态变量的显示初始化代码(b)非静态代码块的语句(c)构造器 * (a)(b)谁谁在上谁先执行，构造器后执行
5. 类的第五个成员--内部类
* 内部类：定义在另一个类里面的类叫做内部类。把外面的这个类称为外部类。
* 例如：
* 【修饰符】 class 外部类{
//成员内部类，在外部类方法的外边。
【修饰符】 class 内部类{
}
【修饰符】 返回值类型 方法名(【形参列表】){
//局部内部类，在方法体的里边
【修饰符】 class 内部类{
}
}
}
* 内部类分为：
* 1、成员内部类
* 在外部类的里面，在外部类的方法的外面。
* （1）静态成员内部类：有static修饰
* （2）非静态成员内部类：没有static修饰
*
* 2、局部内部类
* 在外部类的方法体里面。
* （1）有名局部内部类
* （2）匿名局部内部类
*
* 为什么要用内部类？
* 类的概念：一类具有相同特性的事物，用一个Java类进行描述。例如：学生类，身体类
* 内部类也是类，当某个事物的内部，存在另一个事物，发现也需要一个Java类进行描述，而且这个内部的事物只为外部类服务，
* 基本上不会单独使用，那么这个时候用内部类比较合适。定义内部类还有一个好处，内部类可以使用外部类的私有成员。
成员内部类--静态内部类
* 一、静态内部类 * 1、语法格式： * 【修饰符】 class 外部类 { * //静态成员内部类 * 【修饰符】 static class 内部类{ * } * } * * 2、静态内部类也是一个类 * （一）静态内部类的成员（都可以） * （1）属性：类变量和实例变量 * （2）方法：静态方法和非静态方法，抽象方法(只有静态内部类是个抽象类就可以) * （3）构造器：无参构造，有参构造 * （4）代码块：静态代码块和非静态代码块 * （5）内部类：各种内部类 * * （二）静态内部类可以继承父类实现接口 * * （三）有自己的字节码文件 * 外部类名$静态内部类名.java * * 3、如何使用静态内部类 （必须在方法中才能调用） * （1）在外部类中使用静态内部类 和原来使用其他类一样。 静态内部类作为外部类的一个静态成员； * 在外部类的静态方法中使用静态内部类（调用内部类的静态方法）：如Inner.inTest(); 在外部类的非静态方法中，要创建对象才能调用内部类的成员。 * （2）在外部类的外面（如测试类中）使用静态内部类； 使用静态内部类，前面要加“前缀”，“外部类名.内部类名”；
如调用内部类的静态方法（类名.直接调用）：Outer.Inner.intest()；
如调用内部类的非静态方法（要创建对象）：Outer.Inner in = new Outer.Inner()； in.method()； * * （3）在静态内部类中，使用外部类的成员；在静态内部类中，不能使用外部类的非静态成员（属性和方法），其他的都能用（如在内部类里边的静态方法可以直接调用外部类的静态方法）
public class TestInnerStatic { public static void main(String[] args) { //调用内部类的静态方法 Outer.Inner.inTest();//Inner是Outer的静态成员,所以可通过Outer.访问; //inTest()是Inner的静态成员,所以可以通过Inner.访问 //调用内部类的非静态方法 Outer.Inner in = new Outer.Inner(); //需要对象来调用; //左边：Outer.Inner是表示类型名 //右边：调用Inner的构造器，其实这里静态内部类的构造器，“相当于是一个静态的构造器” in.method(); } } class Outer{ static class Inner{ public static void inTest(){ System.out.println("静态内部类Inner的静态方法inTest"); staticTest(); //调用外部类的静态方法 //outMethod();//错误的，静态内部类成员不能使用外部类的非静态成员 } public void method(){ System.out.println("静态内部类Inner的非静态方法"); } } public Inner getInner(){ Inner in = new Inner(); //创建内部类的对象 return in; } public static void outTest(){ Inner.inTest(); //调用Inner的静态方法 } public static void staticTest(){ System.out.println("外部类Outer的静态方法staticTest"); } public void outMethod(){ System.out.println("外部类Outer的非静态方法outMethod"); } }
成员内部类-非静态内部类
* 二、非静态的成员内部类 * 1、语法格式： * 【修饰符】 class 外部类{ * //非静态成员内部类 * 【修饰符】 class 内部类{ * } * } * * 2、非静态内部类也是一个类， 里边不能有静态相关的 * （一）非静态内部类的成员（都可以） * （1）属性：实例变量 * （2）方法：非静态方法，抽象方法(只有非静态内部类是个抽象类就可以) * （3）构造器：无参构造，有参构造 * （4）代码块：非静态代码块 * （5）内部类：各种非静态内部类 * * 和静态无缘了，里面不能有静态成员了，其他都可以。（特殊） * * （二）非静态内部类可以继承父类实现接口 * * （三）有自己的字节码文件 * 外部类名$非静态内部类名.java * * * 3、如何使用非静态内部类 * （1）在外部类中使用非静态内部类；在外部类的静态成员中不能使用非静态的内部类（特殊）；外部类的静态成员不能使用非静态内部类的方法和属性等；
就是在外部类中，静态方法不能使用非静态内部类。
* （2）在外部类的外面使用非静态内部类（如在测试类中使用） 第一步：先创建外部类的对象 第二步：通过外部类的对象才能访问内部类的构造器，创建内部类的对象 或者 通过外部类的某个方法来返回内部类的对象 第三步：才能通过内部类的对象访问它的成员
如 Outer out = new Outer(); out对象可以调用外部类的所有方法和属性；
Outer.Inner in = out.new Inner(); 等价于 Outer.Inner in = new Outer().new Inner()； （非静态成员内部类的实例化）
in.inMethod(); （用in对象调用里边的非静态方法。）
但在开发中一般都是这样写：Outer.Inner in2 = out.getInner(); //在外部类中写一个getInner()方法
public Inner getInner(){
Inner in = new Inner();
return in;}
* （3）在非静态内部类中，使用外部类的成员； 直接使用，没有限制
如在非静态内部类中，非静态方法可以直接调用 外部类的静态方法或者非静态方法或者属性。
public class TestNonstaticInner { public static void main(String[] args) { Outer out = new Outer(); //因为Inner是外部类Outer的非静态成员,需要先创建外部类的对象; Outer.Inner in = out.new Inner(); //左边是Inner类型; 右边是通过外部类的对象才能访问内部类的构造器; in.inMethod(); //非静态内部类的对象in //out.new Inner();写太古怪了---> 如果要获取非静态内部类的对象,开发中一般这么写: /*Outer.Inner in2 = out.getInner(); //写一个getInner()方法 in2.inMethod();*/ } } class Outer{ private String name = "Outer类"; class Inner{ //成员非静态内部类 public void inMethod(){ outerMethod(); //成员非静态内部类可以使用外部类的 静态方法和非静态方法. outerTest(); } } public Inner getInner(){ Inner in = new Inner(); return in; } public void outerMethod() { System.out.println("外部类的非静态方法"); } public static void outerTest() { System.out.println("外部类的静态方法"); // Inner in = new Inner();//静态方法outTest是不能使用非静态的成员内部类Inner } }
//要求编写一个Sub类，它继承Inner类，在测试类中，创建Sub对象，并且调用method() /* * 1、继承的语法格式 * 【修饰符】 class 子类名 extends 父类的类型名{ * } * * 问题：Inner的类型名是什么？包名.Outer.Inner * * 2、父类是抽象类，子类要重写父类的抽象方法 * * 3、子类继承父类时，一定会调用父类的构造器，默认调用父类的无参构造 * super() * * 问题： * (1)父类Inner是否有无参构造器？有，所有类没有写构造器，都有默认的无参构造 * (2)父类Inner的构造器要如何调用？需要外部类的对象 */ public class TestOuter { public static void main(String[] args) { Outer out = new Outer(); Sub s = new Sub(out); s.method(); } } class Outer{ public abstract class Inner{ public abstract void method(); //定义一个抽象方法 } } class Sub extends Outer.Inner{ public Sub(Outer out) { out.super(); } @Override public void method() { System.out.println("重写父类的抽象方法"); } }
局部内部类 -- 有名的局部内部类
* 三、有名字的局部内部类（很少）（了解） * 1、语法格式 * 【修饰符】 class 外部类{ * 【修饰符】 返回值类型 方法名(【形参列表】){ * 【修饰符】 class 局部内部类{ * } * } * } * * 局部内部类：在方法体、代码块中声明的，和方法的局部变量很多方面是一样 * * 2、局部内部类也是一个类 * (1)有自己的字节码文件 * 外部类名$编号局部内部类名 * 这里用编号原因，在不同的方法中，局部内部类可能同名 * (2)成员 * A：属性 * B：方法 * C：构造器 * D：代码块 * E：内部类 * 不能有静态的成员 跟非静态内部类是一样的 * * 即唯一能声明静态成员的内部类只有一个“静态内部类”，其他内部类统统都不可以有静态成员。 * * 3、使用 * （1）在外部类中使用局部内部类 * 只能在声明局部内部类的下面才能使用，即先声明后使用（即要先 class，再实例化），并且有作用域的限制（在这个方法内）。
* （2）在外部类的外面 肯定不行
* (3)在局部内部类中（只有非静态方法）使用外部类的成员
* 局部内部类是否可以使用外部类的非静态的成员，取决于所在方法是否是静态的，如果方法是静态的就不可以使用了，如果是非静态的可以使用。
如果是非静态方法里的局部内部类：可以使用外部类的静态属性、方法或者非静态的都可以；（没有静态方法）
* (4)在局部内部类中可以使用外部类的“局部常量”，即有final修饰 （必须有final修饰，即常量，不能使用变量。）
* JDK1.8之前：必须手动加final； JDK1.8之后，自动加final
*/
public class TestLocalInner { private static int i; private int j; public static void main(String[] args) { // Inner i = new Inner(); // a = 10; int b = 20; class Inner{ public void inTest(){ System.out.println(i); // System.out.println(j);//不能使用外部类的非静态成员，原因main是静态的 System.out.println(b); } } int a = 10; } public void method(){ // Inner in = new Inner(); // a = 20; Object obj = test();//obj编译时Object，运行时是Inner } //返回值类型Object，返回值Inner的对象 public Object test(){ int c = 10; class Inner{ public void inTest(){ System.out.println(i); System.out.println(j);//这里可以使用j，因为test()是非静态的 System.out.println(c); //此c非彼c,因为上面的c是局部变量，它的生命周期很短和存储的位置在栈，而我们的Inner对象生命周长，它的信息是在堆中 //堆中是无法直接使用栈中的变量，所以必须在堆中重新弄一个c的副本 } } Inner in = new Inner(); return in; } } class Other{ }
局部内部类--匿名内部类
* 四、匿名内部类（重要） * 1、语法格式： * 外部类{ * 方法{ new 父类(【实参列表】){ 成员 } new 父接口(){ 成员 } * } * } * * 2、特点 * （1）没名字 所以不写构造器； 不能有构造方法 * （2）匿名内部类必须在声明类的同时就要创建对象，也只有唯一的一个对象 * （3）必须指定匿名内部类的父类或父接口 * * 3、匿名内部类也是类 * （1）有字节码文件； 外部类名$编号.class * （2）也有成员 （不能定义任何静态成员、方法、类； 匿名内部类不能是public、protected、private、static） * 属性、方法、代码块、内部类、构造器都有，不能有静态的，一般不会写这么多。 * 一般匿名内部类都是重写父类的方法或实现接口的抽象方法 * * 4、在匿名内部类中要使用外部类的成员的话 * （1）是否可以使用外部类的非静态成员，要看所在的方法是否是静态的 * （2）只能使用外部类的局部常量，必须有final *
public class TestAnoymousInner { public static void main(String[] args) { final int A = 10; //匿名内部类的匿名对象调用test() new Father(){ //重写父类的方法 public void test(){ System.out.println("子类的方法1" + A); } }.test(); //多态引用 Father f = new Father("尚硅谷"){ //重写父类的方法 public void test(){ System.out.println("子类的方法2"); } }; f.test(); //右边用匿名内部类的形式实现了MyInter接口，并创建了实现了对象 MyInter m = new MyInter(){ @Override public void method() { System.out.println("实现接口的抽象方法"); } }; m.method(); } } class Father{ private String info; public Father(){ } public Father(String info){ this.info = info; } public void test(){ System.out.println("父类的方法"); } } interface MyInter{ void method(); }
* java.util.Arrays数组工具类有sort方法 * * public static void sort(Object[] a)：根据元素的自然顺序对指定对象数组按升序进行排序。数组中的所有元素都必须实现 Comparable 接口 * public static void sort(Object[] a,Comparator c)：根据指定比较器产生的顺序对指定对象数组进行排序。 * 指定比较器就是Comparator的对象，用它的c.compare(元素1，元素2) * * java.util.Comparator接口：有一个抽象方法int compare(Object o1, Object o2) * * 当某个接口的实现或某个子类，只用一次，而且代码比较简洁，可以考虑使用匿名内部类 *
//要求用Arrays.sort对arr进行排序 //Arrays.sort(arr); //匿名内部类的匿名对象作为sort的实参 Arrays.sort(arr, new Comparator() { @Override public int compare(Object o1, Object o2) { Employee e1 = (Employee) o1; Employee e2 = (Employee) o2; return e1.getId() - e2.getId();//如果e1.getId()>e2.getId()返回正整数，如果小于，返回负整数，等于返回0 } }); for (Employee employee : arr) { System.out.println(employee); } //按照薪资排序 /* Arrays.sort(arr, new Comparator() { @Override public int compare(Object o1, Object o2) { Employee e1 = (Employee) o1; Employee e2 = (Employee) o2; if(e1.getSalary() > e2.getSalary()){ return 1; }else if(e1.getSalary() < e2.getSalary()){ return -1; }else{ return 0; } } });*/ Arrays.sort(arr, new MyComparator()); for (Employee employee : arr) { System.out.println(employee); } } } class MyComparator implements Comparator{ @Override public int compare(Object o1, Object o2) { Employee e1 = (Employee) o1; Employee e2 = (Employee) o2; if(e1.getSalary() > e2.getSalary()){ return 1; }else if(e1.getSalary() < e2.getSalary()){ return -1; }else{ return 0; } } } class Employee { private int id; private String name; private double salary; ... }
例如:
public static void main(String[] args) { printArea(new Rectangle("矩形", 2.0, 2.0)); //把矩形 //一次传用匿名内部类实现Graphic的圆对象（包含属性半径，实现抽象方法） printArea(new Graphic("圆") { @Override public double getArea() { double radius = 1.0; return Math.PI * radius * radius; } }); Graphic[] gra = new Graphic[3]; gra[0] = new Rectangle(2.1, 2.1); gra[1] = new Rectangle(2.2, 3.1); gra[2] = new Rectangle(1.2, 4.0); for (Graphic graphic : gra) { System.out.println(graphic); } //调用Arrays.sort(数组，Comparator)的方法排序 Arrays.sort(gra, new Comparator() { @Override public int compare(Object o1, Object o2) { Graphic g1 = (Graphic) o1; Graphic g2 = (Graphic) o2; if(g1.getArea() > g2.getArea()){ return 1; }else if(g1.getArea() < g2.getArea()){ return -1; }else{ return 0; } } }); for (Graphic graphic : gra) { System.out.println(graphic); } } public static void printArea(Graphic g){ //System.out.println(g);//自动调用g.toString()，打印对象，自动调用toString() //自己拼 System.out.println("图形名称：" + g.getName() +"，面积：" + g.getArea()); }
