1）抽象类和接口
package AbstractClass;
public class AbstractClass {
public static void main(String[] args) {
// 抽象类 父类抽象设计 不能创建实例
// abstract 修饰类 不可创建实例
// 修饰方法 没有实现 子类非抽象类必须实现
// 抽象类 不一定有 抽象方法，有抽象方法的一定的抽象类或接口
// 匿名类 对象（匿名内部类）
new Person(){
@Override
public void abstractDoing() {
System.out.println("abstractDoing");
}
@Override
public void do1() {
}
@Override
public void do2() {
}
}.abstractDoing();
// 设计模式之一：模板方法，已经定义了执行流程，实现声明的对应方法
Person p = new Man();
p.doAll();
// 接口 interface 类不可多继承，接口多实现
// 接口中不能有实例方法
// 全局常量 public static final
// 抽象方法 public abstract
// jdk8 静态方法 默认方法
// 打破了单继承局限性
// 匿名接口实现类 对象
// 区分默认方法冲突问题 this.子类方法 super.父类方法 接口名.super.接口方法
new CanDoAble(){
@Override
public void do1() {
System.out.println("do1");
}
@Override
public void defaultDo() {
CanDoAble.super.defaultDo();
}
}.defaultDo();
// 设计模式之一：代理模式，另一个类实现对象接口，创建代理对象调用被代理对象处理
CanDoAble obj = new CanDo();
CanDoAble proxy = new CanDoAble() {
@Override
public void do1() {
// 代理
obj.do1();
}
};
// 设计模式之一：工厂模式，工厂类方法获取对象 简单工厂
Factory.createCanDo();
Factory.createAnotherCanDo();
// 工厂方法 工厂和产品作为接口 有新的实现就定义新的实现类
// 抽象工厂 相比较工厂方法 有更多创建方法 更多的产品接口
// 反射-工厂 将产品信息定义在配置中 无产品限制的工厂 Spring框架的核心
// 变态题 区分继承属性和接口属性
// super.继承属性 接口.接口属性
// 接口多实现出现完全一致的抽象方法不会报错
// 比较：抽象类定义抽象事物，如动物；接口定义抽象行为，如会飞的。
}
}
// 抽象类
abstract class Person{
// 不能创建实例 提供给子类实例初始化
public Person(){}
// 声明抽象方法 实例相关的 子类非抽象类就必须实现方法
abstract void abstractDoing();
// 抽象类可以有实现方法
public void doing(){
System.out.println("implement");
}
public void doAll(){
this.do1();
this.do2();
}
public abstract void do1();
public abstract void do2();
}
// 抽象类子类
class Man extends Person{
// 访问权限 >= 声明
@Override
public void abstractDoing() {
System.out.println("man doing");
}
@Override
public void do1() {
System.out.println("do1");
}
@Override
public void do2() {
System.out.println("do2");
}
}
// 接口
interface CanDoAble{
// public static final 可省略
public static final int i = 1;
// public abstract 可省略
public abstract void do1();
// public 可省略
public static void doSome(){
}
// public 可省略 实现子类实例可用
public default void defaultDo(){
System.out.println("defaultDo");
}
}
// 接口实现类
class CanDo implements CanDoAble{
public CanDo(){
System.out.println(CanDo.this);
//CanDo.super //Object
//CanDoAble.super //CanDoAble
}
@Override
public void do1() {
}
@Override
public void defaultDo() {
CanDoAble.super.defaultDo();
}
}
// 工厂类
class Factory{
public static CanDoAble createCanDo(){
return new CanDo();
}
public static CanDoAble createAnotherCanDo(){
return new CanDoAble() {
@Override
public void do1() {
System.out.println("another do1");
}
};
}
}
2）内部类
package InnerClass;
import java.io.Serializable;
public class OuterClass {
public static void main(String[] args) {
// 内部类 定义在类中的类
// 成员内部类：成员位置
// 局部内部类：局部位置
// 局部内部类 无修饰符
class Temp{
public void hello(){
System.out.println("hello");
}
}
new Temp().hello();
// 成员内部类使用
// 静态
OuterClass.Sinner s = new OuterClass.Sinner();
// 实例
OuterClass.Inner i = new OuterClass().new Inner();
i.doSome();
// 局部内部类：通常用于匿名创建对象参数传递，使用lambda表达式简写
// 成员内部类：对此理解要区分 类对象 和 实例对象
// 执行程序时，外部类加载了，static成员被加载，
// 因此有了类对象之后，即可使用static成员，创建外部类对象，和静态的内部类对象，
// 正如可以访问静态方法和属性一样
// 创建外部类实例之后，可见实例成员，如属性，方法，实例代码块，实例内部类结构，
// 所以可以使用实例this来new实例内部类
// 反过来，获得静态内部类实例，与外部类实例毫无关系
// 获得实例内部类对象，必定有外部类实例，所以可以访问外部实例内容
// 理解（实质不保证，只保证理解）：
}
static int sa;
private int a = 1;
// static final abstract 可修饰
// 静态成员类 只能访问外部类静态属性
static class Sinner{
private int a;
public void doSome(){
int sa1 = OuterClass.sa;
// 获取this的完整办法
// OuterClass.Sinner.this
// Object
// OuterClass.Sinner.super
}
}
// 实例成员类 能访问外部类实例
// public class Inner{
// class Inner{
// protected class Inner{
private class Inner implements Serializable {
private int a = 2;
public void doSome(){
// 区分内部类实例与外部实例
// Inner.this
// OuterClass.this
int a1 = OuterClass.this.a;
int a2 = OuterClass.sa;
System.out.println(this.a); // 2
System.out.println(OuterClass.this.a); // 1
// 获取this的完整办法
System.out.println(Inner.this.a);
System.out.println(OuterClass.this.a);
// Object
// Inner.super
// OuterClass.super
}
}
public void doSome(){
// 外部类把内部类作为结构，创建对象使用
new OuterClass.Sinner().doSome();
// 对象可见实例内部类结构，创建实例使用
OuterClass.this.new Inner();
}
}
