首页 > 代码库 > 抽象类
抽象类
抽象类
抽象类概述:抽象就是看不懂的
1.抽象类特点
1) 抽象类和抽象方法必须用abstract关键字修饰
abstract class 类名 {} 抽象类
public abstract void eat();抽象方法
注意:抽象方法//直接;,不加大括号./当不知道该方法具体是怎么实现的//比如动物吃，你知道它吃什么吗？怎么吃？都不知道,就定义成抽象的.
2) 抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口
3) 抽象类不能实例化
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
抽象类可以声明:抽象类名 类名
多态(继承,重写,父类引用指向子类对象)(编译看左边运行看右边)
4) 抽象类的子类
a.要么是抽象类(可以不用重写抽象方法)
abstract class Cat extends Animal { } 相当于把抽此案够方法继承下来了(不能实例化)
b.要么子类重写抽象类中的所有抽象方法(一般用这种)
2.抽象类的成员特点
1) 成员变量
既可以是变量，也可以是常量。abstract是不能修饰成员变量(值都是具体的)
2) 构造方法
有构造方法,用于子类访问父类数据的初始化。
3) 成员方法
既可以是抽象的，也可以是非抽象的。
3.抽象类的成员方法特性：
a:抽象方法 强制要求子类做的事情。
b:非抽象方法 子类继承的事情，提高代码复用性。
4.为什么非要继承抽象类?
要遵守里面的规则,统一了标准,有了规则就能每个看法自己的了,没有规则则前台开发后台就得写着
定义抽象类,抽象方法,就是给子类做了个声明,声明规则后就需要遵守.
5.abstract不能和哪些关键字共存
1) abstract和static
被abstract修饰的方法没有方法体
被static修饰的可以用类名.调用,但是类名.调用抽象方法是没有意义的
2) abstract和final
被abstract修饰的方法强制子类重写
被final修饰的不让子类重写,所以他俩是矛盾
3) abstract和private
被abstract修饰的是为了让子类看到并强制重写 被private修饰不让子类访问,所以他俩是矛盾的
例:
abstract class Demo {
//public static abstract void print(); //错误: 非法的修饰符组合: abstract和static
//public final abstract void print(); //错误: 非法的修饰符组合: abstract和final
private abstract void print(); //错误: 非法的修饰符组合: abstract和private
}
6.一个抽象类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
可以
这么做目的只有一个,就是不让其他类创建本类对象,交给子类完成
举例说明:
例1:
class bj09_09 {
public static void main(String[] args) {
//Animal a = new Animal(); 不能实例化,不能用于创建但是可以声明
Animal a = new Cat();//父类引用指向子类对象
a.eat();//编译看左边,左边有eat保证编译通过,不调用它//运行走的是右边,执行
System.out.println("Hello World!");
}
}
abstract class Animal { //抽象类
public abstract void eat();//直接;,不加大括号
}
class Cat extends Animal {
public void eat() {
System.out.println("猫吃鱼");
}
}
例2:
class bj09_14 {
public static void main(String[] args) {
Coder c = new Coder("德玛西亚","007",8000);
c.work();
Manager m = new Manager("苍老师","9527",2000,20000);
m.work();
System.out.println("Hello World!");
}
}
abstract class Employee {
private String name; //姓名
private String id; //工号
private double salary; //工资
public Employee() {} //空参 //为了给子类初始化使用的
public Employee(String name,String id,double salary) { //有参
this.name = name;
this.id = id;
this.salary = salary;
}
public void setName(String name) { //设置姓名
this.name = name;
}
public String getName() { //获取姓名
return name;
}
public void setId(String id) { //设置工号
this.id = id;
}
public String getId() { //获取工号
return id;
}
public void setSalary(double salary) { //设置工资
this.salary = salary;
}
public double getSalary() { //获取工资
return salary;
}
public abstract void work();//当无法描述一个方法时就把他定义成抽象的
}
//程序员
class Coder extends Employee {
public Coder(){} //空参
public Coder(String name,String id,double salary){
//this.name = name; //父类中已经被私有化了,所以用super
super(name,id,salary);
} //有参
public void work() {
System.out.println("我的名字是:" + this.getName() + ",我的工号:" + this.getId() + ",我的工资是:" + this.getSalary() + ",我的工作内容是敲代码");
//name这里被父类私有化了,不能被继承,可以通过getName获得,this.name;
}
}
//项目经理
class Manager extends Employee {
private int bonus;
public Manager() {} //空参
public Manager(String name,String id,double salary,int bonus){
super(name,id,salary);
this.bonus = bonus;
} //有参
public void work() {
System.out.println("我的名字是:" + this.getName() +
",我的工号:" + this.getId() + ",我的工资是:" +
this.getSalary() + ",我的奖金是:" + bonus + ",我的工作内容是管理");
}
}
抽象类