其他分享
首页 > 其他分享> > 2022-07-21 第4组 蒋萍 面向对象（4）

2022-07-21 第4组 蒋萍 面向对象（4）

作者：互联网

继承（Java面向对象三大特征之一）

目录

1.1、使用继承

1.1.1 编写父类A

访问修饰符 class A{
    // 公有属性和方法
}

1.1.2 编写子类B，继承父类A

访问修饰符 class B extends A{
    // 子类特有的属性和方法
}

注意

image

image

*上图截自菜鸟教程

访问父类的父类的成员，使用一个super. 就可以

1.2 继承的特性

1.3 子类继承父类的什么？

1.4 super和this关键字

super：super调父类，指向父类，但不代表任何对象；

this：当前对象
this调当前类，代表当前类的对象（方法调用者），可以作为返回值返回，super不可，super也不能当参数；

如果子类父类中出现了 重名成员变量，这是访问是有影响的！！！

区分同名成员变量，到底是父成员变量还是子成员变量，需要使用super关键字，修饰父类的成员变量，类似于这前所学this；或者可以理解为super可以使被屏蔽掉（子父类成员变量重名了）的成员可见。

使用格式：

super.父类成员变量名

// super();super(name，health，……)——访问父类构造方法

this.子类成员变量名

note：

super调用父类构造方法时只可有一条且必须放在第一句；

super只能出现在子类的普通方法和构造方法里；
super.属性/方法 ：调用父类的属性/方法（super可以省略，调构造器不能省略）

1.5 继承条件下构造方法的调用原则

note：

调用 自己本类的构造方法：

public PP(){} // 无参构造
public PP(String name,int age){
    // 方法体
}
public PP(String name,int age,String sex){
    this(name,age); // this写于首行
    // …………
}

二、访问权限控制

1、类的访问控制；

2、类成员的访问控制；

常用的访问控制修饰符：

2.1 实现类的访问控制

类的访问修饰符：

2.2 类成员的访问修饰符

​ 只有本类可访问。

​ 对象：变量、方法。 注意：不能修饰类（外部类）

​ 对同一包内的类和所有子类可见。（本类、同包、子类）

​ 使用对象：变量、方法。 注意：不能修饰类（外部类）。

image

三、static 修饰符（静态）

3.1、类的成员变量

3.1.1 类变量（静态变量）

public class Student{
    // 实例变量
    int age;
    String name;
    //类变量
    public static String email;
}

public class Test{
    public static void main(String[] args){
       // 使用
		System.out.println(Student.email);// 类名.属性
    }    
}

3.1.2 实例变量

public class Student{
    // 实例变量
    int age;
    String name;
}

public class Test{
    public static void main(String[] args){
        Student stu=new Student();// 创建实例对象
        System.out.println(stu.age);// 使用
    }    
}

3.1.3 static变量的作用

  1. 能被类的所有实例共享，可作为实例之间进行交流的共享数据；
  2. 如果类的所有实例都包含一个相同的常量属性，可把该属性定义为静态常量类型，从而节省内存空间。
// 模拟实现选民投票过程：
// 一群选民进行一次投票，当总票数达到100时停止投票
   // 选民类
public class Voter {
    private static int count;// 投票总数
    private static final int MAX_COUNT=100;// 静态常量
    private static String name;
// 构造方法
    public Voter(){}
    public Voter(String name){
        this.name=name;
    }
// 还可封装
   public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return this.name;
    }

    public void voteFor(){
        if (count==MAX_COUNT){
            System.out.println("已停止投票！");
            return; // 结束程序
        }else {
            count++;
            System.out.println(this.name+"投票成功！");
        }
    }
}

// 测试类
public class TestVoter {
    public static void main(String[] args) {
        Voter zhang=new Voter("张三");// 1号选民（构造方法的使用）
        zhang.voteFor();

        for (int i = 1; i <=99; i++) {
            Voter  names=new Voter("name"+i);
            names.voteFor();
        }
    }
}

3.2、static 方法

3.2.1 静态方法

  1. 可直接通过类名访问，（静态方法访问不不能直接访问实例的变量和方法）

  2. 静态方法中不能使用 this 和 super 为什么呢？？

    静态方法不需要创建对象，而this和super与对象有关；

  3. 可直接访问静态变量和静态方法

  4. 静态方法必须被实现（得有方法体）

    为什么main方法（程序入口）是静态 ???

    在加载类的时候就会执行静态方法相关代码，而静态方法与类相关，只要加载类，就会执行与类相关的main方法，不用创建类对象就可以执行。

3.2.2 实例方法（普通方法）

  1. 实例方法可直接访问所属类的静态变量、静态方法、实例变量、实例方法
// 打印投票结果
// 静态方法
    public static void printRes(){
        System.out.println("投票总数："+count);
    }

// 在测试类里调用
Voter.printRes();// 通过类名调直接用静态方法

3.3、静态代码块

JVM加载类时，加载静态代码块。

3.4、注意

在继承只是继承共性而个性没法很好的实现，怎么办呢：

可以先继承共性，再补全个性，于是我们有了方法重写：

四、方法重写（override）

方法重写时，可以扩展对父类所定义同名方法，是实现多态的基础。

方法重写：父子(返回值类型 方法名 （方法的参数列表）)必须都相同

方法重写里可以调用父类的方法;

note:

先得有继承才能有重写（必须是父子类）！！！

  1. 方法名必须相同；
  2. 参数列表相同；
  3. 返回值可以不一样；（返回值类型相同或是其子类）
  4. 访问权限不严于父类；（要么一样要么比你更宽松，public重写时不能是private）
    5、抛出异常：重写方法不能抛出比被重写的方法更大的异常

父类的（非）静态方法不能被子类重写为（静态）非静态；

父类的 私有方法 不能被子类重写；( 此时本就不能继承，更不能重写)

不能抛出比父类更多的异常；

看到这里，我们就更加容易理解到：在子类重写父类方法后，这里我们可以理解为父类的方法被屏蔽（覆盖）了，此时通过super. 就可以被屏蔽的成员变量可见。

// 下面这种写法不常见，这里就是第3、的体现

// 父类方法
public Person m1(){
        System.out.println("我是父类的m1方法");
        return new Person();
    } 

// 子类方法
public Student m1(){
    // 这里Student是Person的一个子类，所以这也是方法重写
        System.out.println("我是子类的m1方法");
        return new Student();
    }

4.2 方法重载(overload)和方法重写(override)区别

1、重载：同一个类里的多个方法，且它们同名不同参；（与访问权限修饰符、返回值无关）

2、重写：子类里重写父类方法，父子类（两个类），子父类同名同参（注意访问权限和返回值）

4.5、关于super的理解例子

// 找到程序入口然后“顺藤摸瓜”

// 父类
public class Father {
    String name="Father";
    public void m1(){
        System.out.println("我是Father类的m1方法");
    }
}
// 子类
public class Son extends Father{
    String name="Son";

    /*
    方法重写了！！！
    此时原来父类的m1方法已经被Son类覆盖；
    所以在main方法中执行的是本类的方法，
    */
    public void m1(){
        System.out.println("我是Son类的m1方法");
    }
    public void varTest(){
        super.m1(); // 此时这里才是父类的m1方法
        System.out.println(name);// 此时的name="Son"
        System.out.println(super.name);// 这里name="Father"
        super.m1();// 这时调用的是本类的方法
    }
// 程序入口
    public static void main(String[] args) {
        /* super. 不能出现在静态方法区中 */
        Son son=new Son();// 找到Son类
        son.varTest();// 方法调用
        son.m1();// 执行本类的m1方法
    }
}
/*我是Father类的m1方法
Son
Father
我是Father类的m1方法
我是Son类的m1方法
*/

标签：super,07,子类,修饰符,蒋萍,2022,父类,方法,public
来源： https://www.cnblogs.com/fulfill/p/15991849.html