JAVASE(十一) 高级类特性： abstract 、模板模式、interface、内部类、枚举、注解

个人博客网：https://wushaopei.github.io/    (你想要这里多有)

1、关键字 abstract

1.1.abstract可以修饰：类，方法

1.2.abstract修饰方法 ：

1. 抽像方法没方法体
2. 非抽像类继承抽像类 必须重写抽像类中的所有抽像方法（包括间接抽像父类）父类如果重写了间接抽像父类中的抽像方法，那么非抽像子类可以不用再重写该方法
3. 如果非抽像子类不想抽写抽像类中的抽像方法

①那么该类只能也被声明成抽像类

②父类全部重写抽像方法

abstract修饰类:

1. 抽像类不能被实例化
2. 思考：抽像类构造器吗？ 抽像类是有构造器的 因为要实现 子类对象的实例化过程。
3. 抽像方法所在的类必须是抽像类

1.4.abstrcat不可以和哪些关键字一起使用

    final,static,private

1.5：代码

/*
 * 几何图形
 * 1.抽像类可以继承非抽像类
 */
abstract class GeometricObject extends A {
	//抽像类是构造器的因为 要实现  子类对象的实例化过程
	public GeometricObject(){
		System.out.println("GeometricObject()");
	}

	@Override
	public void test() {

	}
	//抽像方法没方法体
	public abstract void findArea();
}

//如果非抽像子类不想抽写抽像类中的抽像方法，那么该类只能也被声明成抽像类
class Triangle extends GeometricObject{

	//非抽像类继承抽像类 必须重写抽像类中的所有抽像方法（包括间接抽像父类）
	//抽像父类如果重写了间接抽像父类的抽像方法 ①那么该类只能也被声明成抽像类  ②父类全部重写抽像方法
	@Override
	public void findArea() {

	}
}

2、模板方法的设计模式

/*
 * 模板设计模式：
 *
 *
 * 需求 ： 计算代码运行的时间
 *
 */
abstract class Computer{

	public void codeTime(){

		long start = System.currentTimeMillis();
		//将可变的代码抽成抽像方法，具体的实现由子类去实现
		runCode();

		long end = System.currentTimeMillis();

		System.out.println("time = " + (end - start));
	}

	public abstract void runCode();
}

class RunNumber extends Computer{

	@Override
	public void runCode() {

		for (int i = 0; i < 1000; i++) {
			if(i % 2 == 0){
				System.out.println(i);
			}
		}
	}
}

3、关键字：interface

3.1 接口的声明格式 ：

权限修饰符（public,缺省的 interface 接口名{}

3.2 说明
   1.接口声明的格式 ：权限修饰符(public和缺省的)   interface  接口名{}
   2.接口和类是并列的关系。
   3.jdk1.8之前接口中只能定义 - 抽像方法和常量
   4.类和类的关系是继承 （单继承）
      类和接口的关系是实现关系（多实现 例   A implments English,Math接口和接口的关系是继承关系（多继承
   5.接口中没构造器 - 不能创建接口的实例
   6.接口与实现类的多态性（详见InterfaceTest2.java）
3.3：接口和类的多态性

class Computer{

    public void runUSB(USB usb){
        usb.start();
        System.out.println("-----------工作中-------------");
        usb.close();
    }

    public void runBluetooth(Bluetooth bt){
        bt.connect();
        System.out.println("--------连接中--------------");
        bt.disConnect();
    }
}

interface USB{

    void start();
    void close();
}

interface Bluetooth{
    void connect();
    void disConnect();
}

class Printer implements USB,Bluetooth{

    @Override
    public void start() {
        System.out.println("打印机开始工作了.....");
    }

    @Override
    public void close() {
        System.out.println("打印机停止工作了....");
    }

    @Override
    public void connect() {
        System.out.println("打印机已经连接蓝牙.....");
    }

    @Override
    public void disConnect() {
        System.out.println("打印机已经断开蓝牙.....");
    }

}

class Mouse implements USB,Bluetooth{
    @Override
    public void connect() {
        System.out.println("鼠标已经连接蓝牙.....");
    }

    @Override
    public void disConnect() {
        System.out.println("鼠标已经断开蓝牙.....");
    }

    @Override
    public void start() {
        System.out.println("鼠标开始开作了....");
    }

    @Override
    public void close() {
        System.out.println("鼠标停止工作了....");
    }
}

面试题： 关于abstract 和 interface 的关系

（1）abstract类其实和普通类一样，拥有有自己的数据成员和方法，只不过abstract类里面可以定义抽象abstract的方法（声明为abstract的类也可以不定义abstract的方法，直接当做普通类使用，但是这样就失去了抽象类的意义）。

（2）一个类中声明了abstract的方法，该类必须声明为abstract类。

（3）interface中只能定义常量和抽象方法。在接口中，我们定义的变量默认为public static final类型，所以不可以在显示类中修改interface中的变量；定义的方法默认为public abstract，其中abstract可以不明确写出。

4、关键字：工厂方法的设计模式

interface IWorkFactory{
	Work getWork();
}
class TeacherWorkFactory implements IWorkFactory{
	@Override
	public Work getWork() {
		return new TeacherWork();
	}
}

class StudentWorkFactory implements IWorkFactory{
	@Override
	public Work getWork() {
		return new StudentWork();
	}
}

interface Work{
	void doWork();
}

class StudentWork implements Work{
	@Override
	public void doWork() {
		System.out.println("学生就要好好学习");
	}
}

class TeacherWork implements Work{
	@Override
	public void doWork() {
		System.out.println("老师就要好好教学生学习，不学就打");
	}
}

5、关键字：内部类

5.1 定义 : 在一个类A的内部再声明一个类B，类A叫做外部类，类B叫做内部类

5.2 内部类的分类
内部类 ： 成员内部类   vs  局部内部类
成员内部类 ： 静态成员内部类  vs 非静态成员内部类

5.3 说明
内部类作为成员来说：

1. 可以使用四种权限修饰符
2. 可以使用static修饰

内部类作为类来说：

1. 类内部可以，构造器，属性，代码块
2. 可以被继承

5.4 如何创建内部类对象

静态内部类 ： new 外部类的类名.静态内部类的类名()
非静态内部类 :new 外部类的类名().new 非静态内部类的类名（）

5.5 如何调用外部类的成员

静态内部类 ：外部类的类名.类变量的名字、静态方法名
非静态内部类 ：外部类的类名.this.属性名、方法名

5.6 局部内部类

1. 在方法内再定义一个类。
2. 如何返回内部类的对象？

①可以通过创建一个接口，让局部内部类实现该接口。
       ②方法的返回值类型为该接口的类型
       ③创建局部内部类的对象并返回

        public AA getInnerClass(){
		//局部内部类
		class C implements AA{
			@Override
			public void show(){
				System.out.println("inner class");
			}
		}

		C c = new C();
		return c;
	}
        interface AA{
	    void show();
        }

6、关键字：枚举

6.1 定义

如果一个类的对象是有限的，可数多个的这样的类叫做枚举类

6.2 如何自定义枚举类

class Season{
	//ctrl + shift + x 所字母变成大写
	//ctrl + shift + y 所字母变成小写
	private final String SEASONNAME;
	private final String SEASONDES;
	//私化构造器
	private Season(String SEASONNAME,String SEASONDES){
		this.SEASONDES = SEASONDES;
		this.SEASONNAME = SEASONNAME;
	}

	//创建四个对象
	public static final Season SPRING = new Season("春天","春眠不觉晓");
	public static final Season SUMMER = new Season("夏天","夏天蚊子咬");
	public static final Season AUTUMN = new Season("秋天","秋天扫落叶");
	public static final Season WINTER = new Season("冬天","冬天穿棉袄");

	public String getSeasonName() {
		return SEASONNAME;
	}
	public String getSeasonDes() {
		return SEASONDES;
	}
}

6.3 如何使用enum关键字定义枚举类

enum Season10{
	//创建四个对象。注意 ：创建的对象必须放在首行
	SPRING,
	SUMMER,
	AUTUMN,
	WINTER;
}

6.4 常用API

​

6.5 枚举的对象实现接口中的方法

enum Season3 implements Show{
	//创建四个对象。注意 ：创建的对象必须放在首行
	SPRING{
		@Override
		public void info() {
			System.out.println("春天");
		}
	},
	SUMMER{
		@Override
		public void info() {
			System.out.println("夏天");
		}
	},
	AUTUMN{
		@Override
		public void info() {
			System.out.println("秋天");
		}
	},
	WINTER{
		@Override
		public void info() {
			System.out.println("冬天");
		}
	};
}

7、关键字 ： 注解

7.1 定义：注解可以用来对类中的结构（属性，方法，类，构造器...）进行补充说明，而不改变原有的结构。

7.2 JDK内置的个注解

​

自定义注解
格式 ： 权限修饰符（public,缺省的 @interface 注解名{
          int age() default 10;
}
代码：

@interface MyAnn2{
    String name();
    int age() default 20; //给这个属性赋值一个默认值为20，这样就可以再加注解时不用再强行进行赋值
}

7.4 元注解

@Target : 用来限制说明注解可以用在类中的哪些结构上。
@Retention :
            SORUCE(了解): 源文件 - 编译期间 （现在直接丢弃了这种策略）
            CLASS(了解): 编译期间 - 运行期间
            RUNTIME: 运行期间 （如果需要通过反射获取该注解的信息，那么该注解必须是Runtime）

//下面两个知道即可
@Documented ： 该注解是否能被javadoc所解析
@Inherited ： 该注解是否可以被继承。