java笔记2.10

今天是抽象类（C++中应该是叫虚基类）

先复习一下多态

import javax.sound.sampled.SourceDataLine;

public class b {
    public static void main(String[] args) {

        // 关于多态一定要记住，p1和p2依旧是person类，只能访问person类中有的东西
        person p1 = new student();
        person p2 = new teacher();
        p1.function();
        p2.function();

        // 子类类型，才可以访问衍生所扩展的方法
        student s1 = new student();
        teacher t1 = new teacher();
        s1.study();
        t1.teach();
    }
}

class person {
    public int age;
    public String name;
    public int height;

    public void function() {
        System.out.println("人类: " + name + ",身高:" + height + ",年龄:" + age);
    }
}

class student extends person {
    public void function() {
        System.out.println("学生: " + name + ",身高:" + height + ",年龄:" + age);
    }

    public void study() {
        System.out.println("学生学习");
    }
}

class teacher extends person {
    public void function() {
        System.out.println("教师: " + name + ",身高:" + height + ",年龄:" + age);
    }

    public void teach() {
        System.out.println("老师教书");
    }
}

public abstract class b {
    public abstract void function();

	public void function2()
	{
		System.out.println("但是有什么用呢？抽象类中可以包含非抽象方法");
	}
}

但是有什么用呢？有什么特别的？
.
.
.
.
.
需要没有方法体的方法
抽象类不能直接使用，不可直接实例化

抽象类中不一定是抽象方法
但含抽象方法，就一定是抽象类

二种用法
1. 重写抽象类中所有抽象
2. 子类也是抽象类

class class2 extends class1 {
    @Override
    void function() {
        }
}

// 继续抽象类
abstract class class3 extends class1 {
    // 这一句写与不写都一样
    abstract void function();
}

.
.
.
.
.
.

貌似并没有什么好处
强制要求重写方法
强制继承后才可使用
（保证安全性？）

好处就是：当我不希望能够实例化父类的时候可以使用抽象类
比如说：人类，我不希望你能够实例化一个人类对象，我只希望你能够实例化更具体的对象，比如说，男人，女人；这时候可以使用抽象类
人类，并不是所需要的具体的类的时候。

.
.
.
.
换种说法：当我需要黑人白人黄种人男人女人…等多种类的时候，而我又不需要人类这个类。
为了通过继承减少代码量，我就创建一个抽象类，抽象类是对“各种人”的特征集合！

public class b {
    public static void main(String[] args) {
        class1 c1 = new class2();
        class1 c2 = new class3();
        c1.function();
        c2.function();

        // 还是不可以，和多态相比较有何优势吗？
        // c1.function2();
        // c2.function2();

    }
}

abstract class class1 {
    abstract void function();
}

class class2 extends class1 {
    @Override
    void function() {
        System.out.println("class2这里重写抽象类中的方法");
    }

    void function2() {
        System.out.println("class2自己的方法");
    }

}

class class3 extends class1 {
    void function() {
        System.out.println("class3这里重写抽象类中的方法");
    }

    void function2() {
        System.out.println("class3自己的方法");
    }
}

…
.
.
.
.
.
.

#include
using namespace std;
class Person 
{
    public:
    virtual void function()
    {
        cout<<"这是人类"<
   public:
   virtual void function() 
   {
       cout << "学生学习" << endl;
   }
};

class Teacher : public Person
{
   public:
   virtual void function() 
   {
       cout << "老师教书" << endl;
   }
};

int main()
{
    // 不同类，调用不同的函数
   Student s;
   Person p;
   Teacher t;
   s.function();
   t.function();
   p.function();

}