Java进阶 -- 继承

面向对象-继承

1. 概念：一种子父类关系，子类可以拥有父类的成员变量和成员方法。

2. 继承格式： public class 子类 extends 父类{ }

3. 继承可以解决什么问题？

   如果多个类都有相同的成员变量和成员方法，那么就可以给这些类提取一个父类，让这类去继承父类。

4. 注意事项：
   1、一个类可以有多个子类，但是只能有一个父类。
   2、Java不支持多继承，但是支持多层继承。也就是只支持单继承。

/*
	父类
*/
public class Fu {
    public void show() {
        System.out.println("Fu类中的show方法");
    }
}

/*
	子类
*/
public class Zi extends Fu {
}

/*
	测试类
*/
public class ExtendsDemo {
    public static void main(String[] args) {
        // 创建父类对象
        Fu f = new Fu();
        // 调用父类方法
        f.show();

        // 创建zi类对象
        Zi z = new Zi();
        // 用子类对象，调用父类方法
        z.show();
    }
}

继承中成员变量、成员方法、构造方法的访问特点

• 成员变量的访问特点：
  就近原则：方法内有同名局部变量就是访问局部变量，如果没有同名局部变量就方法当前类的成员变量， 如果当前类没有同名的成员变量，就访问父类的成员变量。如果父类也没有，就编译报错。

    例如：
   
        //如果要打印当前子类的age=20，该如何输出
        System.out.println(this.age);
        //如果要打印父类的age=40，该如何输出
        System.out.println(super.age);
        
     this和super的区别？
        this表达当前类对象，如果当前类是子类，那么this就表示子类对象。
        super：当前类的父类对象。
  

• 构造方法的访问特点：
  1、创建子类对象的同时默认会执行父类的空参构造，创建父类对象，目的：初始化父类中的成员变量，因为子类可能会使用到父类的成员变量。

  2、如果在子类的构造方法中访问父类的有参构造，那么需要在构造方法的第一行使用super关键字。例如：

			public Zi(int age){
                //需求；访问父类的有参构造？
                super(age);//将new zi(20)中的20传递个父类的构造方法。
                System.out.println("zi类的带参构造");
            }

注意事项：super(…)可以不写，默认就是访问父类的空参构造，如果写了，就必须是构造方法中的第一行代码

• 成员方法的访问特点：
  子类对象在调用方法时，如果子类中有这个方法，那么就是调用子类的方法，如果子类中没有这个方法，那么就调用父类的该方法。如果父类中也没有该方法，那么就编译编译报错。当然在子类的方法中可以使用super.方法名()访问父类的成员方法。

			public void show(){
                super.show();
                System.out.println("子类中的show方法执行了...");
            }

总结：this表达当前类的对象，super表示当前类的父类对象，super点任意东西都指的是父类中的内容。

方法的重写

• 方法重载：在同一个类中，方法名相同，参数列表(参数个数不同，相同位置的参数类型不同)不同就是方法重载。方法重载和返回值、变量名无关。

• 方法重写：在子父类关系中，子类定义了一个和父类一样(方法名和参数吧列表一样)的方法就是方法的重写。

• 小提示：1、子类如果要重写父类的方法，不需要复制粘贴，只需要在子类中写要重写的方法名就会有提示。 2、@Override注解主要是在编译期检查方法是不是重写，如果是重写的方法就不会编译报错，反之就报错。

• 方法重写的目的：扩展功能。如果父类中方法的功能不能满足需求，那么子类就可以重写该方法，自己重写写方法体来实现需求，子类重写了该方法，那么调用的时候就是调用子类的方法。

• 方法重写的注意实现： 在开发中一般重写的方法权限修饰符和父类的一样即可。（一定不能比父类的小）

• 案例1：老师类和学生类

需求：
            1、定义老师类（姓名、年龄成员变量，教书的方法）
            2、定义学生类（姓名、年龄成员变量、学习的方法）
        分析：
            1、定义一个老师类和学生类的父类Person
            2、在Person类中定义name和age，提供get/set方法
            3、定义老师类和学生类继承Person类，声明各自特有的teach和study方法。
            4、定义测试类进行测试
        测试类：PersonDemo
            1、创建Teacher对象，调用set方法赋值
            2、调用get方法打印老师的名字和年龄，调用teach方法
            3、创建Student对象，调用set方法赋值
            4、调用get方法打印学生的名字和年龄，调用study方法

/*
	Person父类
*/
public class Person {
    private String name;
    private int age;

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

    public Person() {
    }

    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;
    }
}

/*
	Student子类
*/
public class Student extends Person{
    public Student(String name, int age) {
        super(name, age);
    }
    public Student() {
    }

    public void study() {
        System.out.println("我爱学习");
    }
}

/*
	Teacher子类
*/
public class Teacher extends Person {
    public void teach() {
        System.out.println("我爱教书");
    }
}

/*
	测试类
*/
public class PersonDemo {
    public static void main(String[] args) {
        // 创建教师对象
        Teacher t1 = new Teacher();
        t1.setName("于曼丽");
        t1.setAge(18);
        System.out.println(t1.getName() + ", " + t1.getAge());
        t1.teach();


        // 创建学生对象
        Student s1 = new Student("刘达亮", 28, 12);

        System.out.println(s1.getName() + ", " + s1.getAge());
        s1.study();
    }
}

package、import、final、static关键字

• package:包，包的本质是文件夹，多级包使用点隔开。package表示当前类所在的包。package com.jxufe_ldl;

• import：导包，引入其他类所在的包。

• package和import的区别？
  package用于表示当前类所在的包，import表示导入其他类所在的包。

• Java权限修饰符：public > protected > 默认 > private

  1、掌握public和private：public修饰的成员变量和成员方法任何包中的任何类都能访问，private修饰的成员变量和成员方法只能自己类访问。
  2、同一个包中的类相互访问，最少可以访问三种修饰符修饰的成员变量和成员方法。
  3、不同包中的类相互方法，最多可以访问两种修饰符修饰的成员变量和方法。

• final:最终的。

  1、final修饰类：表示这个类是最终类，不能被继承。
  2、final修饰变量(成员变量和局部变量)：被final修饰变量是常量，基本数据类型值或者引用数据类型地址值不能发生改变。
  3、final修饰成员方法：表示这个方法是最终方法，不能被子类重写。

  注意：final不能修饰构造方法；

• static：静态的
  1、static修饰的成员变量不属于类的某个对象，被类的所有对象共享。
  2、static修饰的内容可以直接使用类名点调用
  例如：类名.成员变量名,类名.方法名()

  注意：非静态方法中既可以访问静态成员，也可以访问非静态成员
  静态方法中只能访问静态成员，不能访问非静态成员