面向对象-抽象类

简单认识抽象类 

 

 

//抽象类
public   abstract class A {
    //抽象方法，必须使用 abstract修饰，没有方法体
       public  abstract  void  run();
       //抽象类中该有的构造器跟构造方法都有
       private  String name ;
       private  static String schoolname;

    public A() {
    }

    public A(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static String getSchoolname() {
        return schoolname;
    }

    public static void setSchoolname(String schoolname) {
        A.schoolname = schoolname;
    }
}
//一个类继承了抽象类，必须重写完抽象类的全部抽象方法，否则自己也要是抽象类
public abstract class B extends A {

            @Override
    public   void run()
            {

            }
}
public class Test {
    public static void main(String[] args) {
               //抽象类中不能创建对象
             // A a =new A();
    }
}

接口只能定义抽象方法不能实现方法，抽象类既可以定义抽象方法，也可以实现方法。 

// 抽象类 Animal
abstract class Animal {
    // 抽象方法，没有方法体，必须由子类实现
    abstract void makeSound();

    // 具体方法，已经实现了
    void sleep() {
        System.out.println("This animal is sleeping.");
    }
}

// 具体类 Dog 继承自 Animal
class Dog extends Animal {
    // 实现抽象方法
    @Override
    void makeSound() {
        System.out.println("The dog barks.");
    }
}

// 具体类 Cat 继承自 Animal
class Cat extends Animal {
    // 实现抽象方法
    @Override
    void makeSound() {
        System.out.println("The cat meows.");
    }
}

// 主类，测试抽象类和具体类
public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();
        
        myDog.makeSound();  // 输出: The dog barks.
        myDog.sleep();      // 输出: This animal is sleeping.
        
        myCat.makeSound();  // 输出: The cat meows.
        myCat.sleep();      // 输出: This animal is sleeping.
    }
}

 

 

 

 抽象类的好处

 在这个例子中父类的cry没有调用所以可以将父类进行抽象类这样就直接进行抽象重写

//抽象类
public abstract class Animal {
    private  String name;
          public  abstract   void cry();
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Cat extends Animal{

    @Override
    public void cry() {
        System.out.println(getName()+"喵喵叫");
    }
}

public class Dog extends Animal{
    @Override
    public void cry() {
        System.out.println(getName()+"汪汪汪");
    }
}

public class Test {
    public static void main(String[] args) {
                 Animal a =new Cat();//多态
                 a.setName("猫");
                 a.cry();
        System.out.println("-----------");
        Animal a2 =new Dog();
        a2.setName("狗");
        a2.cry();
    }
}

抽象类的常见应用场景：模板方法设计模式 

 

 快捷键：alt+enter直接进行抽象方法重写

注：模板方法尽量用final修饰。

public class Test {
    public static void main(String[] args) {
                 Student s =new Student();
                 s.write();
        System.out.println("-------------");
        Teacher t= new Teacher();
        t.write();
    }
}

public abstract class People {
    public final void  write()
    {
        System.out.println("\t\t《我的爸爸》");
        System.out.println(writemain());
        System.out.println("我爱我的爸爸");
    }
    //定义一个抽象方法用于装抽象
    public  abstract  String writemain();
}
public class Teacher extends  People{
    @Override
    public String writemain() {
        return "我是老师";
    }
}
public  class Student extends People
{
    @Override
    public String writemain() {
        return   "我是学生";
    }
}