Java面向对象篇：封装、继承、多态（二）-阿里云开发者社区

7.6 方法重写

1、方法重写概念

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

2、方法重写的应用场景

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

3、Override注解

用来检测当前的方法，是否是重写的方法，起到【校验】的作用

7.7 方法重写的注意事项

方法重写的注意事项

私有方法不能被重写(父类私有成员子类是不能继承的)
子类方法访问权限不能更低(public > 默认 > 私有)

示例代码

public class Fu {
    private void show() {
        System.out.println("Fu中show()方法被调用");
    }
    void method() {
        System.out.println("Fu中method()方法被调用");
    }
}
public class Zi extends Fu {
    /* 编译【出错】，子类不能重写父类私有的方法*/
    @Override
    private void show() {
        System.out.println("Zi中show()方法被调用");
    }
    /* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    private void method() {
        System.out.println("Zi中method()方法被调用");
    }
    /* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    public void method() {
        System.out.println("Zi中method()方法被调用");
    }
}

7.8. Java中继承的注意事项

Java中继承的注意事项

Java中类只支持单继承，不支持多继承

错误范例：class A extends B, C { }

Java中类支持多层继承

多层继承示例代码：

public class Granddad {
    public void drink() {
        System.out.println("爷爷爱喝酒");
    }
}
public class Father extends Granddad {
    public void smoke() {
        System.out.println("爸爸爱抽烟");
    }
}
public class Mother {
    public void dance() {
        System.out.println("妈妈爱跳舞");
    }
}
public class Son extends Father {
  // 此时，Son类中就同时拥有drink方法以及smoke方法
}

8. 继承练习

8.1 老师和学生

需求：定义老师类和学生类，然后写代码测试；最后找到老师类和学生类当中的共性内容，抽取出一个父类，用继承的方式改写代码，并进行测试

步骤：

①定义老师类(姓名，年龄，教书())

②定义学生类(姓名，年龄，学习())

③定义测试类，写代码测试

④共性抽取父类，定义人类(姓名，年龄)

⑤定义老师类，继承人类，并给出自己特有方法：教书()

⑥定义学生类，继承人类，并给出自己特有方法：学习()

⑦定义测试类，写代码测试

示例代码：

class Person {
    private String name;
    private int age;
    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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;
    }
}
class Teacher extends Person {
    public Teacher() {}
    public Teacher(String name,int age) {
        super(name,age);
    }
    public void teach() {
        System.out.println("用爱成就每一位学员");
    }
}
class Student extends Person{
    public Student() {}
    public Student(String name, int age) {
        super(name,age);
    }
    public void study(){
        System.out.println("学生学习");
    }
}
class PersonDemo {
    public static void main(String[] args){
        //创建老师类对象并进行测试
        Teacher t1 = new Teacher();
        t1.setName("林青霞");
        t1.setAge(30);
        System.out.println(t1.getName() + "," + t1.getAge());
        t1.teach();
        Teacher t2 = new Teacher("风清扬", 33);
        System.out.println(t2.getName() + "," + t2.getAge());
        t2.teach();
        // 创建学生类对象测试
        Student s = new Student("张三"，23)；
        System.out.println(s.getName() + "," + s.getAge());
        s.study();
    }
}

8.2 猫和狗

需求：请采用继承的思想实现猫和狗的案例，并在测试类中进行测试

分析：

①猫：

成员变量：姓名，年龄

构造方法：无参，带参

成员方法：get/set方法，抓老鼠()

②狗：

成员变量：姓名，年龄

构造方法：无参，带参

成员方法：get/set方法，看门()

③共性：

成员变量：姓名，年龄；构造方法：无参，带参；成员方法：get/set方法

步骤：

1、定义动物类(Animal)

【成员变量：姓名，年龄】【构造方法：无参，带参】【成员方法：get/set方法】

2、定义猫类(Cat)，继承动物类

【构造方法：无参，带参】【成员方法：抓老鼠() 】

3、定义狗类(Dog)，继承动物类

【构造方法：无参，带参】【成员方法：看门() 】

4、定义测试类(AnimalDemo)，写代码测试

示例代码：

class Animal {
    private String name;
    private int age;
    public Animal() {
    }
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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;
    }
}
class Cat extends Animal {
    public Cat() {
    }
    public Cat(String name, int age) {
        super(name, age);
    }
    public void catchMouse() {
        System.out.println("猫抓老鼠");
    }
}
class Dog extends Animal {
    public Dog() {
    }
    public Dog(String name, int age) {
        super(name, age);
    }
    public void lookDoor() {
        System.out.println("狗看门");
    }
}
/*
    测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //创建猫类对象并进行测试
        Cat c1 = new Cat();
        c1.setName("加菲猫");
        c1.setAge(5);
        System.out.println(c1.getName() + "," + c1.getAge());
        c1.catchMouse();
        Cat c2 = new Cat("加菲猫", 5);
        System.out.println(c2.getName() + "," + c2.getAge());
        c2.catchMouse();
    }
}

9. 修饰符

9.1 package

1、包的概念

包就是文件夹，用来管理类文件的

2、包的定义格式

package 包名; (多级包用.分开)

例如：package com.heima.demo;

3、带包编译&带包运行

带包编译：javac –d . 类名.java

例如：javac -d . com.heima.demo.HelloWorld.java

带包运行：java 包名+类名

例如：java com.heima.demo.HelloWorld

9.2 import

导包的意义
使用不同包下的类时，使用的时候要写类的全路径，写起来太麻烦了
为了简化带包的操作，Java就提供了导包的功能
导包的格式
格式：import 包名;
范例：import java.util.Scanner;
示例代码（没有使用导包，创建的Scanner对象）

package com.heima;
public class Demo {
    public static void main(String[] args) {
        // 1. 没有导包，创建Scnaner对象
        java.util.Scanner sc = new java.util.Scanner(System.in);
    }
}

示例代码（使用导包后，创建的Scanner对象）

package com.heima;
import java.util.Scanner;
public class Demo {
    public static void main(String[] args) {
        // 1. 没有导包，创建Scnaner对象
        Scanner sc = new Scanner(System.in);
    }
}

9.3 权限修饰符

9.4 final

fianl关键字的作用

final代表最终的意思，可以修饰成员方法，成员变量，类

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

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

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

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

9.5 final修饰局部变量

fianl修饰基本数据类型变量

final 修饰指的是基本类型的数据值不能发生改变

final修饰引用数据类型变量

final 修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的
举例：

public static void main(String[] args){
    final Student s = new Student(23);
    s = new Student(24);  // 错误
  s.setAge(24);  // 正确
}

9.6 static

static的概念

static关键字是静态的意思，可以修饰【成员方法】，【成员变量】

static修饰的特点

被类的所有对象共享，这也是我们判断是否使用静态关键字的条件
可以通过类名调用当然，也可以通过对象名调用**【推荐使用类名调用】**

示例代码：

class Student {
    public String name; //姓名
    public int age; //年龄
    public static String university; //学校 共享数据！所以设计为静态！
    public void show() {
        System.out.println(name + "," + age + "," + university);
    }
}
public class StaticDemo {
    public static void main(String[] args) {
      // 为对象的共享数据赋值
        Student.university = "传智大学";
        Student s1 = new Student();
        s1.name = "林青霞";
        s1.age = 30;
        s1.show();
        Student s2 = new Student();
        s2.name = "风清扬";
        s2.age = 33;
        s2.show();
    }
}

9.7 static访问特点

static的访问特点

非静态的成员方法

能访问静态的成员变量
能访问非静态的成员变量
能访问静态的成员方法
能访问非静态的成员方法

静态的成员方法

能访问静态的成员变量
能访问静态的成员方法

总结成一句话就是：

静态成员方法只能访问静态成员

10. 多态

10.1 多态的概述

什么是多态
同一个对象，在不同时刻表现出来的不同形态
多态的前提

要有继承或实现关系
要有方法的重写
要有父类引用指向子类对象

10.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 AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();
        System.out.println(a.age);
//        System.out.println(a.weight);
        a.eat();
//        a.playGame();
    }
}

10.3 多态的好处和弊端

好处
提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作
弊端
不能使用子类的特有成员

10.4 多态中的转型

向上转型
父类引用指向子类对象就是向上转型
向下转型
格式：子类型对象名 = (子类型)父类引用;
代码演示

public class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}

猫类

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}

测试类

public class AnimalDemo {
    public static void main(String[] args) {
        //多态
        //向上转型
        Animal a = new Cat();
        a.eat();
//      a.playGame();
        //向下转型
        Cat c = (Cat)a;
        c.eat();
        c.playGame();
    }
}

Java面向对象篇：封装、继承、多态（二）

7.6 方法重写

7.7 方法重写的注意事项

7.8. Java中继承的注意事项

8. 继承练习

8.1 老师和学生

8.2 猫和狗

9. 修饰符

9.1 package

9.2 import

9.3 权限修饰符

9.4 final

9.5 final修饰局部变量

9.6 static

9.7 static访问特点

10. 多态

10.1 多态的概述

10.2 多态中的成员访问特点

10.3 多态的好处和弊端

10.4 多态中的转型

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Java面向对象篇：封装、继承、多态（二）

7.6 方法重写

7.7 方法重写的注意事项

7.8. Java中继承的注意事项

8. 继承练习

8.1 老师和学生

8.2 猫和狗

9. 修饰符

9.1 package

9.2 import

9.3 权限修饰符

9.4 final

9.5 final修饰局部变量

9.6 static

9.7 static访问特点

10. 多态

10.1 多态的概述

10.2 多态中的成员访问特点

10.3 多态的好处和弊端

10.4 多态中的转型

热门文章

最新文章

相关课程

相关电子书

相关实验场景