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

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

1、关键字 abstract

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

1.2.abstract修饰方法：

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

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

②父类全部重写抽像方法

abstract修饰类:

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

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 说明
内部类作为成员来说：

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

内部类作为类来说：

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

5.4 如何创建内部类对象

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

5.5 如何调用外部类的成员

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

5.6 局部内部类

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

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

        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 ：该注解是否可以被继承。