6.2Java面对对象(下)

面对对象(下)-1

继承

继承概述：

	1.多个类存在相同的属性和行为时，将这些内容抽取到单独一个类中，
	  那么多个类无需再定义这些属性和行为，只要继承那个类即可。
	  
	2.通过extends关键字可以实现类与类的继承；
		public class 子类名 extends 父类名 {}
		
	3.单独的这个类称为父类，这多个类称为子类。
	
	4.有了继承以后，我们定义一个类的时候，可以在一个已经有的类基础上，定义自己的新成员。

继承的好处与弊端：

继承的好处：
	1.提高了代码的复用性；
	2.提高了代码的维护性；
	3.让类与类之间产生关系;
继承的弊端：
	让类与类之间产生关系，也就让类的耦合性增强了
	开发原则：高内聚，低耦合；
		内聚:就是自己完成某件事的能力；
		耦合:类与类之间的关系;

Java继承中成员变量的特点：

	1.Java中类只支持单继承，不支持多继承；（son ->father or son->gradefather）
	2.Java中类支持多层继承；（son ->father;father ->gradefather）
	-->son可以使用gradefather的方法

	3.成员变量名称不一样，使用的时候很简单。
	4.成员变量一样的情况（就近原则）
		a:在方法的局部变量范围找，如果有就是用；
		b:在子类的成员变量范围找，如果有就是用；
		c:在父类的成员变量范围找，如果有就只用；
		d:如果找不到，就报错；

super关键字：

super和this的用发很像：
	this:代表本类对象的引用
	super:代表父类对象引用（代表父类的存储空间）
		用法：
		访问成员变量--->	this.成员变量
					  super.成员变量

		访问构造方法--->	this(...)
						super(...)
						
		访问成员方法--->	this.成员方法
						super.成员方法

Java继承中构造方法的特点：

Java继承中构造方法访问特点:
	1.子类构造方法执行前都会执行父类无参构造方法；
		原因：因为子类继承父类，会继承父类的非私有成员。
			 而子类在初始化的时候，可能会使用父类的数据，
			 如果父类数据没有先初始化，子类就不能使用这些数据，
			 所以在子类初始化之前，*(一定要先完成父类数据的初始化)（无参构造方法）
	注意：在子类的构造方法中，默认第一行有一条语句：super();

	假如父类中没有无参构造方法如何解决？
		a:添加一个无参构造方法（建议使用）
		b:可以通过super访问父类的带参构造方法（不建议使用）

Java继承中构造方法的特点：

Java继承中构造方法的访问特点：
	子类中方法和父类中方法不一样
	子类方法和父类的方法的声明一样，调用哪一个?
	
通过子类对象调用方法：
	a:在子类中找，有就是用
	b:在父类中找，有就是用
	c:如果没有就报错

Java继承中方法重写的概述和使用：

方法重写：子类中出现了和父类中一模一样的方法声明的情况。
方法重写的应用：当子类需要父类的功能，而功能主体子类又有自己特有内容的时候。

@Override 这是注解，用来标记一个方法，表明该方法时重写父类的方法；

方法重写的注意事项：
	a:父类的私有方法不能被重写；
	b:子类重写父类方法时，访问权限不能更低；（*建议与父类访问权限一致）
	
	
（private << 默认修饰符(什么都不带) << public）

继承的练习

学生与老师案例：
	学生类：
		成员变量：name,age
		构造方法：无参，带参
		成员方法：getXxx(),setXxx(),study()
		
	老师类：
		成员变量：name,age
		构造方法：无参，带参
		成员方法：getXxx(),setXxx(),teach()

这两个类中相同的代码比较多，所以提取一个父类。

	人类：
		 成员变量：name,age
		 构造方法：无参，带参
		 成员方法：getXxx(),setXxx(),teach()

	学生类：
		 继承人类
		 study()
	老师类：
		 继承人类
		 teach()

多态

多态：同一个对象，在不同时刻体现出来的不同状态
举例：
	猫是猫，猫也是动物
	水可以是液体，固体，气体
	
Java中多态的前提
	a:有继承关系
	b:有方法重写
	c:有父类引用指向子类对象
		Fu f = new Fu();
		Zi z = new Zi();
		Fu f = new Zi();

多态中成员访问特点：

成员变量：
	编译看左边，执行看左边；
成员方法：
	编译看左边，执行看右边；

编译与执行访问不一样的原因：

		因为成员放法有重写，而变量没有。

package com.scy;

public class Animal {
    public int age = 40;

    public void eat(){
        System.out.println("吃东西");
    }
}

package com.scy;

public class Cat extends Animal{
    public int age =30;
    public String name = "猫";

    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }

    public void playGame(){
        System.out.println("玩游戏");
    }
}

package com.scy;

public class MainApp {
    public static void main(String[] args) {
        Animal a = new Cat();
        System.out.println(a.age); --->40
//        System.out.println(a.name);  成员变量编译看左边，执行看左边
        a.eat();	--->“猫吃鱼”
//        a.playGame(); 成员方法，编译看左边，执行看右边
    }
}

多态的好处与弊端：

多态的好处：提供了程序的扩展性；
多态的弊端：不能使用子类的特有功能；

package com.scy;     # 父类

public class Animal {
    public int age = 40;

    public void eat(){
        System.out.println("吃东西");
    }
}

package com.scy;  # 子类

public class Cat extends Animal{

    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

package com.scy;	#多态可扩展性的体现；

public class AnimalOperate {
//    public void useAnimal(Cat c){ 
// 						Cat c = new Cat();
//        c.eat();
//    }
//    public void useAnimal(Dog d){ 
// 						Dog d = new Dog();
//        d.eat();
//    }
    public void useAnimal(Animal a ){ 
    				//Animal a = new Cat();多态
        a.eat();
    }
}

package com.scy;	# 测试类

public class MainApp {
    public static void main(String[] args) {
      AnimalOperate ao = new AnimalOperate();
      Cat c = new Cat();
      ao.useAnimal(c);
      Dog d = new Dog();
      ao.useAnimal(d);
    }
}

多态中的转型问题：

向上转型：
	从子到父
	父类引用指向子类对象
向下转型：
	从父到子
	父类引用转为之类对象

public class MainApp {
    public static void main(String[] args) {
     //多态
        Animal a  = new Cat();  # 向上转型
        						# 父类引用指向子类对象
        a.eat();
        a.playGame();//无法访问子类特有方法
        // Cat c = new Cat();
         //这样虽然可以访问子类的特有方法，但是不合理，
         //内存中有两个猫对象；
        // 如何使用一个子类访问子类特有方法？
        // 就要使用多态中的转型了；
        # 父类引用转为之类对象
        Cat c = (Cat)a;
        c.eat();
        c.playGame()
    }

多态转型内存图解:
(ClassCastException)类型转换异常

多态的练习：

package com.scy;

public class MainApp {
    public static void main(String[] args) {
        Animal a = new Cat();   //向上转型
        a.eat();
        Cat c = (Cat) a; //向下转型
        c.eat();
        c.play();
        a = new Dog(); //向上转型
        a.eat();
        Dog d = (Dog) a; //向下转型
        d.eat();
        d.lookDoor();
    }
}