java个人学习笔记11（abstract+interface）

1.abstract

抽象事物：没有足够信息来描述该事物，用abstract关键字修饰（包括类和方法）

1）抽象方法一定定义在抽象类中，都需要用abstract来修饰，如：abstract void method();

2）抽象类不能实例化，即不能用new关键字创建对象

3）只有子类覆盖了所有的抽象方法后，子类具体化，子类就可以创建对象

如果子类没有覆盖所有的抽象方法，那么子类还是一个抽象类

抽象类：也是不断向上抽取共性而来的，抽取了方法的声明而不确定具体的方法内容，由不同的子类来完成具体的方法内容。

pro1：抽象类中有构造函数吗？

有，虽然抽象类中的构造函数不能给本类对象实例化，因为抽象类不能创建对象；但是抽象类有子类，它可以给子类的对象实例化

pro2：抽象类和一般类的不同？

抽象类中可以定义抽象方法，而一般类不能；抽象类不可实例化，而一般类可以

pro3：抽象类一定是父类吗？

一定，抽象类的抽象方法必须由子类覆盖该方法后，才可以实例化使用这些方法

pro4：抽象类中可以不定义抽象方法吗？

可以，仅仅是为了让该类不能够实例化对象

pro5:abstract不能和那些关键字共存？

final：final修饰的类不能被子类继承，final修饰的方法不能被覆盖；而abstract修饰的类必须被子类继承，并且抽象方法也必须被子类的方法覆盖

private：private修饰的方法只能在本类中使用，子类无法使用更无法覆盖

static：static修饰的方法在静态区，可以通过类名的方式调用，但是抽象方法没有方法内容，所以没有意义

2.练习

/*
需求：公司中程序员有姓名、工号、薪水、工作内容
项目经理除了以上还有奖金，进行数据建模
*/
abstract 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 void work(){
		System.out.println("coding...");
	}//子类方法覆盖抽象类中的抽象方法
}

class Manager extends Employee{
	private double bonus;//特有属性
	Manager(String name,String id,double pay,double bonus){
		super(name,id,pay);//调用父类构造函数初始化子类对象
		this.bouns = bouns;
	}
	public void work(){
		System.oout.println("Manager...");
	}//子类方法覆盖抽象类中的抽象方法
}

3.接口（interface）
1）接口的成员：全局常量、抽象方法，均有固定的修饰符
2）接口不可以实例化（原因是有抽象方法）
3）需要覆盖了接口中的所有的抽象方法的子类才可以实例化

4）接口是用来被实现的（implements）,而非继承

interface(接口)
interface Inter{
	public static final int NUM = 1;//全局常量
	public abstract void show();//抽象方法
	public abstract void print();//抽象方法
}

5）多继承可以拥有更多的功能，但产生调用的不确定性，原因在于方法主体内容的不同
java中不直接支持多继承，而是通过接口将多继承转化为了多实现。接口中的抽象函数不存在方法的主体内容，只有在子类中进行方法覆盖后才能实例化，因此不会出现调用方法的不确定性

interface InterA{
	public abstract show();
}
interface InterB{
	public abstract show();
}
class InterDemo implements InterA,InterB{//多实现
	public void show(){
		System.out.println("show");
	}//由于接口中定义的是抽象方法，此处不会产生调用的不确定性
}

6）单继承通过接口扩展功能
一个类继承一个类的同时，还可以实现多个接口，避免单继承的局限性
继承是为了获取体系的基本功能，扩展功能可以通过接口来实现
接口之间支持多继承，在实现接口时需在类中覆盖所有接口的抽象方法

class Father{
	void method(){
		System.out.println("Father.method()");
	}
} 
interface Inter{
	public abstract void method1();
}
class Son extends Father implements Inter{
	public void method1(){
		System.out.println("Iner.method1()");
	}
}//子类同时拥有父类和接口的功能

7）使用接口的部分方法:没有抽象方法的抽象类
1）先用一个类把接口的所有方法都空实现，由于该类创建对象没有意义，所以抽象化该类
2）再让子类继承该类，覆盖该类的部分方法

interface Inter{
	public abstract void show1();
	public abstract void show2();
	public abstract void show3();
}
abstract class Demo implements Inter{//空实现接口所有的抽象方法
	public void show1(){}
	public void show2(){}
	public void show3(){}
}
class Demo1 extends Demo{
	public void show1(){
		System.out.println("Inter.Demo.show1()");
	}//覆盖Demo中的show1()
}
class Demo2 extends Demo{
	public void show3(){
		System.out.println("Inter.Demo.show3()");
	}//覆盖Demo中的show3()
}
class InterDemo
{
	public static void main(String[] args) 
	{
		Demo1 d1 = new Demo1();
		Demo2 d2 = new Demo2();
		d1.show1();
		d2.show3();
	}
}

4.接口和抽象类的比较

类用于描述事物的共性基本功能，要从问题领域考虑子类是不是父类中的一种

接口用于定义的都是事物的额外功能，要从问题领域考虑