2020-10-30

面向对象程序设计语言的三大特性：继承，封装，多态

封装：封装可以隐藏实现细节，使得代码模块化；仅对外提供公共访问方式。

封装时的权限控制符区别如下:

// private    封装的标识
   private String name;
   private int age;

// 封装之后只能通过一些共有的方法访问
 getName() {
 		return name;
 	}

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

 	public int getAge() {
 		return age;
 	}

 	public void setAge(int age) {
 		if(age<0) {
 			System.out.println("设置的年龄不合法");
 			this.age = 0;
 		}else {this.age = age;
 		}
 	};

// 直接访问不被允许
Scanner scan = new Scanner(System.in);
Student s1 = new Student();
s1.name = "小明";//错误
s1.setName(scan.next());//正确

封装的益处：
1.良好的封装能够减少耦合。
2.类内部的结构可以自由修改。
3.可以对成员进行更精确的控制。
4.隐藏信息，实现细节。

继承：是指可以让某个类型的对象获得另一个类型的对象的属性的方法。

兔子和羊继承自食草动物，狮子和老虎继承自食肉动物，这两类动物都继承自动物这个类。
虽然兔子和羊都是食草动物，但是他们也有自己的属性和行为。

// 
class A{
private String name;
private int age;
public void(){
   System.out.println("你好！");
   }
......
       };
   
 class B extends A{  //继承的关键词
 //extends
         private String sno;
           ......
                }//B子类不仅有自己
                //的属性还从父类那里
                //继承来了父类的
                //属性和方法。
                //值得注意的是
                //object类是根类是
                //所有类的父类（超类）
 //假设还有一个A1类
 class B extends A1{
    ...
   }//这是不被允许的 ，Java是单继承机制，
   //不支持多继承，但是可喜的是
   //我们有interface接口，
   //来实现多继承
             

继承的缺点：增加了类之间的耦合。
如果没有继承，那么各个类之间耦合确实降低了，但这就大大的增加了代码量，使编程过于繁琐。再者现实世界也确实存在着普遍的联系，所以相对而言继承是必不可少。

多态：

同一行为具有多个不同表现形式或形态的能力。
同一个接口，使用不同的实例而执行不同操作。

// shape类的draw方法
public abstract void draw(Graphics g);

//Triangle 子类的draw
@Override
	public void draw(Graphics g) {
		g.drawPolygon(x, y, x.length);
	}

//Line类的  draw
@Override
	public void draw(Graphics g) {
		g.drawLine(x1, y1, x2, y2);
	}

多态的体现除了继承后方法的重载，还有cast 造型（向上或向下）
子类转换为父类的规则：
将一个父类的引用指向一个子类的对象，称为向上转型(upcasting)，自动进行类型转换。此时通过父类引用调用的方法是子类覆盖或继承父类的方法，不是父类的方法。 此时通过父类引用变量无法调用子类特有的方法；

如果父类要调用子类的特有方法就得将一个指向子类对象的父类引用赋给一个子类的引用，称为向下转型，此时必须进行强制类型转换。
如下面的代码所示：

// Animal类和Cat类，Dog类都已经声明，
//且Cat和Dog类继承自Animal
public class TestAnimalDemo {
    public static void main(String[] args) {
        show(new Cat()); // 以 Cat 对象调用 show 方法
        show(new Dog()); // 以 Dog 对象调用 show 方法
        Animal a = new Cat(); // 向上转型
        a.eat(); // 调用的是 Cat 的 eat
        Cat c = (Cat) a; // 向下转型
        c.work(); // 调用的是 Cat 的 work
    }
    public static void show(Animal a) {
        a.eat();
        // instanceof关键字，
        //用来判断A对象是不是B类型
        ///如果是则返回true 否则返回false
        if (a instanceof Cat) { // 猫做的事情
            Cat c = (Cat) a;
            c.work();
        } else if (a instanceof Dog) { // 狗做的事情
            Dog c = (Dog) a;
            c.work();
        }
    }
};