java03三、继承多态

1. 继承

1.1 继承的实现

 概念：继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法

实现继承的格式：

class 子类 extends 父类 { }

举例：class Dog extends Animal { }

继承带来的好处：继承可以让类与类之间产生关系，产生子父类后，子类则可以使用父类中非私有的成员。

1.2 继承的好处和弊端

继承好处提高了代码的复用性(多个类相同的成员可以放到同一个类中)提高了代码的维护性(如果方法的代码需要修改，修改一处即可)

继承弊端 继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性

继承的注意事项：

Java类只能单继承，支持多层继承

son extends father,mother 错

son extends father   father extends grandfather

1.3 super

this&super关键字：

this：代表本类对象的引用

super：代表父类存储空间的标识(可以理解为父类对象引用)

（1）成员变量：

this.成员变量 - 访问本类成员变量

super.成员变量 - 访问父类成员变量

（2）成员方法：

this.成员方法 - 访问本类成员方法

super.成员方法 - 访问父类成员方法

（3）构造方法：

this(…) - 访问本类构造方法

super(…) - 访问父类构造方法

 

1.4  继承中变量的访问特点

 在子类方法中访问一个变量，采用的是就近原则。

1. 子类局部范围找2. 子类成员范围找3. 父类成员范围找4. 如果都没有就报错(不考虑父亲的父亲…)

1.5 继承中成员方法的访问特点

 通过子类对象访问一个方法

1. 子类成员范围找2. 父类成员范围找3. 如果都没有就报错(不考虑父亲的父亲…)

1.6继承中构造方法的访问特点

注意：子类中所有的构造方法默认都会访问父类中无参的构造方法

子类会继承父类中的数据，可能还会使用父类的数据。所以子类初始化之前，一定要先完成父类数据的初始化，原因在于每一个子类构造方法的第一条语句默认是super()

 

public class Zi extends Fu{

      public zi(){super();}

public zi(int age){super();}

  //super()写不写一样，都默认有

}

1.7方法重写（掌握）

1、概念 子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）

2、Override注解重写的方法

方法重写的注意事项：

1. 私有方法不能被重写(父类私有成员子类是不能继承的)

2. 子类方法访问权限不能更低(public > 默认 > 私有)

2  修饰符

2.1  权限修饰符

修饰符	同一个类	同一个包子类、无关类	不同包的子类	不同包的无关类
private	可
默认	可	可
protected	可	可	可
public	可	可	可	可

 

 

 

 

 

 

 

 

 

 

 

2.2  final修饰符

可以修饰成员方法，成员变量，类

final修饰类、方法、变量的效果

 final修饰类：该类不能被继承（不能有子类，但是可以有父类）

final修饰方法：该方法不能被重写

final修饰变量：表明该变量是一个常量，不能再次赋值

被final修饰的常见类：String,StringBuilder,StringBuffer

注意：final修饰基本类型变量，值不能改变

           final修饰引用类型变量，地址值不能改变，但地址存的内容可以改变

final int age=1； age=2；错

final Student s=new Student（2）；s.setAge（3）; 对

     s=new Student（）；错

2.3  static 修饰符

2.3.1 static修饰的特点

static可以修饰成员方法、成员变量 

(1) 被类的所有对象共享

 (2)可以通过类名调用当然，也可以通过对象名调用【推荐使用类名调用】

 

2.3.2 static访问特点（掌握）

static的访问特点

非静态的成员方法

能访问静态的成员变量

能访问非静态的成员变量

能访问静态的成员方法

能访问非静态的成员方法

静态的成员方法

能访问静态的成员变量

能访问静态的成员方法

总结成一句话就是：静态成员方法只能访问静态成员、方法

 

3 多态

3.1多态特点

继承是多态的前提，没有继承就没有多态

继承主要解决的问题就是：共性抽取

多态：同一个对象，在不同时刻表现出来的不同形态

多态的前提和体现：

（1）有extends继承或者implements实现关系

（2）有方法重写

（3）有父类引用指向子类对象

（4）有父接口引用指向实现类对象

3.2 多态中的成员访问特点

成员访问特点

成员变量 ：编译看父类，运行看父类

成员方法 ：编译看父类，运行看子类

因为成员方法有重写，成员变量不能重写。

代码演示：

动物类

public class Animal {   

public int age = 40;   

 public void eat() {  System.out.println("动物");    }

}

猫类

public class Cat extends Animal {  

 public int age = 20;    public int weight = 10;   

 @Override   

public void eat() {  System.out.println("猫吃鱼");    }     public void playGame() { System.out.println("猫捉迷藏");    }

}

测试类

public class TestDemo { 

    public static void main(String[] args) {       

//有父类引用指向子类象      

 Animal a = new Cat();       

 System.out.println(a.age);//40        System.out.println(a.weight); //报错      

 a.eat();//  猫吃鱼      a.playGame();  //报错

} 

3.3多态的好处和弊端

 好处：提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作

弊端： 不能使用子类的特有成员

3.4多态中的转型

（1） 向上转型

父类引用指向子类对象

（2）向下转型

格式：子类型 对象名 = (子类型)父类引用;

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

 //向下转型        Cat c = (Cat)a;

4抽象类

抽象类的成员特点

成员变量：既可以是变量也可以是常量

构造方法：空参构造有参构造

成员方法：抽象方法普通方法

5 接口

 5.1 接口的特点

public interface 接口名 {}

（1）类实现接口用implements表示   

（2）接口不能实例化

接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态。 多态的形式：具体类多态，抽象类多态，接口多态。

（3）接口的子类

 要么重写接口中的所有抽象方法 要么子类也是抽象类

 5.2 接口的成员特点

成员变量： 只能是常量 默认修饰符：public static final

构造方法： 没有

成员方法：只能是抽象方法 默认修饰符：public abstract

 5.3类和接口的关系

类和类：继承关系，只能单继承可多层继承，注意不是多继承

 类和接口：实现关系，可单实现也可多实现

接口和接口：继承关系，可单继承也可【多继承】

 

抽象类和接口的区别：

（1）成员区别：

       抽象类可以变量常量、构造方法，有抽象非抽象方法

     接口只能有常量和抽象方法

（2）设计概念区别：

    抽象类：对类的抽象，属性和行为

   接口：对行为的抽象，主要是行为。