java面向对象之继承

继承（inheritance)

Java支持单继承：一个类只能有一个直接父类

                关键字：extends

                  class Student extends Person{...}

注：如果没有extends子句，则该类默认为java.lang.Object的子类，所有的类都是通过直接或间接的继承java.lang.Object。

            继承则相当于is--a的关系

继承的好处

1）提供了代码的复用性，解决了代码的臃肿；
2）它是多态的前提。

Java中继承的特点

子类继承了父类所有的东西，但是子类不能使用父类私有的东西，只能通过访问父类共有的方法间接的让子类访问它。

Java中继承的注意事项?以及我们什么时候使用继承?

A：子类只能继承父类非私有成员（成员方法和成员变量）
B:   子类不能继承父类的构造方法，但是可以通过super关键字去访问父类的构造方法

C:   不要为了部分功能去继承

案例分析：

package Test;

/*
猫狗案例

先找到具体的事物，然后发现具体的事物有共性，才提取出一个父类。

猫：
	成员变量：姓名，年龄，颜色
	构造方法：无参，带参
	成员方法：
		getXxx()/setXxx()
		eat()
		palyGame()
狗：
	成员变量：姓名，年龄，颜色
	构造方法：无参，带参
	成员方法：
		getXxx()/setXxx()
		eat()
		lookDoor()
		
共性：
	成员变量：姓名，年龄，颜色
	构造方法：无参，带参
	成员方法：
		getXxx()/setXxx()
		eat()
		
把共性定义到一个类中，这个类的名字叫：动物。
动物类：
	成员变量：姓名，年龄，颜色
	构造方法：无参，带参
	成员方法：
		getXxx()/setXxx()
		eat()
		
	猫：	
		构造方法：无参，带参
		成员方法：palyGame()
	狗：
		构造方法：无参，带参
		成员方法：lookDoor()
*/
//定义动物类
class Animal {
//姓名
private String name;
//年龄
private int age;
//颜色
private String color;

public Animal() {}

public Animal(String name,int age,String color) {
	this.name = name;
	this.age = age;
	this.color = color;
}


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("不要睡了,该吃饭了");
}
}

//定义猫类
class Cat extends Animal {
public Cat() {}

public Cat(String name,int age,String color) {
	super(name,age,color);
}

public void playGame() {
	System.out.println("猫玩英雄联盟");
}
}

//定义狗类
class Dog extends Animal {
public Dog() {}

public Dog(String name,int age,String color) {
	super(name,age,color);
}

public void lookDoor() {
	System.out.println("狗看家");
}
}

//测试类
class Test{
public static void main(String[] args) {
	//测试猫
	//方式1
	Cat c1 = new Cat();
	c1.setName("Tom");
	c1.setAge(3);
	c1.setColor("白色");
	System.out.println("猫的名字是："+c1.getName()+";年龄是："+c1.getAge()+";颜色是："+c1.getColor());
	c1.eat();
	c1.playGame();
	System.out.println("---------------");
	
	//方式2
	Cat c2 = new Cat("杰瑞",5,"土豪金");
	System.out.println("猫的名字是："+c2.getName()+";年龄是："+c2.getAge()+";颜色是："+c2.getColor());
	c2.eat();
	c2.playGame();
	
	//测试狗
	//方式1
	Dog d1 = new Dog();
	d1.setName("Jem");
	d1.setAge(6);
	d1.setColor("红色");
	System.out.println("狗的名字是："+d1.getName()+";年龄是："+d1.getAge()+";颜色是："+d1.getColor());
	d1.eat();
	d1.lookDoor();
	System.out.println("---------------");
	
	//方式2
	Dog d2 = new Dog("汪汪",8,"深灰");
	System.out.println("狗的名字是："+d2.getName()+";年龄是："+d2.getAge()+";颜色是："+d2.getColor());
	d2.eat();
	d2.lookDoor();
}
}

运行结果如下：

猫的名字是：Tom;年龄是：3;颜色是：白色
不要睡了,该吃饭了
猫玩英雄联盟
---------------
猫的名字是：杰瑞;年龄是：5;颜色是：土豪金
不要睡了,该吃饭了
猫玩英雄联盟
狗的名字是：Jem;年龄是：6;颜色是：红色
不要睡了,该吃饭了
狗看家
---------------
狗的名字是：汪汪;年龄是：8;颜色是：深灰
不要睡了,该吃饭了
狗看家

方法重写和方法重载的区别?

Overload：方法重载 方法名一样，参数不同（1、参数类型不同 2、参数个数不同），和返回值没有关系

Override：方法重写 子类定义和父类一模一样的方法声明，实现对父类方法的覆盖

super的使用：

1）使用super访问父类的域和方法（在覆盖父类方法的同时，又利用已定义好的父类的方法）

                使用super可以访问被子类所隐藏的同名变量

                当覆盖父类的同名方法的同时，又要调用父类的方法，就必须使用super

2）使用父类的构造方法（构造方法不能被继承）

                如：父类Person有一构造方法Person(String ,  int)不能说子类Student也自动有一个构造方法Student(String ,  int)

                       但，子类在构造方法中，可以用super来调用父类的构造方法，使用时，super()必须放在第一句。

//Student类中的构造方法
Student (String name , int age , String school)
{
   super(name, age);//super()必须放在第一句！
   this.school = school;
}

父类对象与子类对象的转换：

1）向上转型：父类的引用指向子类对象 Father f  = new Son() ;   
2）向下转型：将父类的引用强制转换子类的引用 Son s = (Son) f;