抽象类的特点：
A：抽象类和抽象方法必须用abstract关键字修饰。
B:抽象类中不一定有抽象方法，但是抽象方法的类必须定义为抽象类
c: 抽象类不能被实例化，因为它不是具体的。
抽象类有构造方法，但不能被实例化？构造方法的作用是什么？
用于子类访问父类数据的初始化。
D：抽象的子类。
如果不想重写抽象类的方法，该子类是个抽象类。重写所有的抽象方法，这个时候子类是一个具体的类
抽象类Demo:
//abstract class Animal //抽象类的声明格式 abstract class Animal { //抽象方法 //public abstract void eat(){} //空方法体,这个会报错。抽象方法不能有主体 public abstract void eat(); public Animal(){} } //子类是抽象类 abstract class Dog extends Animal {} //子类是具体类，重写抽象方法 class Cat extends Animal { public void eat() { System.out.println("猫吃鱼"); } } class AbstractDemo { public static void main(String[] args) { //创建对象 //Animal是抽象的; 无法实例化 //Animal a = new Animal(); //通过多态的方式 Animal a = new Cat(); a.eat(); } }
抽象实例：
/* 抽象类的成员特点： 成员变量：既可以是变量，也可以是常量。 构造方法：有。 用于子类访问父类数据的初始化。 成员方法：既可以是抽象的，也可以是非抽象的。 抽象类的成员方法特性： A:抽象方法 强制要求子类做的事情。 B:非抽象方法 子类继承的事情，提高代码复用性。 */ abstract class Animal { public int num = 10; public final int num2 = 20; public Animal() {} public Animal(String name,int age){} public abstract void show(); public void method() { System.out.println("method"); } } class Dog extends Animal { public void show() { System.out.println("show Dog"); } } class AbstractDemo2 { public static void main(String[] args) { //创建对象 Animal a = new Dog(); a.num = 100; System.out.println(a.num); //a.num2 = 200; System.out.println(a.num2); System.out.println("--------------"); a.show(); a.method(); } }
/* 猫狗案例 具体事物：猫，狗 共性：姓名，年龄，吃饭 分析：从具体到抽象 猫: 成员变量：姓名，年龄 构造方法：无参，带参 成员方法：吃饭(猫吃鱼) 狗: 成员变量：姓名，年龄 构造方法：无参，带参 成员方法：吃饭(狗吃肉) 因为有共性的内容，所以就提取了一个父类。动物。 但是又由于吃饭的内容不一样，所以吃饭的方法是抽象的， 而方法是抽象的类，类就必须定义为抽象类。 抽象动物类： 成员变量：姓名，年龄 构造方法：无参，带参 成员方法：吃饭(); 实现：从抽象到具体 动物类: 成员变量：姓名，年龄 构造方法：无参，带参 成员方法：吃饭(); 狗类： 继承自动物类 重写吃饭(); 猫类： 继承自动物类 重写吃饭(); */ //定义抽象的动物类 abstract class Animal { //姓名 private String name; //年龄 private int age; public Animal() {} public Animal(String name,int age) { this.name = name; this.age = age; } 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; } //定义一个抽象方法 public abstract void eat(); } //定义具体的狗类 class Dog extends Animal { public Dog() {} public Dog(String name,int age) { super(name,age); } public void eat() { System.out.println("狗吃肉"); } } //定义具体的猫类 class Cat extends Animal { public Cat() {} public Cat(String name,int age) { super(name,age); } public void eat() { System.out.println("猫吃鱼"); } } //测试类 class AbstractTest { public static void main(String[] args) { //测试狗类 //具体类用法 //方式1： Dog d = new Dog(); d.setName("旺财"); d.setAge(3); System.out.println(d.getName()+"---"+d.getAge()); d.eat(); //方式2： Dog d2 = new Dog("旺财",3); System.out.println(d2.getName()+"---"+d2.getAge()); d2.eat(); System.out.println("---------------------------"); Animal a = new Dog(); a.setName("旺财"); a.setAge(3); System.out.println(a.getName()+"---"+a.getAge()); a.eat(); Animal a2 = new Dog("旺财",3); System.out.println(a2.getName()+"---"+a2.getAge()); a2.eat(); } }
抽象类不能和那些关键字共存
/* 一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义? A:可以。 B:不让创建对象。 abstract不能和哪些关键字共存? private 冲突 final 冲突 static 无意义 */ abstract class Fu { //public abstract void show(); //非法的修饰符组合: abstract和private //private abstract void show(); //非法的修饰符组合 //final abstract void show(); //非法的修饰符组合 static abstract void show(); public static void method() { System.out.println("method"); } } class Zi extends Fu { public void show() {} } class AbstractDemo3 { public static void main(String[] args) { Fu.method(); } }
接口的特点：
A：接口用关键字interface表示,interface 接口名{}
B：类实现接口用implements 表示
class 类名 implements 接口名{}
C：接口不能实例化
接口实例化必须按照多态的方式来实现实例化的
D：接口的子类：
可以是抽象类，但意义不大
可以是具体类，要重写接口中所有抽象方法
/* 接口的特点： A:接口用关键字interface表示 interface 接口名 {} B:类实现接口用implements表示 class 类名 implements 接口名 {} C:接口不能实例化 那么，接口如何实例化呢? 按照多态的方式来实例化。 D:接口的子类 a:可以是抽象类。但是意义不大。 b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案) 由此可见： A:具体类多态(几乎没有) B:抽象类多态(常用) C:接口多态(最常用) */ //定义动物培训接口 interface AnimalTrain { public abstract void jump(); } //抽象类实现接口 abstract class Dog implements AnimalTrain { } //具体类实现接口 class Cat implements AnimalTrain { public void jump() { System.out.println("猫可以跳高了"); } } class InterfaceDemo { public static void main(String[] args) { //AnimalTrain是抽象的; 无法实例化 //AnimalTrain at = new AnimalTrain(); //at.jump(); AnimalTrain at = new Cat(); at.jump(); } }
接口成员特点：
成员变量：
只能是常量，默认饰符 public static final
构造方法：
没有，因为接口主要是扩展功能的，而没有具体存在
成员方法：
只能是抽象方法，默认修饰符 public abstract
/* 接口成员特点 成员变量；只能是常量，并且是静态的。 默认修饰符：public static final 建议：自己手动给出。 构造方法：接口没有构造方法。 成员方法：只能是抽象方法。 默认修饰符：public abstract 建议：自己手动给出。 所有的类都默认继承自一个类：Object。 类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。 */ interface Inter { public int num = 10; public final int num2 = 20; public static final int num3 = 30; //错误: 需要<标识符> //public Inter() {} //接口方法不能带有主体 //public void show() {} //abstract void show(); //默认public public void show(); //默认abstract } //接口名+Impl这种格式是接口的实现类格式 /* class InterImpl implements Inter { public InterImpl() { super(); } } */ class InterImpl extends Object implements Inter { public InterImpl() { super(); } public void show() {} } //测试类 class InterfaceDemo2 { public static void main(String[] args) { //创建对象 Inter i = new InterImpl(); System.out.println(i.num); System.out.println(i.num2); //i.num = 100; //i.num2 = 200; //System.out.println(i.num); //无法为最终变量num分配值 //System.out.println(i.num2);//无法为最终变量num2分配值 System.out.println(Inter.num); System.out.println(Inter.num2); System.out.println("--------------"); } }