Java面向对象编程（下）

励志语录

失败只是暂时停止成功，假如我不能，我就一定要；假如我要，我就一定能！

关键字-static

可以修饰：属性，方法，代码块

static修饰的属性（类变量）：

1. 类变量随类的加载而加载（只加载一次），实例变量随对象的创建而加载
2. 同一个类的不同对象，独有一份实例变量，共有一份类变量
3. 调用方法：类名.类变量名 对象名.类变量名

注：实例变量：普通属性

static修饰的方法（静态方法）：

1. 静态方法随着类加载而创建
2. 静态方法中不能使用实例变量和非静态方法
3. 非静态方法中可以使用静态方法和类变量
4. 静态方法中不能使用this和super

static修饰的代码块：和代码块一起说

static使用场景：一般用于所有对象共用一个的变量，工具类

代码块

格式：{}

分类：静态代码块 VS 非静态代码块

静态代码块：

1. 随类的加载而加载（只加载一次）
2. 类的加载优先于对象的创建（静态代码块的执行优先于非静态代码块）
3. 静态代码块中不能调用实例变量和非静态方法
4. 静态代码块可以有多个，从上到下依次执行
5. 用于类的初始化

非静态代码块：

1. 随对象的创建而加载
2. 非静态代码块的执行优先于构造器
3. 非静态代码块可以调用类变量和静态方法
4. 非静态代码块可以有多个，从上到下依次执行
5. 用于对象的初始化

关键字-final

final修饰的类：不能被继承
final修饰的方法：不能被重写
final修饰的属性：属性的值不能被改变，并且必须初始化

final初始化的方式：显示赋值，代码块赋值，构造器赋值

抽象类和抽象方法

抽象方法：在Java中如果一个类的方法没有方法体那么我们将这一类方法称为抽象方法，抽象方法必须有关键字 abstract进行修饰

格式：权限修饰符 abstract 返回值类型 方法名（形参列表）；

抽象方法所在的类必须是抽象类，抽象类同样用abstract进行修饰

注：

1. 抽象类不能实例化
2. abstract 不能与 final，private，static连用
3. 抽象类的子类必须重写抽象类的抽象方法

接口

什么是接口？其实接口就是一个标准，比如一个鼠标要想被电脑使用，就要实现USB接口的标准，而一个程序要想被另外一个程序调用的话，也需要去制定一个标准，而这个标准就是接口

关键字：interface

格式：

权限修饰符 interface 接口名{
}

注：

1. 接口的权限修饰符只能为public和缺省的
2. 接口中只能有常量和抽象方法（JDK1.8之后附加静态方法和默认方法）
3. 接口和类是并行存在

实现：
关键字：implements

一个类实现某个接口，就必须重写该接口的抽象方法，要是不想重写，就必须将该类声明成抽象类

接口和类的多态：
接口的引用指向类的实例

默认方法：
声明方式：

default 返回值类型 方法名（形参列表）{
方法体；
}

接口冲突：当一个类同时实现两个接口并且两个接口中有同名同参的默认方法时会出现接口冲突
解决接口冲突的方法：在实现类中重写默认方法

内部类

如果在一个类A的内部在定义一个类B，那么类B就是类A的内部类，而类A是类B的外部类

内部类的分类：成员内部类 VS 局部内部类（在方法内定义的类）

成员内部类分类：静态内部类 VS 非静态内部类

内部类：
作为类：

1. 可以继承父类和实现接口
2. 有类的成员

作为成员：

1. 可以有权限修饰符
2. 可以用static修饰
3. 可以调用外部类的属性和方法

• 静态内部类：可以调用外部类中的类变量和静态方法（不可以调用实例变量和非静态方法）

  调用方式：外部类名.类变量名/静态方法名

  如何实例化静态内部类？

  外部类名.内部类名 对象名 = new 外部类名.静态内部类名()

• 非静态内部类：可以调用外部类中的属性和方法

  调用方式：外部类名.this.属性名/方法名
  如何实例化非静态内部类？

  外部类名.内部类名 对象名 = 外部类对象.new 内部类名()

• 局部内部类：
  如何实例化局部内部类？

  需要局部内部类实现一个接口从而利用多态返回接口类型的局部内部类的对象

代码示例：

class A{
	private String name = "Jeck";
	public static int num = 10;
	
	class B{ //非静态内部类
		public void info(){
			System.out.println(A.this.name + A.num);
		}
	}
	
	static class C{ //静态内部类
		public void info(){
			System.out.println(A.num);
		}
	}
}

interface Inner{
	public abstract void show();
}

public class InnerClassTest {
	public static void main(String[] args) {
		A.B b = new A().new B();
		b.info();
		A.C c = new A.C();
		c.info();
		InnerClassTest test = new InnerClassTest();
		Inner test2 = test.test();
		test2.show();
	}
	
	public Inner test(){
		class D implements Inner{
			public void show(){
				System.out.println("D show");
			}
		}
		return new D();
	}
}

匿名内部类

当一个类的对象在程序中只使用一次那么我们就没有必要在去在外面声明一个类，而可以声明一个匿名内部类

声明格式：

interface 接口名{
	匿名内部类的抽象方法
}

public class test{
	public static void main(String[] args){
		接口名 对象名 = new 接口名(){
			重写接口方法
		};
	}
}