一、抽象类
1.1.抽象类的概述：
我们把一个不是具体的功能称为抽象的功能，而一个类中如果有抽象的功能，该类必须是抽象类。
- 抽象类的特点：
- 抽象类和抽象方法必须用abstract关键字修饰
- 抽象类中不一定有抽象方法,但是有抽象方法的类必须定义为抽象类 (即带有抽象方法的)
- 抽象类不能实例化
因为它不是具体的。
抽象类有构造方法，但是不能实例化,构造方法的作用是 用于子类访问父类数据的初始化 - 抽象的子类
a:被抽象类abstract修饰的子类,也是一个抽象类
b:不加abstract的话,通过多态,抽象类的子类可以被实例化,但是必须重写抽象类中所有的抽象方法.
抽象类的实例化其实是靠具体的子类实现的。是多态的方式。
Animal a = new Cat();(前提是cat已经被实例化)
1.2.抽象类的成员特点
- 成员变量：抽象类的成员方法既可以是常量，也可以是变量，但是不可以抽象化
- 构造方法：抽象类有成员方法，用于子类访问父类数据的初始化
- 成员方法：既可以是抽象的也可以是非抽象的
抽象类成员方法的特性：
1.抽象方法：强制要求子类必须做的事，即子类必须重写父类有的抽象方法
2.非抽象方法：子类可以从父类继承的，提高代码复用性
示例代码：
//这是一个抽象类
abstract class Animel{
public abstract void eat();//正确,不带主体的抽象方法
//public abstract void sleep() {}//报错，因为抽象方法不能有主体。即大括号中的代码块
public void sleep(){
System.out.println("睡觉");//这是抽象类中的一个非抽象方法，可以被子类继承的
}
}
abstract class dog extends Animel{}//如果加了abstract,抽象类的子类也是抽象类
class cat extends Animel{
public void eat() {
System.out.println("吃饭");
//不加abstract的话,通过多态,抽象类的子类可以被实例化,但是必须重写抽象类中所有的的方法
//如果没有全部重写,将会报错
}
}
public class AbstractTest {
public static void main(String[] args) {
//Animel a = new Animel();//错误,抽象类不能直接实例化
Animel a= new cat();//抽象类通过多态实现子类实例化
a.eat();
a.sleep();//未被抽象的方法
cat c= new cat();//具体对象调用
c.eat();
c.sleep();
}
运行结果：
吃饭
睡觉
吃饭
睡觉
1.3.抽象类的注意事项
抽象类的使用限制
- 不能与final (冲突)
- private(冲突)
- static(无意义) 共存
原因:首先因为被final和private修饰的方法不允许被重写或者覆盖,而被abstract修饰的方法又必须在子类中重写,所以这abstract与这两个关键字冲突，关于static关键字,因为被abstract修饰的方法不允许有方法体,而被static修饰的方法可以直接通过类名调用,而调用一个没有方法体的方法是没有意义的
1.4.抽象类总结
1、抽象类不能被实例化，实例化的工作应该交由它的子类来完成，它只需要有一个引用即可。
2、抽象方法必须由子类来进行重写。
3、只要包含一个抽象方法的抽象类，该方法必须要定义成抽象类，不管是否还包含有其他方法。
4、抽象类中可以包含具体的方法，当然也可以不包含抽象方法。
5、子类中的抽象方法不能与父类的抽象方法同名。
6、abstract不能与final并列修饰同一个类。
7、abstract 不能与private、static、final或native并列修饰同一个方法。、
1.5.抽象类的三种调用方式
abstract class Animel{
private int age ;
private String name;
abstract void eat() ;
Animel(){};
public Animel(String name,int age) {
this.name=name;
this.age=age;
}
public void SetName(String name) {
this.name =name;
}
public void SetAge(int age) {
this.age=age;
}
public String GetName() {
return name;
}
public int GetAge() {
return age;
}
}
class dog extends Animel{
public dog() {};
public dog(String name,int age) {
super(name,age);
}
public void eat() {
System.out.println("狗吃肉");
}
}
public class CatDemo {
public static void main(String[] args) {
//调用方式一,构造方法调用
dog d = new dog("哈士奇",20);
d.eat();
System.out.println(d.GetAge()+"------"+d.GetName());
System.out.println("------------");
// 调用方式二,具体调用
dog d1= new dog();
d1.eat();
d1.SetAge(19);
d1.SetName("哈巴狗");
System.out.println(d1.GetAge()+"------"+d1.GetName());
System.out.println("------------");
//调用方式三.抽象调用
Animel d2 = new dog();
d2.eat();
d2.SetAge(99);
d2.SetName("萌犬");
System.out.println(d2.GetAge()+"------"+d2.GetName());
}
}
二、接口
2.1.接口的概述
-
接口用关键字interface表示 （注意，接口不需要加class）
interface 接口名 {} -
类实现接口用implements
class 类名 implements 接口名 {} -
接口不能直接实例化 ，如果需要实例化，必须按照多态的方式来实例化，即利用一个非抽象化的子类进行实例化
-
接口的子类 ，可以是抽象类。但是意义不大。也可以是具体类。但是必须要重写接口中的所有抽象方法。
-
接口并不是实际的一个类,而是功能的拓展，由此可见多态有三种实现方法：
A:具体类多态(很少用)
B:抽象类多态(常用)
C:接口多态(最常用)ps（1.接口名+Impl这种格式是接口的实现类惯用格式 ，2，在实现接口的时候需要注意调用的时候只能调用该接口有的方法 ）
2.2.接口的成员特点
- 成员变量:接口中的变量默认是常量,默认带有 public static final ,不可被重新赋值,同时因为它是静态的， 因此即使另一个类处于不同包下，也可以通过接口名.成员变量名来访问接口里的成员变量。,但是建议自己手动给出public static final，
- 成员方法：接口中的方法只能是抽象方法,且默认为抽象方法,即使没有加抽象修饰符abstract,
因为接口中的成员方法默认加了public abstract，但是为了直观，依旧建议自己手动给出public abstract ,而且， 接口中的成员方法与抽象类类似,都不带有方法主体 - 构造方法：接口没有构造方法
2.3.接口与类之间的关系
- 与类：
继承关系,只能单继承,可以多层继承。（不允许存在son extends father， mother{}这种情况 ） - 类与接口：
实现关系,可以单实现,也可以多实现。（例如：class Son implements Father,Mother{}）
并且还可以在继承一个类的同时实现多个接口。（class son extends father implements mother，sister {}（解释：子类继承父类并实现母和姐妹接口）） - 接口与接口：
继承关系,可以单继承,也可以多继承。（interface Sister extends Father,Mother { }）继承的接口，可以继承功能
三、抽象类与接口的区别
3.1.成员区别
- 抽象类：
成员变量：可以变量，也可以常量
构造方法：有 构造方法
成员方法：可以抽象，也可以非抽象
- 接口：
成员变量：只可以常量 （即被static final）
成员方法：只有抽象 方法
没有构造方法
3.2.关系区别
- 类与类 继承，单继承
- 类与接口 实现，单实现，多实现
- 接口与接口 继承，单继承，多继承
3.3.设计理念区别
抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能，大致来说当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口，通俗的说，类用来抽象共性，而接口用于抽象功能，例如鸟和猫可以抽取一个动物的共性，但是鸟和飞机一般是抽象出一个fly（)的行为的接口。