黑马程序员——Java面向对象（二）—继承、final、多态

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------

一、继承

1、继承的概念：

就是对要描述的事物进行不断的向上抽取，就出现了体系结构。

要了解这个体系结构中最共性的内容,就看最顶层的类。

要使用这个体系的功能,就用最底层的类创建对象。

2、继承的好处：

A：继承的出现，提高了代码的复用性。

B：继承的出现，让类与类之间产生了关系，extends来表示，这个关系的出现，为后面我们讲面向对象的第三个特点多态打下了基础。

3、特点

A：java只支持单继承(其实确切的说是java对多继承进行了优化，避免了安全问题)。

B：java支持多重(层)继承。

4、注意：

A：子类可以直接访问父类中的非私有的属性和行为。

B：不要仅为了获取其他类中部分功能而去继承。

C：类与类之间要有所属( " is a " )关系，xx1是xx2的一种。

如何判断A和B是否有继承关系？

A如果继承B，那么就可以说A是B的一种。

5、继承后子父类之间成员的关系

(1)成员变量

class Fu{
int num = 5;
}

class Zi extends Fu{
int num = 20;

public void show() {
int num = 30;
System.out.println("num:"+num);
//当局部变量和成员变量重名的时候用this来区分
System.out.println("this num:"+this.num);
//当子类和父类出现了同名变量,用super来区分
System.out.println("father num:"+super.num);
}
}

总结:在一个类中如果方法中的局部变量和方法外的成员变量重名,那么如果在方法内输出这变量,就是方法自己的变量里的值,想要区分要用this,加上this.就是输出成员变量的值在子父类中如果出现成员变量重名的时候,在子类输出会输出自己的变量里的值,

想要区分要用super,加上super.就是输出父类里变量的值

this和super的区分：

this代表本类对象的引用

super本类对象父类的引用。

this可以用于区分局部变量和成员变量同名的情况。

super可以用于区分子类和父类成员变量同名的情况。

一般，子类中不会出现和父类同名的成员变量。（面试可能问到）

(2)成员方法

class Fu {
public void show() {
System.out.println("fu show");
}
public void method() {}
}

class Zi extends Fu{

public void show(){

System.out.println("zi show");
}
}

子类中存在和父类成员方法同名的这种现象，叫做重写，复写，覆盖。

重写(override)和重载(overload)的区别：

重载的特点：

在同一类中。

方法名相同，参数列表不同。

重写的特点：

要有继承关系。在子父类中

方法的声明相同。(方法名和参数列表都相同)

覆盖时，子类方法权限一定要大于等于父类方法权限

父类的权限不能是私有的

静态只能覆盖静态。

(3)构造方法

class Fu{

Fu(){}

Fu(int age){
System.out.println("father age:"+age);
}
}

class Zi extends Fu{
Zi(){
this(40);
System.out.println("son");
}

Zi(int age){
super();
System.out.println("son age:"+age);
}
}

Zi z = new Zi();

Zi z = new Zi(30);

总结：子类中所有的构造方法默认都会访问父类中空参数的构造方法。

因为每一个构造方法的第一行都有一条默认的语句super();

当父类中没有空参数的构造方法时，子类的构造函数必须通过this或者super语句指定要访问的构造方法。或者手动提供无参构造方法。

this(...):调用本类中的构造方法

super(...):调用父类中的构造方法

构造方法用于创建对象，并进行初始化.建议如果你写了有参的构造函数,也要把空参的构造函数再手动加上

否则你定义了有参的构造函数,空参的系统就不会再给了你这样创建对象的时候，

就会报错Person p = new Person();//这句话是会去找空参的构造函数

class Person{
Person(){}
Person(int age){
this.age = age;
}

Person(int age,String name){
this(age);
//this.age = age;
this.name = name;
}
}

//Person p =new Person();  //系统默认给出无参构造
//当你手动给出构造方法后，系统就不会再给出默认的空的构造方法。

class Demo{
private String name;
Demo(){}

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

public String getName(){
return name;
}
}

二、final

1、final可以用来修饰类：被fainl修饰的类不能被继承。

2、final可以用来修饰成员方法：被final修饰的成员方法不能被重写。

3、final可以用来修饰变量：被final修饰的变量为常量，值不能被修改。

常量的命名规范：要求大写。

final double X = 3.14;

final修饰的变量可以在声明的时候直接赋值,还可以在构造方法可以给final修饰的变量赋值。

三、多态

1、某一类事物的多种存在形态。

方法重载(静态多态)

方法重写(动态多态,对象多态)

2、对象多态的前提

A：类与类(或接口)要有继承(或实现)关系。

B：一定要有方法的重写。

C：一定要有父类或者接口的引用指向子类的对象。

3、多态中成员的调用

Fu f = new Zi();

A：成员变量

当子父中出现同名成员变量时，多态使用时，只看调用该成员变量的引用所属的类中的成员变量。

简单说：无论编译或者运行，都是等号左边

B：成员函数

当子父类出现一模一样函数时，多态调用，

编译时，看的是引用变量所属的类中的方法。

运行时，看的是对象的所述的类中的方法。

简单说，编译看左边，运行看右边。

C：静态函数：

当出现一模一样静态的函数时，多态调用，

编译和运行时，看引用变量所属的类中的方法。

简单说，变异和运行都看左边。

其实，真正调用静态方法是不需要对象的，直接类名调用。因此静态方法绑定到类上。

4、向上转型：

向上转型 Animal a = new Cat(); a.eat(); //a.catchMouse();

好处：隐藏了子类型，提高了代码的扩展性。

弊端：只能使用父类中的的功能，不能使用子类特有功能。功能被限定了。

什么时候用向上转型：

如果不需要面对子类型，通过提高扩展性，或者使用父类的功能即可完成操作，就是用向上转型。

5、向下转型：

Cat c = (Cat)a;
c.eat();
c.catchMouse();

//向上转型
Animal a = new Dog();
//向下转型 转换异常
//Cat c = (Cat)a;
Dog d = (Dog)a;

好处：可以使用子类型的特有功能，

弊端：面向具体的子类型。向下转型有风险。

只要转换类型和对象类型不匹配就会发生异常ClassCastException。想要安全，必须要进行判断。判断一个对象是否匹配某一个类型，需要使用一个关键字instanceof对象

if(!(a instanceof Dog))
{
system.out.println("类型不匹配");
}

总结:无论是向上转型还是向下转型,变化的都是子类对象,绝对不能把父类对象强转为子类类型

6、多态的好处和弊端

好处:提高了程序的扩展性

弊端:不能使用子类特有的属性和行为

-------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------