面向对象---继承

一、继承的引入

继承:
将多个类抽取位一个独立的类,让独立的类和多个类产生继承关系
继承 的关键字:extends
格式:
  class 子类名 extends 父类名{
...
}
继承的好处:
1)提供了代码复用性,解决了代码的臃肿

2)它是多态的前提(多态的前提是必须有继承关系)

下来我们通过具体的代码来体会一下继承的好处：

继承之前:...

class Student{
	public void study() {
		System.out.println("学生在学习....");
	}
}
class Teacher{
	public void sleep() {
		System.out.println("老师在讲课...");
	}
}
class programmer{
	public void work() {
		System.out.println("程序员在codeing...");
	}
}

//测试类

public class ExtendsDemo {

	public static void main(String[] args) {
		//调用study方法
		Student s = new Student() ;
		s.study(); 
		
		System.out.println("--------------");
		Programmer p = new Programmer() ;
		p.work() ;
		
		System.out.println("--------------");
		Teacher t = new Teacher() ;
		t.teach(); 
	}
}

    这样的代码非常臃肿，如果要定义一千种职业呢？难道我们要定义一千个类然后再每个定义吗？为了解决这种问题，Java提供了继承的方法，我们把Student，Teacher，Programmer类的共性抽取出来，重新定义一个Person类，Person类包含study、work、teach方法，然后我们的Student、Teacher、Programmer类只要将Person类继承过去就可以实现之前的方法，因为父类里面包含这些，代码实现如下：

class Person{
	private String name ;
	public void study() {
		System.out.println("学生在学习....");
	}
	public void teach() {
		System.out.println("老师在讲课...");
	}
		public void work() {
			System.out.println("程序员在codeing...");
		}
}

//学生类
class Student extends Person{}
//程序员类
class Programmer extends Person{}
//老师类
class Teacher extends Person{}

//测试类
public class ExtendsDemo {
	
	public static void main(String[] args) {

		Student s = new Student() ;
		s.study(); 

		Programmer p = new Programmer() ;
		p.work() ;
		
		Teacher t = new Teacher() ;
		t.teach(); 
	}
}

二、继承的特点

继承的特点:

        子类继承父类,是继承了父类所有的东西(成员变量,成员方法,包括私有),但是子类不能使用私有的东西,只能通过父类的公共的访问间接的让子类访问它.

继承的另外一个特点:

  在Java中,继承只支持单继承,不支持多继承(子类名 extends 父类名1,父类名2,...)
  但是,Java是可以支持多层继承...

 类和类之间的关系:继承关系

 类和接口之间的关系:实现关系（以后讲）

多层继承的例子：

class GrandFather{
	public void function() {
		System.out.println("我是爷爷...");
	}
}
class Father extends GrandFather{
	public void show() {
		System.out.println("我是爸爸....");
	}
}
//子类
class Son extends Father{ //只支持单继承
	//子类有自己特有的玩游戏的功能
	public void playGame() {
		System.out.println("儿子会玩绝地求生....");
	}
}

//测试类
public class ExtendsDemo2 {

	public static void main(String[] args) {
		
		//测试Son类
		Son s = new Son();
		s.function(); 
		s.show();
		//访问自己的功能
		s.playGame();
	}
}

Son类继承了Father类，Father类继承了GrandFather类，这就是一种多层继承的关系，子类又有自己单独的方法，所以子类既能调用爷爷类的function功能，又能调用爸爸类的show功能，还能调用自己的playGame功能。

三、继承中的注意事项:

注意事项：

   1)构造方法不能被继承,但是通过super关键字去访问

2)父类中被private修饰的,是可以继承,但是只能间接的去访问私有的..（可以使用super）

假设:有一个A类
class A{
public void show1(){}
public void show2(){}
  }
 
有一个B类
class B{
public void show1(){}
   public void method(){}
   }
 
 按照正常的情况:发现A类和B类中有共同的show1()方法,根据继承的概念,---->让B类继承A类
class B extends A{
   public void method(){}
}
  
  没有问题,但是继承了A类,show1(),show2()也继承过来了,可能show2()并不是我想要的功能;对于这种情况不要使用继承
 
  继承体现的是一种"is a"的关系:
   如果A是B的一种或者B是A的一种,这个可以使用继承!
   水果
   香蕉
苹果
   橘子
 
   人类
   学生
   老师
军人...
 不要随意的使用继承,只要有"is a"的关系就使用它..
  Java开发设计原则:
低耦合,高内聚

耦合:类和类之间的关系 ,尽量降低耦合性
内聚:指的是做一件事情能力(尽量使用一个类完成的事情不要多个类去完成..)
  
  在继承中,成员变量的名称问题
当前子类继承父类的时候,子类和父类中的成员变量名称不一致的情况,非常简单,分别输出就可以了;
   当子类和父类中的成员变量名称一致的情况:
  1)先到子类的局部位置找,如果找到了,就输出
2)没有找到,到子类的成员位置找,有就输出,
3)在类的成员位置还没有找到,直接父类的成员位置找,有就输出

4)如果还没有,就报错了,不存在这个变量

代码举例：

class Fu{
	int num = 50 ;
	
	public void method() {
		int num = 100 ;
		System.out.println(num);
	}
}
class Zi extends Fu{
	public int num2 =20 ;

	//show
	public void show() {
		System.out.println(num);
		System.out.println(num2);
	}
}
//测试类
public class ExtendsDemo {
	
	public static void main(String[] args) {
		
		//创建Zi类对象
		Zi z = new Zi() ;
		z.show();
	}
}

输出结果：

50

20

四、super关键字

要访问这个子类的局部位置的变量,直接可以访问.
需求:要访问Son类的成员位置的这个变量nun,如何访问

需求:要访问Father类的成员位置的变量nun.如何访问?

Java提供关键字：super代表的父类的空间标识(父类的引用或父类的对象)

this和super关键字的用法:
   成员变量:
this:
this.成员变量; (访问当前类)
   super:
super.成员变量;(访问父类)
  
   构造方法:
  this(); //无参构造
   this("") ;//访问当前类的有参构造
super()://访问的父类的无参构造
   super("")://访问的是父类的有参构造..
  成员方法:
   this.xx()

super.xx()

class Father extends Object{
	int num = 100 ;

	public Father() {
		super();
	}
}

//子类
class Son extends Father{
	public int num = 50 ;
	public void show() {
		int num = 20 ;
		System.out.println(num);
		System.out.println(this.num); //this代表了当前的类对象 :Son
		System.out.println(super.num); //super 代表的父类引用
	}
}

//测试类
public class ExtendsDemo2 {

	public static void main(String[] args) {
		//创建对象
		Son s = new Son() ;
		s.show(); 
	}
}

代码运行结果：

20

50

100

五、继承中的问题

1、关于继承的成员的问题：

构造方法:
  子类继承父类,都会默认的访问父类的无参构造方法
假设数据还没有被初始化完毕,所以应该先让父类进行初始化,然后在让子类初始化--->分层初始化

class Fu2{
	public Fu2() {
		System.out.println("父类无参构造方法....");
	}
	
	public Fu2(String name) {
		System.out.println("父类的有参构造方法...");
	}
}
//子类
class Zi2 extends Fu2{
	public Zi2() {
//		super() ;
		System.out.println("子类的无参构造....");
	}
	
	public Zi2(String name) {
//		super() ;
		System.out.println("子类的有参构造....");
	}
}

//测试类
public class ExtendsDemo3 {

	public static void main(String[] args) {
		
		Zi2 zi = new Zi2() ;
		System.out.println("---------------");
		Zi2 zi2 = new Zi2("张三") ;
		
	}
}

代码运行结果：

父类无参构造方法....

子类的无参构造....
---------------
父类无参构造方法....

子类的有参构造....

子类继承父类，默认访问父类的无参构造！

如果父类的无参构造没有提供?怎么办?
   肯定报错;
   如何解决:
   1)可以将父类的无参构造提供出来
   2)可以super关键字去访问父类的带参构造...
   3)还可以在子类中通过this(),访问本类中的有参构造,间接的去访问父类带参构造

   子类的构造方法必须有一个(有参构造/无参构造),让父类进行初始化!

2、继承中成员方法的问题
子类继承父类,访问成员方法名不一致的情况,分别调用!
  当子类中的成员方名和父类中的成员方法名一致的情况:
   1)现在子类的成员位置找,如果有就调用

2)如果没有找到,在父类的成员位置找,有就调用

学习了这么多，我们来试着做道题，看看它的输出结果应该是什么：

class X {
	Y b = new Y();
	X() {
		System.out.print("X");//x
	}
}

class Y {
	Y() {
		System.out.print("Y");  //y
	}
}

public class Z extends X {
	Y y = new Y();
	Z() {
//		super() ; //这个第一句话super(),this(),默认都在一句话,可以省略....
		System.out.print("Z");
		
	}
	public static void main(String[] args) {
		new Z(); 
	}
}

运行结果：

y

x

y

z

-------------------------------华丽分割线------------------------------------

分析：

    首先执行main方法，new一个z对象出来，由于z对象继承了x，所以首先对x进行初始化，x的初始化首先new了一个y对象，所以走y的无参构造，打印y，然后接着对x继续进行初始化，打印x，此时x初始化完毕，执行new y的操作，走y的无参构造打印y，此时再顺序走z的无参构造，打印z。因此打印顺序是y x y z。

六、继承案例

/**
 * 猫狗案例的继承版
 * 
 * 		猫:
 * 			属性:  姓名    ,年龄 ,  毛色
 * 			行为:  玩毛线,猫吃鱼...
 * 		----->Cat 类
 * 				成员变量:name,age,color
 * 				成员方法:setXXX/getXXX()
 * 						 playGame(),eat()...
 * 				构造方法:无参/有参
 * 
 * 		狗:
 * 			属性:  姓名    ,年龄 ,  毛色
 * 			行为:  看门,狗吃骨头
 * 		----->Dog 类
 * 				成员变量:name,age,color
 * 				成员方法:setXXX/getXXX()
 * 						 playGame(),eat()...
 * 				构造方法:无参/有参
 * 
 * ---->将共性的内容抽取一个类中, Animal类
 *class Animal{
 *	...共性内容
 *}
 *
 *Cat类和Dog类分别继承自Animal类
 *			
 * @author Administrator
 *
 */
//动物类
class Animal{
	private String name ;
	private int age ;
	private String color ;
	
	//无参
	//alt+shift+s-->C
	public Animal() {
	}

	//有参
	//alt+shift+s-->O
	public Animal(String name, int age, String color) {
		super();
		this.name = name;
		this.age = age;
		this.color = color;
	}
	
	
	//公共的访问方法:alt+shift+s-->R
	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}
	
	public void eat() {
		System.out.println("动物吃的方法...");
	}
	
	public void sleep() {
		System.out.println("动物睡觉的方法...");
	}
	
}
//猫类
class Cat extends Animal{

	public Cat() {
		super();
	}

	public Cat(String name, int age, String color) {
		super(name, age, color);
	}
	
	//自己的功能,吃(吃鱼),当子类定义一个和父类一模一样的方法声明---->继承中的方法重写
	
	public void eat() {//子类覆盖掉父类中eat()方法,显示自己的特有功能
		System.out.println("猫吃鱼....");
	}
	
	public void playGame() {
		System.out.println("猫玩毛线....");
	}
	
	
	public void sleep() {
		System.out.println("猫趴着睡觉....");
	}
} 

//狗类
class Dog extends Animal{

	public Dog() {
		super();
	}

	public Dog(String name, int age, String color) {
		super(name, age, color);
	}
	
	//覆盖方法
	public void eat() {
		System.out.println("狗吃骨头...");
	}
	
	//特有功能
	public void lookDoor() {
		System.out.println("狗看门...");
	}
	
	public void sleep() {
		System.out.println("狗躺着睡...");
	}
	
}

//测试类
public class AnimalDemo {
	
	public static void main(String[] args) {
		
		//测试猫类
		Cat c = new Cat() ;
		c.setName("Tom");
		c.setAge(5); 
		c.setColor("白色");
		System.out.println(c.getName()+"----"+c.getAge()+"----"+c.getColor());
		c.eat();
		c.playGame();
		c.sleep();
		System.out.println("---------------------------------");
		//方式2:
		Cat c2 = new Cat("咖啡", 5, "褐色") ;
		System.out.println(c2.getName()+"----"+c2.getAge()+"----"+c2.getColor());
		c2.eat();
		c2.playGame();
		c2.sleep();
		
		//狗类
		Dog d = new Dog("毛毛",1,"白色");
		System.out.println(d.getName()+"----"+d.getAge()+"----"+d.getColor());
		d.eat();
		d.lookDoor();
		d.sleep();
		
	}
}

注意事项：

    当子类定义一个和父类一模一样的方法声明---->继承中的方法重写，注意与重载进行区别！

    （重载指的是在同一个类中的两个或两个以上的方法，拥有相同的方法名，但是参数却不相同，方法体也不相同。）

六、final关键字

        由于子类继承父类的时候,提供一模一样的方法声明,然后会将父类该方法覆盖掉(重写,复写)，有时候(具体的需求),不需要子类重写父类的功能,针对这种情况,Java提供了一个关键字:final 最终的,终态的意思

   （1）它可以修饰类,那么该类不能继承
   （2）它可以修饰成员方法,成员方法不能被重写
   （3）它可以修饰变量,此时这个变量是一个常量
  
          常量的分类:
       字面值常量:
       字符串常量,字符常量,,,,
  
       自定义常量(final修饰的)

       pubic final int num = 100 ;

         （4）final不仅可以修饰基本数据类型，还可以修饰引用类型
       如果final修饰的是一个基本数据类型:基本数据类型的值不能再改变了...
       如果final修饰的是一个引用类型数据:引用类型的地址值不能再改变了,但是堆内存中的成员变量的值可以变
  
  final的初始化时机:
   被final只能被赋值一次(final int a = 10 )
   final int a ;
   在使用之前进行初始化,赋值(在构造方法之前赋值) (非静态的...)