教程：b站韩顺平
目录
一、类变量
-
类变量名也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量
-
定义：
访问修饰符 static 数据类型 变量名; -
访问：
类名.类变量名（推荐） 对象名.类变量名 //静态变量的访问修饰符的访问权限和范围 和 普通属性 是一样的- static变量是对象共享，不管static变量在哪里（堆/方法区），共识：
- static变量是同一个类所有对象共享
- static变量，在类加载的时候就生成了
-
注意事项和细节讨论：
- 实用类变量的时机：让某个类的所有对象都共享一个变量时，就可以考虑使用类变量（静态变量）
- 类变量与实例变量（普通属性）的区别：类变量是该类的所有对象共享的，而实例变量是每个对象独享的
- 加上static称为类变量或者静态变量，否则称为实例变量/普通变量/非静态变量
- 实例变量不能通过 类名.类变量名 访问
- 类变量是在类加载时就初始化了，即使没有创建对象，只要类加载了，就可以使用类变量了
- 类变量的生命是随类加载开始，随类消亡销毁
二、类方法
2.1 基本概念
-
类方法，即静态方法
-
定义：
访问修饰符 static 数据返回类型 方法名(){} -
调用：
类名.类方法名() 对象名.类方法名() //前提是满足访问修饰符的访问权限和范围 -
类方法经典使用场景：
当方法中不涉及到任何和对象相关的成员，则可以将该方法设计成静态方法，提高开发效率
例如工具类中的方法：Math类、Array类等 -
注意事项：
- 类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区，类方法中无this的参数，普通方法中隐含着this的参数
- 类方法可以通过类名调用，也可以通过对象名调用
- 普通方法和对象有关，通过对象名调用，比如 对象名.方法名(参数)，不能通过类名调用
- 类方法中不允许使用和对象有关的关键字，如 this,super，普通方法可以使用
- 类方法（静态方法）中 只能访问静态变量 或静态方法
- 普通成员方法，既可以访问 普通变量（方法），又可以访问静态变量（方法）
-
小结：
- 静态方法：只能访问静态的成员
- 非静态的方法：可以访问静态成员和非静态成员
2.2 main方法
-
main()方法的形式
public static void main(String[] args){}
- main方法时虚拟机调用
- java虚拟机需要调用类的main方法，所以该方法的访问权限必须是public
- java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static
- 该方法接受String类型的数组参数，该数组中保存执行java命令时传递给运行的类的参数
- 可以直接使用name
- 静态方法main，可以访问本类的静态成员
- 静态方法main不可以访问本类的非静态成员
- 静态方法main 要访问本类的非静态成员，需要先创建对象， 再调用即可
- 理解main方法语法
在main（）方法中 ，可以直接调用main方法所在类的静态方法或静态属性
但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员
三、代码块
-
代码化块又成为初始化块，属于类中的成员【即 是类的一部分】，类似于方法，将逻辑语句封装在方法体中，通过{}包围
-
和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不能通过对象或类显示调用，而是加载类时，或创建对象是隐式调用
基本语法 [修饰符]{ 代码 }; -
tips: 修饰符 可选，要写的话，也只能写static
-
代码块分为两类：
- 使用static：静态代码块
- 没有static修饰：普通代码块- 逻辑语句可以为任何逻辑语句（输入、输出、方法调用、循环、判断）
- ;号可以写上，也可以省略
-
创建一个对象时：
- 调用 静态代码块 和 静态属性 初始化：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按照他们定义的顺序调用
- 调用 普通代码块 和 普通属性 初始化：普通代码块和普通属性初始化调用的优先级一样，如果有多个代码块和多个普通属性初始化，则按照定义顺序调用
调用构造方法
-
构造方法（构造器）的最前面其实隐含了super()和调用普通代码块，静态相关的代码块，属性初始化，在类加载时，就执行完毕，因此是优先于 构造器和普通代码执行的
-
创建一个子类时：
- 父类的静态代码块和静态属性（优先级一样，按定义顺序执行）
- 子类的静态代码块和静态属性（优先级一样，按定义顺序执行）
- 父类的构造方法
- 子类的普通代码和普通属性初始化（优先级一样，按定义顺序执行）
- 子类的构造方法
-
静态代码块只能直接调用静态成员（静态属性和静态方法），普通代码块可以调用任意成员
四、final关键字
- final：可以修饰类、属性
- 应用场景：
- 当不希望类被继承时，可以用final修饰
- 当不希望父类的某个方法被子类覆盖/重写时，可以使用final关键字修饰
- 当不希望类的某个属性的值被修改，可以使用final修饰
public final double TAX_RATE=0.08;- 当不希望某个局部变量被修改，可以使用final修饰
final double TAX_RATE-0.08;
- 细节
- final修饰的属性又称常量，一般用XX_XX_XX命名
- final修饰的属性在定义时，必须赋初值，并且以后不能在修改，赋值可以在如下位置之一【选择一个位置赋初值】
定义时：
public final double TX_RATE=0.08;
在构造器中
在代码块中
如果final修饰的属性是静态的，则初始化的位置只能是
定义时
在静态代码块 不能在构造器中赋值
final类不能继承，但是可以实例化对象
如果类不是final类，但是含有final方法，则该方法虽然不能重写，但可以被继承
一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法了
final不能修饰构造方法（构造器）
final和static往往搭配使用，效率更高，底层编译器做了优化处理
包装类（Integer，Double，Float，Boolean等都是final），String也是final类
五、抽象类
-
当父类的某些方法，需要声明，但是又不确定如何是实现时，可以将其声明为抽象方法，那么这个类就是抽象类
-
抽象类：
a. 不能被实例化
b. 可以有任意成员，比如非抽象方法、构造器、静态属性等
c. 多用于框架和设计模式
d. 抽象类的价值更多作用在于设计，是设计者设计好后，让子类继承并实现抽象类
e. 如果一个类继承了抽象类，则它需要实现抽象类的所有抽象方法，除非他自己也声明为一个abstract类
f. 抽象类不一定要包含abstract方法
g. 一旦类包含abstract方法，则该类必须声明为abstract
h. abstract只能修饰类和方法，不能修饰属性和其他访问修饰符 abstract 类名{ } -
抽象方法：没有方法体
访问修饰符 abstract 返回类型 方法名(参数列表); -
抽象方法不能使用 private、final、static 修饰, 因为这些关键字和重写相违背
-
应用：模板设计模式
六、接口
- 接口解释给出一些没有实现的方法，封装到一起，到某各类要使用时，再根据具体情况把这些方法写出来
//1. 声明接口
interface 接口名{
//属性
//方法(1.抽象方法2.默认实现方法3.静态方法)
}
//2. 类使用接口，则必须实现接口中的方法
class 类名 implements 接口{
//自己属性
//自己方法
//必须实现的接口的抽象方法
}
- 在jdk7.0之前，接口中的所有方法都没有方法体，都是抽象方法
- 在jdk8.0之后，接口类可以有静态方法，默认方法，也就是说接口中可以有具体方法实现，需要使用 default 关键字
default public void ok(){
}
- 案例1
UsbInterface.java
public interface UsbInterface {
public void start();
public void stop();
}
Camera.java
public class Camera implements UsbInterface{
public void start(){
System.out.println("相机开始工作");
}
public void stop(){
System.out.println("相机停止工作");
}
}
Phone.java
public class Phone implements UsbInterface{
public void start(){
System.out.println("手机开始工作");
}
public void stop(){
System.out.println("手机停止工作");
}
}
Computer.java
public class Computer {
public void work(UsbInterface usbInterface){
usbInterface.start();
usbInterface.stop();
}
}
InterfaceExercise.java
public class InterfaceExercise {
public static void main(String[] args){
Camera camera = new Camera();
Computer computer = new Computer();
computer.work(camera); //把相机接入电脑
}
}
- 案例二
InterfaceExercise02.java
interface A {
int x=0;
}
class B{
int x=1;
}
class C extends B implements A{
public void pX(){
System.out.println(super.x);
System.out.println(A.x);
}
public static void main(String[] args){
//因为pX不是静态类，所以调用时需要创建对象
new C().pX();
}
}
-
接口的注意事项和细节
a. 接口不能被实例化
b. 接口中所有的方法时public方法，接口中抽象方法，可以不用abstract修饰void aaa(); //实际上是 abstract void aaa();c. 一个普通类实现接口，就必须将该接口的所有方法都实现
d. 抽象类实现接口，可以不用实现接口的方法
e. 一个类同时可以实现多个接口
f. 接口中的属性，只能是final，而且是public static final 修饰符 // public static final int a=1;(必须初始化)g. 一个接口不能继承其他的类，但是可以继承多个别的接口
interface A extends B,C{}h. 接口的修饰符 只能是public和默认，这点和类的修饰符是一样的
-
实现接口 vs 继承类
a. 接口和继承解决的问题不同
ⅰ. 继承：解决代码复用性和可维护性
ⅱ. 接口：设计好各种规范（方法），让其他类去实现这些方法
b. 接口比继承更加灵活
ⅰ. 继承：is-a
ⅱ. 接口：like-a
c. 接口在一定程度上实现代码解耦【接口规范性+动态绑定】 -
接口的多态特性
a. 多态参数：在USB案例中，接口既可以接收手机，又可以接收相机（接口引用可以指向实现了接口的类的对象）
b. 多态数组Usb usbs[]=new usb[2]; usbs[0]=new Phone(); usbs[1]=new Camera(); for(int i=0;i<usbs.length;i++){ usbs[i].start(); usbs[i].stop(); } if(usbs[i] instanceof Phone){ ((Phone)usbs[i]).call(); }c. 多态传递
interfce AInterface{ void f1(); } class B implements AInterface{ @Override public void f1(){ System.out.println("f1!"); } } class C extends B{} //.... C c = new C(); AInterface af = c;
七、内部类
一个类的内部又完整地嵌套了另一个类结构，被嵌套的类为内部类，嵌套其他类的类称为外部类
class Outer{ //外部类
class Inner{ //内部类
}
}
class Other{ //外部其他类
}
7.1 定义在外部类局部位置上（如方法内）
7.1.1 局部内部类（有类名）
public class InnerClass {
public static void main(){
Outer outer = new Outer();
outer.m1();
}
}
class Outer{
private int n1=100;
private void m2(){}//私有方法
public void m1(){
final class Inner{
public void f1(){
System.out.println("n1="+n1);
m2();
}
}
Inner inner=new Inner();
inner.f1();
}
}
7.1.2 匿名内部类（没有类名）
-
特点：
a. 本质是类
b. 内部类
c. 该类没有名字
d. 同时还是一个对象 -
说明：匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名
-
基本语法：
new 类或接口(参数列表){ 类体 }; -
案例1-基于接口的匿名内部类：
public class AnonymousClass { public static void main(String[] args){ IA tiger = new Tiger(); tiger.cry(); } } interface IA{ public void cry(); } class Tiger implements IA{ public void cry(){ System.out.println("Tiger cry"); } }将上面代码转变为匿名内部类的形式：
public class AnonymousClass { public static void main(String[] args){ IA tiger = new IA(){ public void cry(){ System.out.println("老虎叫唤"); } }; tiger.cry(); System.out.println(tiger.getClass()); } } interface IA{ public void cry(); }● tiger编译类型：tiger
● tiger运行类型：匿名内部类 AnonymousClass$1(系统分配)class AnonymousClass$1 implements IA{ @Override public void cry(){ System.out.println("老虎叫唤"); } }● jdk在底层创建匿名内部类 AnonymousClass$1，立马就创建了AnonymousClass$1实例，并把地址返回给tiger
● 匿名内部类使用一次就不能再使用了，但是可以被多次调用 -
案例2-基于类的匿名内部类
public class AnonymousClass { public static void main(String[] args){ Father father1 = new Father("father1"); father1.test(); Father father2 = new Father("father2"){ @Override public void test(){ System.out.println("匿名内部类重写了test方法"); } }; father2.test(); System.out.println("father2的运行类型："+father2.getClass()); } } class Father{ private String name; public Father(String name){ this.name=name; } public void test(){ System.out.println("Father\t"+this.name+"\ttest()"); } }● 系统创建AnonymousClass$1，立马就创建了AnonymousClass$1实例，并把地址返回给father2
class AnonymousClass$1 extends Father{ @Override public void test(){ System.out.println("匿名内部类重写了test方法"); } } -
案例-基于抽象类的匿名内部类
abstract class Animal{ abstract void eat(); } Animal animal = new Animal(){ @Overrider void eat(){ //因为抽象类Animal，所以必须实现eat() System.out.println("小狗吃骨头"); } } -
使用细节
● 可以直接访问外部类的所有成员，包含私有的
● 不能添加访问修饰符，因为它的地位就是一个局部变量
● 作用域：仅仅在定义它的方法或代码块中
● 匿名内部类 访问——>外部类成员【直接访问】
● 外部其他类 不能访问——>匿名内部类【应为匿名内部类地位=局部变量】
● 外部类 和 内部类 成员重名是，内部类访问遵循就近原则，访问外部类成员： 外部类名.this.成员
● 练习public class InnerClassExercise { public static void main(String[] args){ Bell getup = new Bell() { @Override public void Ring() { System.out.println("getup!!"); } }; Bell gotoClass = new Bell() { @Override public void Ring() { System.out.println("goutoClass!!"); } }; CellPhone cellPhone = new CellPhone(); cellPhone.alarmclock(getup); cellPhone.alarmclock(gotoClass); } } interface Bell{ void Ring(); } class CellPhone{ public void alarmclock(Bell bell){ System.out.println(bell.getClass()); bell.Ring();//方法是动态绑定机制 } }
7.2 定义在外部类的成员位置上
7.2.1 成员内部类（没用static修饰）
-
成员内部类是定义在外部类的成员位置，并没有static修饰
-
可以直接访问外部类的所有成员，包括私有的
-
可以添加任意访问修饰符（public、protected、默认、private），因为它的地位就是一个成员
-
作用域：和外部类的其他成员一样，为整个类体，在外部类的成员方法中创建成员内部类对象，再调用方法
-
成员内部类 访问——>外部成员【访问方式：直接访问】
-
外部类 访问——>内部成员【创建对象，再访问】
-
外部其他类 访问——成员内部类
a. 法一： 直接创建Outer.Inner inner = outer.new Inner();b. 法二：在外部类中，编写一个方法返回成员内部类对象
Outer.Inner innerInstance = outer.getInnerInstance(); innerInstance.say(); -
如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类成员，则可以使用（外部类名.this.成员）去访问
class A{ private int n1=10; private static String name = "name"; class B{ private int n1=20; public void sat(){ System.out.println("A n1"+A.this.n1+"B n1"+n1); } } }
7.2.2 静态内部类（使用static修饰）
-
说明：静态内部类是定义在外部类的成员位置，有static修饰
-
可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
-
可以添加任意访问修饰符public、protected、默认、private，因为其地位就是一个成员
-
作用域：同其他的成员，为整个类体
-
静态内部类 访问——外部类（如静态属性）【访问方式：直接访问所有静态成员】
-
外部类 访问——>静态内部类【访问方式：创建对象，再访问】
class A{ private int n1 =10; private static String name = "tom"; private static void cry(){ System.out.println("cry"); } static class B{ public void say(){ System.out.println(name); cry(); } } public void test(){ B b = new b(); b.say(); } } -
外部其他类 访问——静态内部类
a. 因为静态内部类可以通过类名直接访问（前提：满足访问权限）B b = new A.B();//这里就不会创建一个A对象实例 b.say();b. 通过一个方法来获取一个静态内部类的对象实例
public class StaticClass{ public static void main(String[] args){ A a = new A(); A.B b = a.getB(); b.cry(); } } class A{ static class B{ public void say(){ System.out.println(name); cry(); } } public B getB(){ return new B(); } }若修改为静态方法，会更方便，就不会创建内部类对象了
public class StaticClass{ public static void main(String[] args){ A.B b = A.getB(); b.cry(); } } class A{ static class B{ public void say(){ System.out.println(name); cry(); } } public static B getB(){ return new B(); } } -
如果外部类和静态类内部类的成员重名是，静态内部类访问时，遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.成员）去访问
//法一，注意没有生成A类对象实例 B b = new A.B(); b.say(); //法二：如果访问内部类的静态方法，就可以不用new A.B.hello();
253
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
