抽象类：
抽象：模糊，不具体。
特点：
1.方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰。抽象方法必须定义在抽象类中。该类必须也被abstract修饰。
2.抽象类不可以被实例化。为什么？因为调用抽象方法没有意义。
3.抽象类必须由其子类覆盖所有的抽象方法后，该子类才可以实例化。否则，这个子类还是抽象类。
抽象类的小细节
1.抽象类中有构造函数吗？
有，用于给子类对象初始化。
2.抽象类可以不定义抽象方法吗？
可以的，但是很少见，目的就是不让该类创建对象。AET的适配器对象就是这种类。
通常这个类中的方法有方法体，但是却没有内容。
class DemoB{
void show(){}
}
3.抽象关键字不可以和哪些关键字共存？
private 不行，私有后无法被覆盖。
static 不行。
final 不行。抽象并必须要被覆盖，final修饰后不能被覆盖。
4.抽象类和一般类区别。
相同点:抽象类和一般类都是用来描述事物的，都在内部定义了成员。
不同：
1.一般类有足够的信息描述事物，抽象类描述事物的信息有可能不足。
2.一般类中不能定义抽象方法，只能定义非抽象方法。抽象类中既可以定义抽象方法也可以定义非抽象方法。
3.一般类可以被实例化，抽象类不可以被实例化。
5.抽象类一定是个父类吗？
是的。因为需要子类覆盖其方法后才可以对子类实力话。
abstract class Demo{//函数声明相同，函数体不同，抽取了方法的声明
abstract void show();//抽象函数所在的类也必须标示成抽象的
}
class DemoA extends Demo{
void show(){
System.out.println("demo a show");
}
}
class DemoB{
void show(){
System.out.println("demo b show");
}
}
抽象类雇员示例：
需求：公司中程序员有姓名，工号，薪水，工作内容。
项目经理除了有姓名，工号，薪水，还有奖金，工作内容。
对给胡需求进行数据建模。
分析：
在这个问题领域中，涉及的对象。(通过名词提炼法)
程序员：
属性：姓名，工号，薪水。
行为：工作。
经理：
属性：姓名，工号，薪水，奖金。
行为：工作。
经理并不是程序员的一种，所以不存在直接继承关系。
但是程序员和经理却具有着共性的内容，可以进行抽取。因为他们都是公司的雇员。
可以讲程序员和经理进行抽取，建立体系。
//描述雇员
abstract class Employee{
private String name;
private String id;
private double pay;
public 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("codeing...");
}
}
class Manager extends Employee{
private int bonus;
Manager(String name,String id,double pay,int bonus){
super(name,id,pay);
this.bonus = bonus;
}
public void work(){
System.out.println("manage...");
}
}
-----------------------------------------------------------------
当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是 接口 Interface
定义接口使用的关键字不是class，是interface。
对于接口当中常见的成员：而且这些成员都有固定的修饰符，如果不写会自动加上。
1.全局常量。public static final
2.抽象方法。public abstract
由此得出结论，接口中的成员都是公共的权限。
interface Demo2{//编译后生成的还是class文件。
public static final int NUM = 3;
public abstract void show1();
public abstract void show2();
}
类与类之间是继承关系，类与接口之间是实现关系。
接口不可以实力化，只能由实现了接口的子类覆盖了接口中所有的抽象方法后，该子类才可以实例化。
否则这个子类就是一个抽象类。
class DemoImpl implements Demo2{
//想要实例化必须覆盖接口中所有的方法
public void show1(){}
public void show2(){}
}
public class InterfaceDemo {
public static void main(String[] args) {
DemoImpl d = new DemoImpl();
System.out.println(d.NUM);
System.out.println(Demo2.NUM);
System.out.println(DemoImpl.NUM);
}
}
多实现
java不直接支持多继承，因为会出现调用的不确定性。
所以java将多继承机制进行了改良，在java中变成了多实现。
一个类可以实现多个接口。完成 了多继承的改良。
interface A{
public void show();
}
interface Z{
public void show();
}
class Test implements A,Z{//多实现
public void show(){
//同时覆盖了A和Z中的show方法。
}
}
接口细节
一个类在继承另一个类的同时，还可以实现多个接口。
继承一个类属于一个体系，实现多个接口拓展其功能。
接口的出现避免了单继承的局限性。
类与类之间是继承关系，类与接口之间是实现关系。
接口与接口之间是继承关系，而且接口可以多继承。
因为接口没有方法体，没有安全隐患所以可以继承。
接口的特点：
接口是对外暴露的规则。
接口是程序的功能扩展。
接口的出现降低耦合性.
接口和抽象类的异同点：
相同点：
都是不断向上抽取而来的。
不同点：
1. 抽象类需要被继承，而且只能单继承。
接口需要被实现，而且可以多实现。
2. 抽象类中可以定义抽象方法和非抽象方法，子类继承后可以直接使用非抽象方法。
接口中只能定义抽象方法，必须由子类去实现。
3. 抽象类的继承，是is a（所属关系）关系，在定义该体系的基本共性内容。
接口的实现是like a关系，在定义体系的额外功能。
类在确定体系，接口在扩展功能。
犬按功能分，有导盲犬，搜爆犬。
分析：犬在定义这类事物的基本功能，导盲犬和搜爆犬都会吼叫。
导盲，和搜爆是犬这类事物的额外功能。
犬应该定义成类，导盲和搜爆应该定义成接口。
abstract class 犬{
abstract void 吼叫();
}
abstract interface 导盲{
abstract void 导盲();
}
class 导盲犬 extends 犬 implements 导盲{
public void 吼叫(){}
public void 导盲(){}
}
接口的应用
例子:笔记本电脑、鼠标、u盘。
笔记本定义规则并使用规则，鼠标、u盘实现规则
继承是is a，我是你里面的一种。
实现是like a 像你里面的一种，usb鼠标像触摸板
笔记本电脑使用。
为了扩展笔记本的功能，但日后出现什么功能设备不知道。
定义一个规则，只要日后出现的设备都符合这个规则就可以了。
规则在java中就是接口。
*/
interface USB{//定义规则
public void open();
public void close();
}
class BookPC{
public static void main(String[] args){
usbUSB(new UPan()); //功能扩展了。
}
//使用规则
public static void usbUSB(USB u){//接口类型的引用。用于接收（指向）接口的子类对象
u.open();
}
}
--------------------------------------------------------
//一年后，实现规则。这些设备和电脑的耦合性降低了。
class UPan implements USB{
public void open(){
System.out.println("UPan open");
}
public void close(){
System.out.println("UPan close");
}
} |
收藏
淘帖
踩
