Java基础部分学习：7、抽象类、接口

1、抽象类：

当父类的一些方法不能确定时，即不知道方法体里面写什么时，可以让abstract关键字类修饰该方法，这个方法就是抽象方法，当一个类中存才抽象方法时，需要将该类声明为抽象类。

abstract class Animal{
	String name;
	int age;
	abstract public void cry();  // 抽象方法没有方法体。
}

一般来说，抽象类会被继承，由其子类来实现抽象方法。

抽象类的价值更多在于设计，是设计者设计好后，让子类继承并实现抽象类。在框架和设计模式使用较多。

1.1 抽象类细节：

1、抽象类不能被实例化：不能new。

2、抽象类不一定里面要有抽象方法，但是类里面有抽象方法，则这个类必须声明为abstract。

3、abstract只能修饰类和方法，不能修饰属性和其它。

4、抽象类里面可以有任意成员（抽象类本质还是类）。

5、如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非他自己也声明为抽象类。

6、抽象方法不能使用private、final、static来修饰，因为他们和重写相违背。

抽象类最佳实现形式：模板设计：

public static void main(String[] args) {
	AA aa = new AA();   
	aa.calculateTime();  // 3ms
	BB bb = new BB();   
	bb.calculateTime();   // 2ms
}

abstract public class Template{   // 模板
	public abstract void job();// 抽象方法
	public void calculateTime() {
		long start = System.currentTimeMills();  // 获取当前时间，返回毫秒
		job();   // 动态绑定机制。哪个对象调用就指向哪个对象的job方法
		long end = System.currentTimeMills();
		System.out.println("任务执行时间为：" + (end - start));
	}
}

public class AA extends Template{
	public void job() {  // 重写模板job方法。
		long num = 0;
		for(long i = 1; i < 600000; i++) {
			num += i;
		}
	}
}

public class BB extends Template{
	public void job() {  // 重写模板job方法。
		long num = 0;
		for(long i = 1; i < 6000; i++) {
			num *= i;
		}
	}
}

2、接口：

2.1、接口入门：

// 1、写一个USB接口
public interface UsbInerface {
// 规定接口的相关方法
	public void start();  // 接口抽象方法可以不写abstract
	public void stop();
}

// 2、写一个phone类，实现 usb接口：实现就是重写接口方法
public class Phone implements UsbInerface {
	@Override
	public void start() {
		System.out.println("手机开始工作");
	}
	@Override
	public void stop() {
		System.out.println("手机停止工作");
	}
}

// 3、再写一个camera类，实现 usb接口：实现就是重写接口方法
public class Camera implements UsbInerface {
	@Override
	public void start() {
		System.out.println("相机开始工作");
	}
	@Override
	public void stop() {
		System.out.println("相机停止工作");
	}
}

// 4、写一个computer类，接入接口
// 使用这个电脑接口来调用方法
public class Computer {
	public void work(UsbInterface usbInterface) {  // 将接口传入
		usbInterface.start();   // 通过接口调用方法
		usbInterface.stop();
	}
}

public static void main(String[] args) { 
	// 1、创建手机、相机对象
	Camera camera = new Camera();
	Phone phone = new Phone();
	// 2、创建电脑对象
	Computer computer = new Computer();
	computer.work(camera);  // 将相机接入到电脑
	computer.work(phone);
}

2.2、接口介绍：

1、是什么：接口就是给出一些没有实现的方法，封装到一起，某个类需要使用时，再根据具体情况把这些方法写出来。

2、语法：

interface 接口名 {
	// 1、可以写属性
	public int n1 = 10;
	// 2、可以写抽象方法方法：接口中，抽象方法可以省略abstract关键字
	public void hi();
	
	// 3、jdk8及以后，可以写默认实现方法，要用default关键字修饰
	default public void ok() {
		System.out.println("ok");
	}
	
	// 4、jdk8及以后，可以写静态方法。
	public static void cry() {
		System.out.println("cry");
	}
}

3、类如何使用接口：implements关键字

class Cat implements iAnterface {
	// 写自己属性、自己方法
	// 必须实现接口的所有抽象方法
}

2.3、接口使用细节：

1、接口不可以被实例化。

2、接口中的所有方法都是public方法，接口中的抽象方法可以不用abstract修饰。

interface AA {
	void sayHi();   // 可以不用public也不用写abstract
}

3、一个普通类实现接口，就必须将接口的所有方法都实现；可以使用alter+enter快捷键

4、抽象类实现接口，可以不用实现接口方法。

5、一个类可以同时实现多个接口。

interface IB {
	void hi();
}
interface IC {
	void say();
}
class Pig implements IB,IC {
	@Overfide
	public void hi() {}

		@Overfide
	public void say() {}
}

6、接口中的属性，只能是final的，而且是public static final 修饰符

int a = 1;   // 实际是：public static final int a = 1;  只是默认省略了

7、接口中的属性访问形式：接口名.属性名。

8、接口不可以继承其它类，但是可以继承多个别的接口

interface IB {
	void hi();
}
interface IC {
	void say();
}
interface ID extends IB,IC {
	void say();
}

9、接口的修饰符只能是public 和 默认。

interface IB {
	void hi();
}

public interface IC {
	void say();
}

3、接口和继承的理解：

1、继承：继承的价值主要在于解决代码复用性和可维护性。
2、接口：价值主要在于设计好各种规范，让其他类去实现这些方法。

当子类继承了父类，就自动拥有了父类的功能，如果子类需要扩展功能，可以通过实现接口的方式扩展，可以理解为：接口是对Java单继承机制的一种补充。

public static void main(String[] args) {
	LittleMonkey little = new LittleMonkey("小猴");
	little.climbing();
	little.flying();
}

interface BirdAble {
	void flying()
}

class Monkey {
	private String name;
	public Monkey(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public voic climbing() {
		System.out.println( name + "会爬树");
	}
}

class LitteMonkey extends Monkey implements BirdAble{
	public LitteMonkey(String name) {
		super(name);
	}
	@Override
	public void flying() {
		System.out.println(getName() + "通过学习，可以像鸟儿一样飞");
	}
}

4、接口的多态体现：

public static void main(String[] args) {
// 1、接口的多态体现：
// 接口类型的变量 if01 可以指向实现了IF接口的对象实例
	IF if01 = new Method1();
	if01 = new Method2();
	
// 2、继承的多态体现：
// 父类类型的变量 a 可以指向继承AAA 的子类对象实例
AAA a = new BBB();
a = new CCC();
}

interface IF {}
class Method1 implements IF{}
class Method2 implements IF{}

class AAA {}

class BBB extends AAA {}
class CCC extends AAA {}

4.1、多态数组：

public static void main(String[] args) {
/*
在USB数组中存放 phone 和 camera 对象，phone类有一个特有方法call()；遍历USB数组，如果是phone对象，除了调用USB接口定义的方法work()外还要调用phone特有方法call()：
*/
	Usb[] usbs = new Usb[2];
	usbs[0] = new Phone();
	usbs[1] = new Camera();

	for(int i = 0; i < usbs.lenth; i++) {
		usbs[i].work();
		if(usbs[i] instanceof Phone) {  // 判断他的运行类型是phone
			({Phone) usbs[i]).call();  // 向下转型
		}
	}
}

interface Usb{}
class Phone implements Usb{}
class Camera implements Usb{}

4.2、接口多态传递：

public static void main(String[] args) {
// 接口类型变量可以指向，实现了该接口的类的对象实例。
	Inter2 inter2 = new Man();
// 如果接口2继承了接口1，而且Man实现了接口2，那么就相当于Man类也实现了接口1
// 这就是所谓的接口多态传递现象：
	Inter1 inter1 = new Man();
	
}

interface inter1{
	void hi();
}
interface inter2 extends inter1{}  // 接口2继承了接口1
class Man implements inter2{
	@Override
	public void hi() {}   // 也要重写接口1的方法
}

类的5的成员：

1、属性
2、方法
3、构造器
4、代码块
5、内部类