复习抽象类和接口

1.抽象类的特点

1.抽象类和抽象方法必须用abstract关键字修饰
例如:abstract class 类名 {}
public abstract void eat(); —注意这个方法不加大括号,因为抽象类的方法是抽象的不是具体的.
2.抽象类不一定有抽象方法(这里指抽象类可以不含有方法或者只有非抽象方法),有抽象方法的类一定是抽象类或者是接口.

这里就抽象类中的抽象方法的存在作出的思考:
如果一个抽象类中一个抽象方法都没有,那说明该抽象类这样做是为了禁止别的类产生这个类的对象;
抽象类也可以有非抽象方法,既可以有方法的具体实现,由抽象父类的子类继承;
如果子类没有实现抽象父类中的抽象方法,那么这个子类也必须声明为抽象的,即只要类中有抽象的方法那么这个类就一定是抽象类,但是抽象类中的方法不一定都是抽象方法.
抽象类是不完整的,它只能用作基类。在面向对象方法中,抽象类主要用来进行类型隐藏和充当全局变量的角色。

3.抽象类不能实例化.那么抽象类如何实例化呢?
按照多态的方式,由具体的子类实例化.其实这也是多态的一种,抽象类多态
4.抽象类子类,要么是抽象类,要么不是抽象类而且重写抽象类中的所有抽象方法
实例代码如下:

class Demo1_Abstarct {
	public static void main(String[] args) {
		//Animal a = new Animal();           错误:Animal是抽象的;无法实例化
		Animal a = new Cat();                //父类引用指向子类对象
		a.eat();
	}
}
abstract class Animal {                       //抽象类
	public abstract void eat() ;               //抽象方法
	//public  void eat(){} ; 如果将上一句方法改成非抽象方法编译也不会报错,输出结果一样
}

class Cat extends Animal {
	public void eat() {
		System.out.println("猫吃鱼");      //如果子类可以继承父类的某个方法,子类就可以重写这个方法 
	}
}
//输出结果:猫吃鱼

抽象类的成员特点

抽象类的成员方法特性:

a:成员变量:既可以是变量,也可以是常量.abstract修饰成员变量.
b:有构造方法,用于子类访问父类数据的初始化.
c:成员方法:既可以是抽象的,也可以是非抽象的.

抽象类的成员方法特性:

a:抽象方法:强制要求子类做的事情.
b:非抽象方法:子类继承的事情,提高代码复用性.

class Demo2_Abstract {
	public static void main(String[] args) {
		System.out.println("Hello World!");
	}
}
abstract class Demo {
	int num1 = 10;     
	final int num2 = 20;  //这里的成员变量为一个值,不是抽象的,是具体的

	public Demo() {}  //抽象类的构造方法,这里为默认构造方法可省略
	
	public void print() {  //非抽象方法
		System.out.println("111");
	}

	public abstract void method(); //抽象方法
}	

class Test extends Demo {
	public void method() {
		System.out.println("111");
	}
}

A:面试题

一个抽象类如果没有抽象方法,可不可以定义为抽象类?如果可以,有什么意义?
答:可以.这么做目的只有一个,就是不让其他类创建本类对象,交给子类完成

B:面试题2

abstract不能和哪些关键字共存
1.abstract和static
被abstract修饰的方法没有方法体
被static修饰的方法可以用类名.调用,但是类名.调用抽象方法是没有意义的.你类名.方法名来调用时,没有结果,所以出错.
2.abstract和final
被abstract修饰的方法强制子类重写
被final修饰的方法不让子类重写,所以他俩是矛盾
3.abstract和private
被abstract修饰的是为了让子类看到并强制重写
被private修饰的不让子类访问,所以他俩是矛盾的

2.接口

A:接口概述
	从狭义的角度讲就是java中的interface
	从广义的角度来讲对外提供规则的都是接口
B:接口特点
	a:接口用关键字interface表示
		interface 接口名 {}
	b:类实现接口用implements表示
		class 类名 implements 接口名 {}
	c:接口不能实例化
		那么,接口如何实现实例化呢?
		按照多态的方式来实例化(父类引用指向子类对象)
	d:接口的子类
		a:可以是抽象类.但是意义不大
		b:可以是具体类,要重写接口中的所有抽象方法(推荐方案)

案例演示:

class Demo1_Interface {
	public static void main(String[] args) {
		//Inter c = new Inter();          错误: Inter是抽象的; 无法实例化;(按多态的方法实例化)
		Inter c = new Demo();
		c.print();
	}
}
interface Inter {
	public abstract void print();        //接口中的方法都是抽象的
}

class Demo implements Inter {
	public void print() {
		System.out.println("print");
	}
}

接口成员特点

成员变量:只能是常量,并且是静态的并公共的
	默认修饰符:public static final(这仨关键字可以交换位置)
	建议:自己手动给出
构造方法:接口没有构造方法
成员方法:只能是抽象方法
	默认修饰符:public abstract
	建议:自己手动给出

class Demo2_Interface {
	public static void main(String[] args) {
		//Inter a = new Demo();
		Demo a = new Demo();
		a.print();  //10
		System.out.println(Inter.num);   //10;说明num是静态的
	}
}
interface Inter {
	public static final int num = 10;
	//public Inter() {};  接口中没有构造方法
	//public abstract void print();
	//public void print() {}   接口中不能定义非抽象方法
	/*public abstract*/ void print();
}

class Demo /*extends Object*/ implements Inter {  //一个类不写继承任何类,默认继承Object类
	/*public Demo() {
		super();
	}*/
	public void print() {
		//num = 20; 错误: 无法为最终变量num分配值
		System.out.println(num);
	}
}

类与类,类与接口,接口与接口的关系

a:类与类:
	继承关系,只能单继承,可以多层继承
b:类与接口:
	实现关系,可以单实现(implements),也可以多实现
	并且还可以在继承一个类的同时实现多个接口
c:接口与接口
	继承关系,可以单继承,也可以多继承

class Demo3_Interface {
	public static void main(String[] args) {
		System.out.println("Hello World!");
	}
}
interface InterA {
	public abstract void printA();
}

interface InterB {
	public abstract void printB();
}

interface InterC extends InterB {
}
//class Demo implements InterA,implements InterB {           这么做是不允许的,是非法的
class Demo extends Object implements InterA,InterB {
	public void printA() {
		System.out.println("printA");
	}

	public void printB() {
		System.out.println("printB");
	}
}

抽象类和接口的区别

A:成员区别
	抽象类:
		成员变量:可以变量,也可以常量
		构造方法:有
		成员方法:可以抽象,也可以非抽象
	接口:
		成员变量:只可以有常量
		构造方法:无
		成员方法:只可以抽象
B:关系区别
	类与类
		继承,单继承
	类与接口
		实现,单实现,多实现
	接口与接口
		继承,单继承,多继承
C:设计理念区别
	抽象类 被继承的体现是:"is a"的关系.抽象类中定义的是该继承体系的共性功能
	接口 被实现体现的是:"like a"的关系.接口中定义的是该继承体系的扩展功能

构造方法不能被继承,不能被重写,可以被重载