一、属性

1、语法

　　数据类型 属性名 【= 属性值】;

2、特点

①属性的数据类型可以为任意类型，包含基本类型或引用类型
②属性可以不用手动赋值，有默认值
　　int——0
　　double——0.0
　　char——\u0000
　　boolean——false
　　引用类型——null
③属性伴随着对象存放在堆中，不同对象的属性相互独立，互不影响
④变量根据作用域不同，分为以下两类
　　全局变量：又称为属性，定义在类体中，作用域为整个类体以及其他类
　　局部变量：定义在方法或某个代码块内，作用域为所在的方法或代码块

3、局部变量和全局变量的区别：★

	作用域	生命周期	存储位置	访问修饰符	默认值	重命名
局部变量	定义变量的方法或某个代码块中	随着方法或代码块的执行而创建 随着执行的结束而消亡	基本类型：栈 引用类型：对象名存在栈，对象存在堆	×	×	两个局部作用域有交集时，不可以重名
全局变量	整个类体及其他类	随着对象的创建而创建 随着对象的消亡而消亡	堆	√	√	一个全局和一个局部，可以重名，默认遵循就近原则

二、方法

1、概念

理解：用于描述类或对象的行为或功能，定义在类体中，属于类的成员

2、好处

1、提高代码的重用性和维护性
2、从调用层面上，调用者不用关心方法的内部实现细节，调用比较简单。只需要知道：
　　叫什么（方法名）
　　干什么（方法功能）

3、定义语法 ★

[修饰符] 返回类型 方法名(参数列表){
　　方法体
}

4、方法五要素

（1）修饰符

特点：可选
public 公共的，任意类都可以调用该方法

（2）返回类型

说明：某些行为或功能执行结束后需要返回给调用方一个具体的值，则将值的类型标注成返回类型，如果行为或功能执行结束后没有返回值，则返回类型写成void即可
特点：
　　①一个方法至多有一个返回值，要求返回值的类型和返回类型一致或兼容
　　②返回类型可以为任意类型，包含基本或引用
　　③如果方法有返回值，则方法体中要求必须有return语句，而且return的值的类型必须和返回类型一致或兼容
　　　如果方法没有返回值，则方法体不用加return语句，如果非加，则写成 return;
　　④如果方法有返回值，则必须保证所有路径下都可以return值;
　　　　public int m(int i){
　　　　　　if(i>5)
　　　　　　　　return 10;
　　　　　　return 99;
　　　　}

（3）方法名

遵循标识符的命名规则和规范（同变量的规范）：见名知义，且遵循驼峰命名法

（4）参数列表

说明：某些方法的执行需要调用方传递源数据，否则无法执行。我们把这些源数据称为参数
特点：
　　①参数可以为多个，语法如下：
　　　　（类型 参数名1,类型 参数名1,...,类型 参数名n）
　　②参数类型可以为任意类型，包含基本类型或引用类型
　　③参数的本质就是一个局部变量，也必须赋值后才能使用，但这个赋值一般是隐式赋值的（传参时）
　　④方法定义时的参数称为形式参数，简称形参；方法调用时的参数称为实际参数，简称实参
　　　　形参和实参的类型、个数必须一致，参数名无要求

（5）方法体

可以包含0条或任意多条逻辑语句。
形式：输入、输出、变量、运算、分支、循环、方法调用

5、调用语法 ★

1、本类内方法调用：方法名(实参列表);
2、跨类中方法调用：对象或类名.方法名(实参列表);
注意：

如果待调用的方法有返回值，则最好用变量接受或做其他处理
如果待调用的方法没有返回值，则不能当成表达式做任何处理

6、调用机制 √

每次方法调用，都伴随“入栈”的操作
每次调用结束，都伴随“出栈”的操作

7、方法的传参 ★

特点：
java中方法按“值”传递。
　　参数类型为基本类型，则值代表元素内容，传递是一个拷贝，形参的改变不影响实参
　　参数类型为引用类型，则值代表地址，传递是一个地址（引用），形参的改变影响实参
示例：
　　public static void main(String[] args){
　　　　int[] arr = {1,2,3};
　　　　update(arr);
　　　　print(arr);//1 2 3
　　}
　　public static void update(int[] arr){
　　　　arr = new int[3];
　　　　arr[0]=100;
　　　　print(arr);//100 0 0
　　}
　　public static void print(int[] arr){
　　　　for(int i=0;i<arr.length;i++){
　　　　　　System.out.println(arr[i]);

　　　　}
　　}

8、方法的重载

1、定义：java中提供了一种机制，允许同一个类中多个同名但参数列表不同的方法存在
2、好处：
　　①解决了起名问题
　　②解决了记名麻烦问题
3、要求：

①同一个类中
②方法名必须相同
③参数列表必须不同（参数类型、个数或顺序至少有一样不同）
④返回类型无要求
⑤修饰符无要求

9、可变参数的方法

1、理解：jdk5.0出现的新特性。java中允许将一个类中同名，同参数类型、同返回的多个方法抽取成一个可变参数的方法

2、语法：

　　修饰符 返回类型 方法名(参数类型...参数名){
　　　　//参数当做数组类型去使用
　　}

3、好处：

　　①提高重用性
　　②提高维护性和扩展性

4、特点：

①可变参数的实参允许0个或多个参数
②可变参数的实参允许数组类型
③可变参数可以和普通类型的参数同时出现在一个形参列表，但要求可变参数必须放在最后
④一个形参列表中最多有一个可变参数
⑤可变参数的方法、普通类型参数的方法实现了重载（注：不可以和同一类型的数组参数方法构成重载），传参时：
　　遵循：先找一致类型——>兼容类型——>可变参数
　　　　A a = new A();
　　　　a.m(10);//执行方法1
　　　　pubic class A{
　　　　　　public void m(int a){ }   //方法1
　　　　　　public void m(double a){ }  //方法2
　　　　　　public void m(int... a){}//方法3
　　　　}

三、构造器

1、理解

构造器又称为构造方法，属于类中的第三大成员。
本质上同"方法"，只是没有返回类型，且对于一个对象来讲，只调用一次，并且不是通过对象或类显示调用

2、语法

[修饰符] 构造器名 （参数列表）{
　　//构造器体
}
注意：
①构造器名与类名一致！
②没有返回类型

3、好处

①用于创建对象
②可以进行初始化的操作，从一定程度上提高代码的重用性！

4、特点

①每一个类都有构造器，如果没有显式声明，系统将默认提供一个无参构造器
②如果显式声明了构造器，则系统将不再提供构造器
③构造器可以重载
④对于一个对象来讲，构造器只调用一次

注意：构造器的调用语法
方式一： 创建一个新对象
　　new 构造器名(参数列表); 
方式二：为了进行初始化（注：this或super调用构造器，只能放在构造器的而第一句，而且只能有一个）
　　this(参数列表);
　　super(参数列表)

四、初始化块

1、理解

初始化块又称为代码块，属于类中的成员，本质上同方法。但没有方法名、没有参数和返回类型，只有方法体，而且不是显式调用的，是创建对象或加载类时隐式调用

2、语法

[static]{
　　方法体
}
使用static修饰的，称为静态代码块
没有用static修饰的，称为普通代码块

3、好处

①用于初始化信息，相当于构造器的补充
②当构造器重载时，如果里面有重复的语句，为了提高代码的重用性，往往将重复的语句提到初始化块中

4、特点 ★

（1）调用时机

静态代码块 是当加载类时，被隐式调用，而且只调用一次
普通代码块 是当对象创建时，被隐式调用，而且可以加载多次

【补充】类的加载时机

①创建对象
②调用静态成员
③加载子类
④反射

（2）顺序（静态代码块和普通代码块）

如果：一个类中可以有多个静态代码块和多个普通代码块
　　静态代码块的  执行  优先于   普通代码块
注意：同一个类别的代码块的执行顺序取决于定义的先后顺序

（3）顺序（静态代码块、普通代码块、属性初始化、构造器）

如果：一个类中有多个静态代码块和多个普通代码块、属性初始化、构造器
　　静态代码块|静态属性——>普通代码块|普通属性——>构造器
注意：同一个类别的代码块的执行顺序取决于定义的先后顺序

（4）顺序（父子类中静态代码块、普通代码块、属性初始化、构造器）

如果：父子类中都有多个静态代码块和多个普通代码块、属性初始化、构造器
　　父类静态代码块|静态属性——>子类静态代码块|子类静态属性
　　——>父类普通代码块|普通属性——>父类构造器
　　——>子类普通代码块|普通属性——>子类构造器
注意：同一个类别的代码块的执行顺序取决于定义的先后顺序

（5）静态成员的特点

静态代码块中只能直接访问静态成员，不能直接访问普通成员

五、内部类

1、理解

一个类体中又完整的嵌套了另一个完整的类结构，被嵌套在里面的类，称为内部类。
嵌套其他类的类，称为外部类。
其他类，称为外部其他类。

2、好处

可以直接访问外部类的私有成员

3、分类

按定义位置不同：
　　定义在成员位置上
　　　　成员内部类（无static修饰）
　　　　静态内部类（有static修饰）
　　定义在局部位置上
　　　　局部内部类
　　　　匿名内部类

4、内部类之成员内部类

（1）语法

class Outer{
　　class Inner{
　　}
}

（2）特点

①成员内部类中可以有五大成员,但不能有静态成员。原因：静态成员的加载时机早于成员内部类！
②成员内部类可以添加访问修饰符，访问权限遵循修饰符的限定
③互访原则：

成员内部类——>外部类 ★
　　直接访问，因为里面隐含着一个Outer.this的引用。
　　注意：当成员内部类和外部类的成员重名时，默认访问的是内部类的成员，如果想访问外部类的成员，可以通过Outer.this.成员的方式访问
外部类——>成员内部类
　　通过创建对象，去访问
　　语法：new Inner().成员
外部其他类——>成员内部类
　　通过创建对象，去访问
　　语法：Outer.Inner member = new Outer().new Inner(); member.成员 
成员内部类——>外部其他类
　　通过创建对象，去访问
　　语法：new Other().成员

5、内部类之静态内部类

（1）语法

class Outer{
　　static class Inner{
　　}
}

（2）特点

1、静态内部类中可以有所有五大成员，包含普通的和静态的
2、静态内部类可以添加访问修饰符，当然也要遵循访问修饰符的权限限定
3、互访原则

静态内部类——>外部类 ★
　　直接访问外部类中的静态成员，包含私有的。但不能直接访问外部类的普通成员（遵循静态成员的特点）
　　注意：如果外部类和静态内部类中有同名成员，访问时遵循就近原则，如果非要访问外部类的成员，则通过 （外部类名.成员 ）方式访问
外部类——>静态内部类
　　情况1：如果访问里面的静态成员，则直接通过静态内部类名去访问
　　情况2：如果访问里面的普通成员，则通过创建静态内部类对象去访问。
　　　　语法：new Inner().成员
外部其他类——>静态内部类
　　通过创建对象去访问
　　语法：Outer.Inner member = new Outer.Inner();
静态内部类——>外部其他类
　　注意：和普通两个类之间的互访一样
　　通过创建对象或类名的方式去访问

6、内部类之局部内部类

（1）语法

public void method(){
　　for(int i=1;i<10;i++){
　　　　class Inner3{
　　　　}
　　}
}

（2）特点

①里面可以有五大普通成员，但不能有静态成员。原因：静态成员的加载时机早于局部内部类！
②不能添加访问修饰符
③作用域：比较小，仅仅在定义它的方法或代码块中有效，而且遵循前向引用
④互访原则

局部内部类——>外部类 ★
　　情况1：可以访问同一个作用域的局部变量，但不能更新。因为默认是final修饰（jdk8，final是系统自动提供的；jdk8之前，final是手动加入）
　　　　　　为什么里面只能访问局部常量？
　　　　　　　　局部变量的消亡时机早于局部内部类，所以局部内部类中使用的仅仅是局部变量的拷贝。如果备份可以更新，则会导致数据不一致。
　　　　　　　　为了避免这种现象，只能读取，不能更新！
　　情况2：直接访问外部类的所有成员，包含私有的
　　注意：如果外部类和内部类的成员同名，则默认遵循就近原则，如果非要访问外部类的成员，则通过（外部类.this.成员 ）方式访问
外部类——>局部内部类
　　创建对象并访问

7、内部类之匿名内部类

（1）语法

new 父类或接口名(){
　　//类体
};

（2）特点

①匿名内部类中可以有属性、方法、内部类、初始化块，但不能有构造器和静态成员
②不能添加修饰符
③作用域比较小，仅仅在定义它的方法或代码块中。
　　注意：匿名内部类的对象只有一个，可以直接拿着对象调用里面的成员或为对象起一个引用名，使用引用名调用通用的成员！
④互访原则

匿名内部类——>外部类
　　情况1：访问外部类中同一个作用域的局部变量,但要求局部变量使用final修饰（jdk8之前，final是需要手动添加；jdk8时，final是系统自动添加，不用手动添加）
　　　　原因：匿名内部类的消亡时机晚于局部变量的消亡时机，所以匿名内部类中使用的是局部变量的备份！为了避免数据不一致，所以只能读取不能更新
　　情况2：可以直接访问外部类中的成员
　　　　如果出现重名问题，则默认访问内部类的成员，如果非要访问外部类的成员，需要通过(外部类名.this.成员) 方式访问
外部类——>匿名内部类
　　new 类名(){}.成员

（3）应用场景 ★

当做实参传递给形参类型为接口的方法！