19.继承和多态的知识点以及“多态测试南北方人案例“和“final“关键字

1.this和super 的区别(面试题)

  this:代表的当前类对象的地址值引用

  super:代表的父类对象的地址值引用(代表父类的空间标识)

访问成员变量
  this.变量名; 访问的本类中的成员变量 ;     super.变量名; 访问的是父类的成员变量

访问构造方法:
  this() ; 访问本类的无参构造方法;              super() ;访问的父类的无参构造方法
  this(xxx);访问的本类的有参构造方法;       super(xxx);访问的父类的有参构造方法
 成员方法:
   this.方法名();访问的是本类的成员方法;    super.方法名() ;访问的是父类的成员方法

2.方法重写和方法重载的区别?(面试题)
 
方法重载:   在一个类中,提供n多个功能,这些功能,方法名相同,参数列表不同,与返回值无关(目的:提高某个功能的扩展

 参数列表不同: 1)类型不同
                         2)个数不同
                         3)考虑参数类型的顺序

 public static void open(int a,double d){}
 public static void open(double a,int b){}
 构造方法也可以重载!
 方法重写:在继承关系中,子类出现了父类一模一样的方法声明,重写的目的:子类有自己的功能,需要   将父类的该功能覆盖掉!

3.多态例题:

南方人和北方人都有姓名,年龄以及性别,都有"吃饭"的功能,但是南方人经常吃米饭,北方人经常吃面条,南方人主要还去经商,北方人主要考学,请使用面向对象编程并且使用多态形式进行测试南方人和北方人

Person.java

public class Person {
    private String name ;
    private int age ;
    private String position; //职位
    private String gender ;//性别

    public Person() {
    }

    public Person(String name, int age, String position, String gender) {
        this.name = name;
        this.age = age;
        this.position = position;
        this.gender = gender;
    }

    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 getPosition() {
        return position;
    }

    public void setPosition(String position) {
        this.position = position;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    //其他成员方法
    public void eat(){
        System.out.println("人都需要吃饭...");
    }

}

SourthPerson.java

//南方人
public class SourthPerson extends Person{
    public SourthPerson() {
    }

    public SourthPerson(String name, int age, String position, String gender) {
        super(name, age, position, gender);
    }

    //重写父类功能
    @Override
    public void eat() {
        System.out.println("南方人喜欢吃大米");
    }

    //特有功能
    public String business(){
        return "喜欢经商" ;
    }
}

NorthPerson.java

//北方人
public class NorthPerson extends Person {
    public NorthPerson() {
    }

    public NorthPerson(String name, int age, String position, String gender) {
        super(name, age, position, gender);
    }

    @Override
    public void eat() {
        System.out.println("北方人喜欢吃面食");
    }

    //特有功能:学习
    public String study(){
       return "喜欢学习钻研...";
    }
}

PersonTest.java(测试类)

public class PersonTest {
    public static void main(String[] args) {

        //测试南方人
        //直接构造方法赋值
        SourthPerson sp = new SourthPerson("南方人",42,"个体户","女") ;
        System.out.println(sp.getName()+"---"+sp.getAge()+"---"+sp.getPosition()+"---"+sp.getGender());
        String str = sp.business();
        System.out.println(str);
        sp.eat();

        //无参构造+setXXX()/getXXX()
        //北方人自己测试
    }
}

4.final(状态修饰符):最终的,无法更改的
  关于final关键字的特点:
  (1)可以修饰类,该类不能被继承
  (2)可以修饰符成员方法,成员方法不能重写
  (3)可以修饰的变量,这个变量此时是一个常量

5.final ,finally,finalize()的区别?(面试题)

a、final可以修饰类、变量、方法，修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修饰变量表示该变量是一个 常量不能被重新赋值。
b、finally关键字一般在异常中使用，配合try catch 一起使用，表示不管是否发生异常，finally中的内容一定会被执行
c、finalize是一个方法，属于Object类的一个方法，而Object类是所有类的父类，该方法一般由垃圾回收器来调用，当我们调 用System.gc() 方法的时候，由垃圾回收器调用finalize()，回收垃圾，一个对象是否可回收的最后判断。

6. final修饰基本数据类型和引用类型的区别?

final修饰基本数据类型: 基本数据类型的对应的数据值不能在被赋值了,只能赋值一次

final修饰引用类型:引用数据类型对应的地址值不能被改变

7.多态

(1)什么是多态?

     一个事物在不同时刻不同形态

(2)多态的前提条件:

a.必须存在继承关系 (extends)

b.必须存在方法重写 :子类需要覆盖父类的功能
                            

  Animal
      eat():"动物都需要吃饭..."
  Cat
      eat() "猫吃鱼"
  Dog
      eat() "狗吃骨头"

c.必须有父类引用指向子类对象

class Fu{}
class Zi extends Fu{
//存在重写
    }
 
格式: Fu fu = new Zi() ;

 (3)多态的成员访问特点:

Fu fu  = new Zi() ;
a.针对成员变量的访问问题:
   编译看左,运行看左(使用父亲的东西)
b.针对多态中的成员方法的访问问题:  我们所说的成员变量/成员方法----非static
   编译看左,运行看右(因为子类重写了父类的东西)
c.如果成员方法是静态方法:(静态成员方法 算不上方法重写,直接可以类名来访问,跟类相关的方法)
   编译看左,运行看左
d.构造方法:存在继承关系: 还需要让父类先初始化,然后再子类进行数据初始化(分层初始化)

(4)多态的弊端:不能访问子类的特有功能 

解决的方法: (推荐使用:"向下转型")
多态的第三个前提条件:父类 引用指向子类对象:"向上转型 "Fu f = new Zi() ;
能不能将父类的引用转换成子类的引用?  

好处:不需要在堆内存开辟空间
可以------>"向下转型"
Zi z =   (Zi)f ;  还原成子类型
强转类型转换: 目标类型 变量名 =(目标类型)初始化值;

(5)多态的好处

a.提高代码的复用性.(由继承保证)

b.提高代码的扩展性.(由多态保证)