【我的Java笔记】抽象类 & 接口

抽象类（abstract）

1.概念：每一个类的方法的功能不一样，故不能定义为一个具体类，而是给出一个声明（abstract）

2. 注：（1）当一个类中存在抽象功能（方法）时，则这个类一定要定义为抽象类

（2）一个类中既可以有抽象方法，也可以存在非抽象方法

3.抽象类不能实例化（创建对象）

（1）抽象类实例化的方式：抽象类多态形式（父类引用指向子类对象，通过子类来进行初始化）

（2）抽象类子类特点：

注：抽象类的子类是抽象类，那么将无意义（不能创建对象）

4.抽象类多态：

（1）强制子类必须重写当前抽象的父类中所有抽象方法

（2）提高代码的维护性（继承关系保证）

5. 注：“private”  “final” 和 “static”三个关键字不能和抽象关键字“abstract”共同使用

6.抽象类的成员特点：

（1）成员变量：可以是变量，也可以是自定义常量

（2）构造方法：可以有构造方法，有参、无参均可

（3）成员方法：可以有抽象方法，也可以存在非抽象方法

7.抽象类的成员方法特性：

（1）抽象方法：强制子类必须做到方法重写

（2）非抽象方法：由继承保证可以提高代码的复用性

例：

/*
老师案例
	具体事物：基础班老师，就业班老师
	共性：姓名，年龄，讲课。
*/

//测试类
public class Test{
	public static void main(String[] args){
		//基础班
		Teacher t=new BasicTeacher("inter",14);
		System.out.println(t.getName()+"----"+t.getAge());
		t.sleep();
		t.teach();
		
		WorkTeacher wt=new WorkTeacher("伊布拉希莫维奇",35);
		System.out.println(wt.getName()+"----"+wt.getAge());
		wt.sleep();
		wt.teach();
	}
}

//抽象类：老师
	
abstract class Teacher {
	//成员变量
	private String name ;
	private int age ;
	
	//无参
	public Teacher() {
	}
	
	//有参
	public Teacher(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	//SetXXX/GetXXX()公共访问方法(alt+shift+s-->r)
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
	//teach()
	public abstract void teach() ;
	
	//非抽象方法
	public void sleep(){
		System.out.println("困了,就需要休息....");
	}
	
	public void show(){
		System.out.println(name+"---"+age);
	}
}

//基本班的老师类
class BasicTeacher extends Teacher {

	//alt+shift+s-->c
	public BasicTeacher() {
		super();
	}

	public BasicTeacher(String name, int age) {
		super(name, age);
	}

	@Override
	public void teach() {
		System.out.println("基础班老师教JavaSE...");
	}
	
}

//就业班老师类
class WorkTeacher extends Teacher {
	//有参
	public WorkTeacher() {
		super();
	}

	//无参
	public WorkTeacher(String name, int age) {
		super(name, age);
	}

	@Override
	public void teach() {
		System.out.println("就业班老师讲JavaEE...");
	}
}

接口（interface）

1.概念：接口所体现出的是一种“扩展功能”

   例子：猫可以跳高（并不是所有的猫都会，后天所养成）

2.接口的格式：interface 接口名｛

｝

注：（1）接口里的方法只能是抽象方法

  （2）接口中不能存在构造方法

3.接口的特点：不能实例化（创建对象）

4.接口实例化的方法：

接口的子实现类：接口的子实现类必须是非抽象类，若为抽象类则无意义（需要子类创建对象）

5.接口的子实现类和接口的关系：implements

格式： class 子实现类 +  implements + 接口名

6.接口成员的特点：

（1）成员变量：只能为常量，并且默认被 “public static final” 修饰

（2）构造方法：接口不存在构造方法！

（3）成员方法：接口中成员方法默认被 “public abstract” 修饰

7.（1）类与接口的关系：

靠implements实现，一个类在继承另一个类的同时，可以实现多个接口

例：class A extends B implements C,D,E·····

   （2）接口与接口的关系：

继承关系，靠extends实现，可以单继承，也可以实现多继承

例： interface A extends B,C,D·····

问题：接口与抽象类的区别

（1）成员的区别：

①成员变量：

抽象类：成员变量可以是常量，也可以是变量

接口：成员变量只可为常量，默认被：public static final 修饰

②构造方法：

抽象类：可以有有参和无参构造方法

接口：不存在构造方法

③成员方法的区别：

抽象类：可以由抽象方法，也可以有非抽象方法

接口：只能为抽象方法，且默认被： public abstract 修饰

（2）关系的区别：

①类与类的关系：

继承关系：extends，只可单继承不可多继承，但可多层继承

②类与接口的关系：

实现关系：implements，且一个类在继承另一个类的同时可以实现多个接口

③接口与接口的关系：

继承关系：extends，可以单继承，也可以多继承

（3）设计理念的区别：

①抽象类：体现的是一种 “is a” 的关系，存在继承关系

②接口：体现到是一种 “like a” 的关系，接口所体现的是一种扩展功能

课堂练习

//定义一个接口
interface Inter{
	//默认修饰
	public static final int num1 = 100 ;
	public static final  int num2 = 200 ;
	
	//抽象方法
	//默认修饰符
	public abstract void show() ;
	
	public abstract void function() ;
}

//定义接口的子实现类
class InterImpl implements Inter{
	
	@Override
	public void show() {
		System.out.println(num1);
		System.out.println(num2);
	}

	@Override
	public void function() {
		System.out.println("function InterImpl...");
	}
	
}

//测试类
public class InterfaceDemo {
	public static void main(String[] args) {
		//创建接口对象:接口多态的形式
		Inter i = new InterImpl() ;
		System.out.println(Inter.num1);//当前变量被static修饰，可直接通过类名访问
		System.out.println(Inter.num2);
		System.out.println("-------------");
		i.show() ;
		i.function() ;
	}
}

2017.10.21