20200322java学习之路之面向对象之抽象类，接口，关键字final

一：关键字final？

1. final是一个修饰符，可以修饰方法，类，变量
2. final是一个修饰的类不可以被继承（继承的弊端：打破了封装性）
3. final是一个修饰符的方法不可以被覆盖
4. final修饰的变量是常量，只能被赋值一次
5. final会显示初始化，如果final int x系统会报错，要赋值

-public static全局变量
-static不需要对象，用类名就可以调用访问
-public static final 全局常量

7. 只要是固定值（常量）就要用final定义，定义的标准
   -取一个有意义的名称
   -写法哟啊规范，常量所有字母都是大写，若多个字母则需要下划线连接

/*final*/ class Fu{
	void method(){

	}
}
class Zi extends Fu{
	void method(){
		final double MY_PI=3.14;
		static final int x=7;
		//inal int x=9;
		//x=8;
		System.out.println(x);
	}
}

class FinalDemo{
	public static void main(String[] args){
			Zi z=new Zi();
			z.method();
	}
}

二：抽象类

1，抽象那就是笼统，模糊，看不清，朦胧等意思
2，抽象类的特点

• 方法只有声明没有实现时，叫做抽象方法。该方法要用abstract修饰，
• 抽象方法必须定义在抽象类中，所以该类也必须被abstract所修饰
• 抽象类没有实例化（用类创建对象的一个过程 Dog d=new Dog();)因为调用抽象方法没有意义
• 该抽象类中必须其子类覆盖所有的抽象方法后，其子类才有实例化，否则该子类也是抽象类

abstract class DemoA{
	final  abstract void show();
}

class DemoB extends DemoA{
	void show(){
		System.out.println("show b");
	}
}
class DemoC extends DemoA{
	void show(){
		System.out.println("show c");
	}
}

class AbstractDemo{
	public static void main(String[] args){
	
	}
}

三：关于抽象类的小问题

1. 抽象类中是否有构造函数？

-答：有，用于给子类对象进行初始化

2. 抽象类可以不定义抽象方法吗？
   -答：可以，很少见，就是为了不让类创建对象
   class demo{
   void show1（）{}
   void show2（）{}
   }

3. 抽象类和一般类的区别？

-相同点：都在内部定义了成员，且都是为了描述事物

-不同点：1）一般类有足够的信息描述事物，抽象类描述事物可能信息不足
2）一般类不能定义抽象方法，只能定义非抽象方法。但是抽象类都可以定义
3）一般类可以被实例化，抽象类不可以被实例化

4. 抽象类与哪些关键字不能共存？
   -private
   -static
   -final
   
   
   
5. 抽象类一定是父类吗？
   -答：是的，因为子类覆盖其方法后子类才可以进行实例化

四:抽象类的实例

/*
雇员示例：
需求：公司中程序员有姓名，工号，薪水，工作内容
对项目经理除了有姓名，工号，薪水，还有奖金，工作内容
对给出需求进行数据建模

分析：在这个问题领域中，先找出涉及的对象
通过名词提炼法
程序员
属性：姓名，工号，薪水
行为：工作
经理：
属性：姓名，工号，薪水，奖金
行为：工作

程序员和经理不存在直接的继承关系
但是程序员和经理却具有共性的内容
可以进行抽取，因为都是公司的员工
可以将程序员和经理进行抽取，建立体系
*/
class Employee{
	private String name;
	private String id;
	private double pay;
	Employee(String name ,String id ,double pay){
		this.name=name;
		this.id=id;
		this.pay=pay;
	}
	public abstract void work();
}


class Programmer extends Employee{
	Programmer(String name,String id,double pay){
		super(name ,id,pay);
		public abstract void work(){
			System.out.println("programmer work code ");
		}
	}
}

class Manager extends Employee{
	Manager(String name,String id,double pay,int bonus){
		super(name,id ,pay,bonus);
		this.bonus=bonus;
	}
	public abstract void work(){
		System.out.println("manager work");
	}
}













class AbstractDemo2{
	public static void main(String[] args){
	
	}
}

/*
对于学生与工人的案例同样适用
*/
class Person{
	private String name;
	private int age;

	Person(String name,int age){
		this.name=name;
		this.age=age;
	}
	public String getName(){
		return name ;
	}
	public void setName(String name){
		this.name=name;
	}
}
class Student extends Person{
	Student(String name,int age){
	super(name,age);
	}
}
public void student(){
	System.out.println("student studay");
}
class Worker extends Person{
	Worker(String name,int age){
	super(name,age);
	}
}
public void work(){
	System.out.println("work jobs");
}

五：接口

1. 当一个抽象类中的方法都是抽象时，可以将该抽象类用另一种方式去定义和表示------那就是接口（interface）

2. 定义接口使用的关键字不是class，而是interface

3. 接口中常见的成员（有固定修饰符的成员）—接口成员的权限都是最大的
   -public static final全局常量
   -public abstract抽象方法

4. 接口不可以实例化（抽象类也不可以实例化）只有实现接口子类覆盖接口所有的方法后，该子类才可以叫实例化，否则这个类就是抽象类

5. 在java中不直接支持多继承，因为会出现调用的不确定性
   所以java将多继承机制进行改良，在java中变成了多实现

6. 一个类可以实现多个接口

7. 一个类在继承另一个类的同时，还可以实现多个接口

8. 接口的出现避免了单继承的局限性

9. 类与类之间是继承关系，类与接口之间是实现关系，接口与接口之间是继承（而且接口可以多继承）

interface A{
	public void showA();
}
interface B{
	public void showB();
}


class Test implements A,B{
	public void show(){

	}
}


interface Demo{
	public static final int NUM=4;
	public abstract void show1();
	public abstract void show2();
}

class DemoImpl implements Demo{
	public void show1(){}
	public void show2(){}
}


class Q{
	public void method(){}
}

class Test2 extends Q implements A,B{

}

interface CC{
	void show();
}
inteface MM{
	void method();
}

interface QQ extends CC,MM{//jiekou yu jiekou zhijianshijichengguanxi
	void function();
}
class WW implements QQ{
	//fugai dange fangfa
	public void show(){}
	public void method(){}
	public void function(){}
}
class InterFaceDemo{
	public static void main(String[] args){
		Test t=new Test();
		t.show();
			//DemoImpl d=new DemoImpl();
			//d.show();
			//System.out.println(d.NUM);
			//System.out.println(DemoImpl.NUM);
			//System.out.println(Demo.NUM);
	}
}

六：接口的特点

1. 接口对外暴露规则
2. 接口是程序的功能扩展
3. 接口出现降低耦合性
4. 接口用来实现多实现

七：接口与抽象类的区别

相同点：都是不断向上抽取而来

不同点：
1，抽象类需要被继承，而且只能单继承
接口需要被实现，而且可以多实现
2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法
接口只能定义抽象方法，必须由子类去实现
3，抽象类的基础，是is a关系，在定义该体系的基本共性内容
接口实现是 like a 关系，在定义体系额外功能

abstract class Dog{
	abstract void jiao();
	
}
abstract class DaoMang{
	abstract void DaoMang();
}
class DaoMangDog extends Dog{
	public void jiao(){}
	public void work(){
		System.out.println("daomang");
	}
}


class InterfaceDemo2{
	public static void main(String [] args){

	}
}

八：接口的实现

//笔记本电脑的使用、
//为了扩展笔记本的功能，但日后出现的设备都符合这个规则就可以
interface USB{
	public void open();
	public void close();
}

class InterfaceDemo4{
	public static void main(String[] args){
		//useUSB(null);
		useUSB(new UPan());//功能扩展了
		useUSB(new UsbMouse());
	}
	public static void useUSB(USB u){//接口类型引用，用于接收接口的子类对象
		u.open();
		u.close();
	}
}
//一年后，实现规则
//这些设备和电脑的耦合性降低了
class UPan implements USB{
	public void open(){
		System.out.println("upan open");
	}
	public void close(){
		System.out.println("upan close");
	}

}
class UsbMouse implements USB{
	public void open(){
		System.out.println("UsbMouse open");
	}
	public void close(){
		System.out.println("UsbMouse close");
	}

}