Java-抽象类

抽象类

含有抽象方法的类就是抽象类
1) 抽象方法：该方法有返回值，有参数，就是没有方法体，该方法没有方法实现
2) 抽象方法的格式：
abstract 返回值类型方法名（参数列表）；
3) 抽象类需要靠子类来重写抽象方法，以实现其功能

public class Test1 {
    //抽象类：含有抽象方法的类
    //抽象方法：没有方法体的方法
    public static void main(String[] args) {
        Taxi taxi=new Taxi();
        taxi.name="出租车";
        taxi.start();
        taxi.run();
        taxi.stop();
    }
}
//定义一个抽象类Car：属性：名字，价格，速度
//                       方法：启动，运行，刹车，全是抽象方法
abstract class Car{
    String name;
    double price;
    int speed;
    public abstract void start();
    public abstract void run();
    public abstract void stop();
}
class Taxi extends Car{
//抽象类是依靠子类，来实现其功能（子类重写抽象方法）
    public void start() {
        System.out.println(name+"行驶");
    }
    public void run() {
        System.out.println(name+"启动");
    }
    public void stop() {
        System.out.println(name+"刹车");
    }
}

4) 抽象类不能直接实例化（创建对象）

public class Test1 {
    public static void main(String[] args) {
//        Foo1 foo1=new Foo1();---报错
    }
}
abstract class Foo1{
    abstract void show();
}

5) 可以使用抽象类声明一个对象，然后利用该抽象类的子类来创建对象
格式：抽象类对象名-->定义对象
对象名=new 子类构造方法-->创建对象
抽象名对象名=new 子类构造方法

public class Test1 {
    public static void main(String[] args) {
        Koo1 koo1=new Koo2();    //抽象类名（父类） 对象名=new 子类的构造方法
        koo1.show();
    }
}
abstract class Koo1{//父类---声明（定义）对象
    public abstract void show();
}
class Koo2 extends Koo1{//子类---创建对象
    public void show() {
        System.out.println("昨天下雨了");
    }
}

6) 父类声明指向子类引用
格式：父类对象=new 子类的构造方法
编译时（javac）运行时（java）
用这种方式创建的对象，可以访问父类的除重写以外所有的方法，可以访问子类重写父类的方法
唯一不能做的事，就是访问子类独有的方法

public class Test1 {
    public static void main(String[] args) {
        Eoo eoo=new Eoo2();
        eoo.show();//访问子类中重写父类的方法
        eoo.print();//父类中的普通方法
//        eoo.speak();---报错//不能访问子类独有的方法
    }
}
class Eoo{
    void show(){
        System.out.println("今天是个好天气");
    }
    void print(){
        System.out.println("今天是周一");
    }
}
class Eoo2 extends Eoo{
    void show(){
        System.out.println("天气好好");//重写
    }
    void speak(){//子类独有的方法
        System.out.println("说话");
    }
}

7) 抽象类跟一般类是一样的，只是抽象类含有抽象方法（没有方法体的方法）
抽象类需要靠子类来重写所有的抽象方法，以实现其功能
创建对象：
1.直接使用子类来声明和创建对象
2.父类声明指向子类的对象

public class Test1 {
    public static void main(String[] args) {
        Person person=new Worker("张",23,"男",5000);
        person.print();
        person.show();
    }
}
//设计Person类型，属性：姓名，年龄，性别
//               构造方法：1.空参的构造方法
//                        2.带（姓名，年龄，性别）的构造方法
//               方法：show():显示姓名，年龄属性
//                     抽象方法print();
//设计Worker类型，属性：姓名，性别，年龄，工资
//               构造方法：给所有的属性赋值
//               方法：重写print()方法，显示该对象所有的属性
//        
abstract class Person{
    String name;
    int age;
    String sex;
    Person(){}
    Person(String name,int age,String sex){
        this.name=name;
        this.age=age;
        this.sex=sex;
    }
    void show(){
        System.out.println(name+","+age);
    }
    public abstract void print();
}
class Worker extends Person{
    double salary;
    Worker(String name,int age,String sex,double salary){
        super(name,age,sex);
        this.salary=salary;
    }
    public void print() {
        System.out.println(name+","+age+","+sex+","+salary);
    }    
}

设计模式---工厂模式（了解）
用一个类来帮我们创建和管理对象，就是工厂模式

public class Test1 {
    //工厂类中用来提供对象的方法，最好设计静态方法，易于调用
    public static void main(String[] args) {
        Emp emp=EmpFactory.getInstance();
        emp.show();;
    }
}
class EmpFactory{
    public static Emp getInstance(){
    Emp emp=new Emp("刘",45);
    return emp;
    }
}
class Emp{
    String name;
    int age;
    Emp(String name,int age){
        this.name=name;
        this.age=age;
    }
    void show(){
        System.out.println(name+","+age);
    }
}

public class Test1 {
    public static void main(String[] args) {
        Car car=CarFactory.getInstance(1);
        car.name="Bmw";
        car.show();
        Car car1=CarFactory.getInstance(2);
        car1.name="Benz";
        car1.show();
    }
}
//设计一个父类Car，属性：名字
//                构造方法：空参构造方法，带名字的构造方法
//                方法：show显示该Car的名字
//设计一个Car的子类Bmw，属性：速度
//设计一个Car的子类Benz，属性：价格
//设计一个Car的子类QQ，属性：颜色
//设计一个工厂，可以根据用户的请求来创建不同的子类对象

class Car{
    String name;
    Car(){}
    Car(String name){
        this.name=name;
    }
    void show(){
        System.out.println(name);
    }
}
class Bmw extends Car{
    int speed;
}
class Benz extends Car{
    double price;
}
class QQ extends Car{
    String color;
}
//分析：参数来代表用户不同的请求
//1---BMZ,2---Benz,3----QQ
//工厂中获得对象的方法，可以根据调用参数的不同，返回不同的Car的子类对象
class CarFactory{
    public static Car getInstance(int type){
        Car car=null;
        if(type==1){
            car=new Bmw();
        }else if(type==2){
            car=new Benz();
        }else if(type==3){
            car=new QQ();
        }
        return car;
    }
}