抽象类和接口（基础，代码版）

抽象类和接口

1.抽象类

概念：有一些事物，我们可以分析为类，但是相对比较抽象，不能直接实例化分析为具体的对象，此时我们可以将此类书写为抽象类。比如，动物，电脑，人……

抽象类的规则：

1.抽象方法使用abstract修饰 没有方法体
2.抽象方法必须存在于抽象类中
3.抽象类不能直接实例化 不能直接new对象 必须通过new子类的方式 来实例化 ，向上转型的方式
4.子类必须实现父类的抽象方法 除非子类也是抽象类
5.子类可以选择是否重写父类的非抽象(普通)方法
6.抽象类中可以有构造方法，是给子类使用的
7.抽象类中可以有普通的属性，普通的方法，静态方法，使用方式跟之前是一样的

package com.qfedu.test2;
/**
 * 	本类是一个父类
 * 	属性：
 * 	品牌
 * 	行为：
 * 	开门
 * 	关门
 * @author WHD
 *
 */
public abstract class Door {
	private String brand;
	public String getBrand() {
		return brand;
	}
	public void setBrand(String brand) {
		this.brand = brand;
	}
	public Door(String brand) {
		this.brand = brand;
	}
	public Door() {
	}
	public abstract  void open();
	
	public abstract void close();	
}

package com.qfedu.test2;
/**
 * 	普通门
 * 	普通的开门关门方式
 * @author WHD
 *
 */
public class CommonDoor extends Door{
	
	public void open() {
		System.out.println("插入钥匙，门开了");
	}
	
	public void close() {
		System.out.println("手动关门");
	}

	public CommonDoor() {
		super();
	}

	public CommonDoor(String brand) {
		super(brand);
	}
	
}

package com.qfedu.test2;
/**
 * 防盗门
 */
public class SecurityDoor extends Door{

	@Override
	public void open() {
		System.out.println("指纹 + 密码解锁，门开了");
		
	}

	@Override
	public void close() {
		System.out.println("自动上锁，关门");
	}

	public SecurityDoor() {
	}

	public SecurityDoor(String brand) {
		super(brand);
	}

}

package com.qfedu.test2;
/**
 * 	人类 由人来操作门 
 * 	开门
 * 	关门
 * @author WHD
 *
 */
public class Person {
	/**
	 * 	多态实现方式1 父类作为形参 
	 * @param door
	 */
	public void openDoor(Door door) {
		System.out.println("回家了，开门");
		door.open();
	}
	
	/**
	 * 	多态实现方式1 父类作为形参 
	 * @param door
	 */
	public void closeDoor(Door door) {
		System.out.println("进入家中");
		door.close();
	}
	/**
	 * 	多态实现方式2 父类作为返回值
	 * @param money
	 * @return
	 */
	public   Door  buyDoor(int money){
		if(money > 10000) {
			return new SecurityDoor("大金刚");
		}else {
			return new CommonDoor("小金刚");
		}
	}
	public static void main(String[] args) {
		Person person = new Person();
		Door commonDoor = new CommonDoor("大钻石");
		person.openDoor(commonDoor);
		person.closeDoor(commonDoor);
		person.openDoor(new SecurityDoor("大金刚"));
		person.closeDoor(new SecurityDoor("大金刚"));
	}

}

package com.qfedu.test2;

public class Test {
	
	public static void main(String[] args) {
		Door common = new CommonDoor("钻石");
		common.open();
		common.close();
		System.out.println("======================");
		Door securityDoor = new SecurityDoor("大金刚");
		securityDoor.open();
		securityDoor.close();
	}
}

2.final关键字

final：最终

修饰

1.属性，称之为常量

​ A:只有final修饰，就是常量，全部大写，必须在声明的赋值，或者在构造方法中赋值，且只能赋值一次，因为值不可改变

​ B:static final修饰，表示静态常量，必须在声明的时候赋值，或者在静态代码块中赋值，且只能赋值一次，因为值不可改变

小结：加上static的含义是在值不可改变的作用下，同时表示这个常量在内存只存在一份。

2.方法，不能被重写

3.类，不能被继承

3.接口

接口：interface

接口特点
JDK7
1.接口中不能定义普通属性，接口中的所有属性默认都是 public static final 修饰的
2.接口中的方法 都是抽象方法 默认都是 public abstract 修饰的（不能写普通方法，不能写静态方法）
3.实现类(子类)必须重写接口的抽象方法，除非实现类是抽象类，或者接口继承接口
4.接口不能直接new对象，不能直接实例化，必须通过new子类的方式实例化

JDK8 在原来JDK7的基础上
1.可以写普通方法，使用default关键字修饰 加载访问权限之后，返回值之前
2.也可以书写静态方法

抽象类和接口：

区别

1.本质区别(适用场景)

​ 当你关注一个事物的本质的时候，使用抽象类，当你关注一个功能的时候，使用接口。

2.使用的区别

​ a.抽象类可以有普通属性，接口只有静态常量

​ b.抽象类可以有构造方法，接口不能有构造方法

​ c.抽象类可以有普通方法和静态，接口只有JDK8开始才支持使用default关键字声明方法和静态方法

​ b.抽象类是extends继承，接口是implements实现

​ e.只能继承一个类，可以实现多个接口，接口可以继承多个接口

​ f.抽象类中方法必须使用abstract修饰，接口中默认都是public abstract修饰的

面试题：Java支持多继承吗？

不支持，一个类只能有一个直接父类，但是可以通过接口继承多个接口的方式，实现类似多继承的效果，在能够满足需求的前提下，尽量使用接口。