day14-多态&final&包&权限修饰

海绵宝宝丶哈

已于 2024-03-16 00:10:42 修改

阅读量41

点赞数

分类专栏： Java学习文章标签： java android 开发语言

于 2024-03-15 14:11:44 首次发布

原文链接：https://www.bilibili.com/video/BV17F411T7Ao?p=129&vd_source=e3b917eea18314bd051ef5d2f859d9b3

版权

Java学习专栏收录该内容

37 篇文章 0 订阅

订阅专栏

第一章多态

1.1 多态的形式

多态是继封装、继承之后，面向对象的第三大特性。

多态是出现在继承或者实现关系中的。

多态体现的格式：

父类类型 变量名 = new 子类/实现类构造器;
变量名.方法名();

多态的前提：有继承关系，子类对象是可以赋值给父类类型的变量。例如Animal是一个动物类型，而Cat是一个猫类型。Cat继承了Animal，Cat对象也是Animal类型，自然可以赋值给父类类型的变量。

1.2 多态的使用场景

如果没有多态，在下图中register方法只能传递学生对象，其他的Teacher和administrator对象是无法传递给register方法方法的，在这种情况下，只能定义三个不同的register方法分别接收学生，老师和管理员。

在这里插入图片描述

有了多态之后，方法的形参就可以定义为共同的父类Person。

要注意的是：

当一个方法的形参是一个类，我们可以传递这个类所有的子类对象。
当一个方法的形参是一个接口，我们可以传递这个接口所有的实现类对象（后面会学）。
而且多态还可以根据传递的不同对象来调用不同类中的方法。

在这里插入图片描述

代码示例：

class Person {
    private String name;
    private int 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;
    }

    public void show(){
        System.out.println(name + ", " + age);
    }
}

class Administrator extends Person {
    @Override
    public void show() {
        System.out.println("管理员的信息为：" + getName() + ", " + getAge());
    }
}

class Student extends Person{

    @Override
    public void show() {
        System.out.println("学生的信息为：" + getName() + ", " + getAge());
    }
}

class Teacher extends Person{

    @Override
    public void show() {
        System.out.println("老师的信息为：" + getName() + ", " + getAge());
    }
}

public class Test {
    public static void main(String[] args) {
        //创建三个对象，并调用register方法

        Student s = new Student();
        s.setName("张三");
        s.setAge(18);


        Teacher t = new Teacher();
        t.setName("王建国");
        t.setAge(30);

        Administrator admin = new Administrator();
        admin.setName("管理员");
        admin.setAge(35);
        register(s);//学生的信息为：张三, 18
        register(t);//老师的信息为：王建国, 30
        register(admin);//管理员的信息为：管理员, 35


    }
    //这个方法既能接收老师，又能接收学生，还能接收管理员
    //只能把参数写成这三个类型的父类
    public static void register(Person p){
        p.show();
    }
}

1.3 多态的定义和前提

多态：同类的对象，表现出的不同形态

从上面案例可以看出，Teacher、Student、Administrator都是Person，都展示这个行为，但是出现的效果（表现形式）是不一样的。

前提【重点】

有继承或者实现关系
方法的重写【意义体现：不重写，无意义】
父类引用指向子类对象【格式体现】

父类类型：指子类对象继承的父类类型，或者实现的父接口类型。

在这里插入图片描述

1.4 多态的运行特点

调用成员变量时：编译看左边，运行看左边
解释：

编译看左边：javac编译代码的时候，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有编译失败
运行看左边：java运行代码的时候，实际获取的就是左边父类中成员变量的值

调用成员方法时：编译看左边，运行看右边
解释：

编译看左边：javac编译代码的时候，会看左边的父类中有没有这个方法，如果有，编译成功，如果没有编译失败
运行看左边：java运行代码的时候，实际上运行得是子类的方法

如何理解：

在这里插入图片描述

GPT解释：

在 Java 中，多态是面向对象编程的一个核心概念，它允许一个引用类型变量在不同情况下引用不同类型的对象，实现方法的动态绑定。多态的实现主要依靠 Java 的继承和接口机制。当涉及到多态时，成员变量和成员方法的访问规则确实不同，这主要是由 Java 的绑定机制决定的：

成员变量的访问规则：编译看左边，运行还看左边
当通过一个多态的引用来访问成员变量时，Java 总是参考变量的声明类型（即引用变量的类型，也就是代码中变量定义时的类型，通常称为左边类型）来确定应该访问的变量。这是因为成员变量的访问在编译时就已经确定下来了，运行时不会改变。这种机制被称为“静态绑定”或“早期绑定”。

成员方法的访问规则：编译看左边，运行看右边
当通过一个多态的引用来调用一个方法时，Java 在编译时使用引用的声明类型来检查方法的存在性和可访问性（即编译看左边），但在运行时，它实际上会调用实际对象的方法（即运行看右边）。如果这个实际对象覆盖了该方法，则调用的是子类的覆盖版本；如果没有覆盖，则调用的是父类的方法。这种根据对象的实际类型来动态绑定方法的机制被称为“动态绑定”或“晚期绑定”。
为什么设计成这样？
成员变量不支持多态：成员变量的行为不是多态的，因为成员变量在对象中占用固定的内存空间，而多态性主要应用于可以被覆盖的方法上，这允许子类提供具体实现的动态行为。Java 中的继承确保了成员变量可以被继承，但它们的值是和具体的对象实例绑定的，而不是动态决定的。

方法支持多态：对于方法而言，多态性是面向对象编程的一个重要特性，允许一个类表现出与其它类不同的功能。这是通过方法的覆盖（Override）和接口的实现来达成的。Java 虚拟机（JVM）在运行时期根据对象的实际类型来动态地决定应该调用哪个方法，从而实现运行时的多态性。
这种设计使得 Java 语言既保持了面向对象编程的灵活性和动态性（通过方法的多态），又保持了一定的性能和稳定性（通过变量的静态绑定）。

1.5 多态的弊端

我们已经知道多态编译阶段是看左边父类类型的，如果子类有些独有的功能，此时多态的写法就无法访问子类独有功能了。

class Animal{
    public  void eat()｛
        System.out.println("动物吃东西！")
    ｝
}
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
   
    public void catchMouse() {  
        System.out.println("抓老鼠");  
    }  
}  

class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
}

class Test{
    public static void main(String[] args){
        Animal a = new Cat();
        a.eat();
        a.catchMouse();//编译报错，编译看左边，Animal没有这个方法
    }
}

1.6 引用类型转换

1.6.1 为什么要转型

多态的写法就无法访问子类独有功能了。

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。

回顾基本数据类型转换

自动转换: 范围小的赋值给范围大的.自动完成:double d = 5;
强制转换: 范围大的赋值给范围小的,强制转换:int i = (int)3.14

多态的转型分为向上转型（自动转换）与向下转型（强制转换）两种。

1.6.2 向上转型（自动转换）

向上转型：多态本身是子类类型向父类类型向上转换（自动转换）的过程，这个过程是默认的。
当父类引用指向一个子类对象时，便是向上转型。
使用格式：

父类类型  变量名 = new 子类类型();
如：Animal a = new Cat();

**原因是：父类类型相对与子类来说是大范围的类型，Animal是动物类，是父类类型。Cat是猫类，是子类类型。Animal类型的范围当然很大，包含一切动物。**所以子类范围小可以直接自动转型给父类类型的变量。

1.6.3 向下转型（强制转换）

向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。
一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

使用格式：

子类类型 变量名 = (子类类型) 父类变量名;
如:Aniaml a = new Cat();
   Cat c =(Cat) a;

1.6.4 案例演示

转型演示，代码如下：

定义类：

abstract class Animal {  
    abstract void eat();  
}  

class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void catchMouse() {  
        System.out.println("抓老鼠");  
    }  
}  

class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void watchHouse() {  
        System.out.println("看家");  
    }  
}

定义测试类：

public class Test {
    public static void main(String[] args) {
        // 向上转型  
        Animal a = new Cat();  
        a.eat(); 				// 调用的是 Cat 的 eat

        // 向下转型  
        Cat c = (Cat)a;       
        c.catchMouse(); 		// 调用的是 Cat 的 catchMouse
    }  
}

1.6.5 转型的异常

转型的过程中，一不小心就会遇到这样的问题，请看如下代码：

public class Test {
    public static void main(String[] args) {
        // 向上转型  
        Animal a = new Cat();  
        a.eat();               // 调用的是 Cat 的 eat

        // 向下转型  
        Dog d = (Dog)a;       
        d.watchHouse();        // 调用的是 Dog 的 watchHouse 【运行报错】
    }  
}

这段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。

1.6.6 instanceof关键字

为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：

变量名 instanceof 数据类型 
如果变量属于该数据类型或者其子类类型，返回true。
如果变量不属于该数据类型或者其子类类型，返回false。

所以，转换前，我们最好先做一个判断，代码如下：

public class Test {
    public static void main(String[] args) {
        // 向上转型  
        Animal a = new Cat();  
        a.eat();               // 调用的是 Cat 的 eat

        // 向下转型  
        if (a instanceof Cat){
            Cat c = (Cat)a;       
            c.catchMouse();        // 调用的是 Cat 的 catchMouse
        } else if (a instanceof Dog){
            Dog d = (Dog)a;       
            d.watchHouse();       // 调用的是 Dog 的 watchHouse
        }
    }  
}

1.6.7 instanceof新特性

JDK14的时候提出了新特性，把判断和强转合并成了一行

//新特性
//先判断a是否为Dog类型，如果是，则强转成Dog类型，转换之后变量名为d
//如果不是，则不强转，结果直接是false
if(a instanceof Dog d){
    d.lookHome();
}else if(a instanceof Cat c){
    c.catchMouse();
}else{
    System.out.println("没有这个类型，无法转换");
}

在这里插入图片描述

1.7 综合练习

需求：根据需求完成代码:
1.定义狗类
		属性：
			年龄，颜色
		行为:
			eat(String something)(something表示吃的东西)
			看家lookHome方法(无参数)
2.定义猫类
	属性：
		年龄，颜色
	行为:
		eat(String something)方法(something表示吃的东西)
		逮老鼠catchMouse方法(无参数)
3.定义Person类//饲养员
	属性：
		姓名，年龄
	行为：
		keepPet(Dog dog,String something)方法
			功能：喂养宠物狗，something表示喂养的东西
	行为：
		keepPet(Cat cat,String something)方法
			功能：喂养宠物猫，something表示喂养的东西
	生成空参有参构造，set和get方法  
4.定义测试类(完成以下打印效果):
	keepPet(Dog dog,String somethind)方法打印内容如下：
		年龄为30岁的老王养了一只黑颜色的2岁的狗
		2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃
	keepPet(Cat cat,String somethind)方法打印内容如下：
		年龄为25岁的老李养了一只灰颜色的3岁的猫
		3岁的灰颜色的猫眯着眼睛侧着头吃鱼
5.思考：		
	1.Dog和Cat都是Animal的子类，以上案例中针对不同的动物，定义了不同的keepPet方法，过于繁琐，能否简化，并体会简化后的好处？
	2.Dog和Cat虽然都是Animal的子类，但是都有其特有方法，能否想办法在keepPet中调用特有方法？

画图分析：

在这里插入图片描述

代码示例：

public class Animal {
    private int age;

    private String color;

    public Animal(){

    }

    public Animal(int age, String color) {
        this.age = age;
        this.color = color;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public void eat(String food){
        System.out.println("吃"+food);
    }
}




public class Dog extends Animal{
    public Dog(){}

    public Dog(int age, String color){
        super(age,color);
    }

    @Override
    public void eat(String food){
        System.out.println(this.getAge()+"岁的"+this.getColor()+"颜色的狗两只前腿死死的抱住"+food+"猛吃");
    }

    public void lookHome(){
        System.out.println("看家");
    }
}





public class Cat extends Animal{
    public Cat(){}

    public Cat(int age,String color){
        super(age,color);
    }

    @Override
    public void eat(String food){
        System.out.println(this.getAge()+"岁的"+this.getColor()+"颜色的猫眯着眼睛侧着头吃"+food);
    }

    public void catchMouse(){
        System.out.println("抓老鼠");
    }
}





import com.sun.deploy.security.ValidationState;

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

    public void keepPet(Animal animal,String food){

        if (animal instanceof Dog){
            Dog animal1 = (Dog) animal;
            System.out.println("年龄为"+this.getAge()+"岁的"+this.getName()+"养了一只"+animal.getColor()+"颜色的"+animal.getAge()+"岁的狗");
            animal.eat(food);
            animal1.lookHome();
        }
        else if(animal instanceof Cat){
            Cat animal2 = (Cat) animal;
            System.out.println("年龄为"+this.getAge()+"岁的"+this.getName()+"养了一只"+animal.getColor()+"颜色的"+animal.getAge()+"岁的猫");
            animal.eat(food);
            animal2.catchMouse();
        }
        else {
            System.out.println("没有这样的动物！");
        }


    }


}





public class Main {
    public static void main(String[] args) {
        Person laowang = new Person("老王", 30);
        Dog dog = new Dog(2, "黑");
        laowang.keepPet(dog,"骨头");


        System.out.println("=====================");


        Person laoli = new Person("老李", 25);
        Cat cat = new Cat(3, "灰");
        laoli.keepPet(cat,"鱼");
    }
}

第二章包

2.1 包

包在操作系统中

其实就是一个文件夹。包是用来分门别类的管理技术，不同的技术类放在不同的包下，方便管理和维护。

在IDEA项目中，建包的操作如下：

在这里插入图片描述

包名的命名规范：

路径名.路径名.xxx.xxx
// 例如：com.itheima.oa

包名一般是公司域名的倒写。例如：黑马是www.itheima.com,包名就可以定义成com.itheima.技术名称。
包名必须用”.“连接。
包名的每个路径名必须是一个合法的标识符，而且不能是Java的关键字。

2.2 导包

什么时候需要导包？

情况一：在使用Java中提供的非核心包中的类时

情况二：使用自己写的其他包中的类时

什么时候不需要导包？

情况一：在使用Java核心包（java.lang）中的类时

情况二：在使用自己写的同一个包中的类时

2.3 使用不同包下的相同类怎么办？

假设demo1和demo2中都有一个Student该如何使用？

代码示例：

//使用全类名的形式即可。
//全类名：包名 + 类名
//拷贝全类名的快捷键：选中类名crtl + shift + alt + c 或者用鼠标点copy，再点击copy Reference
com.itheima.homework.demo1.Student s1 = new com.itheima.homework.demo1.Student();
com.itheima.homework.demo2.Student s2 = new com.itheima.homework.demo2.Student();

在这里插入图片描述

第三章权限修饰符

3.1 权限修饰符

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，我们之前已经学习过了public 和 private，接下来我们研究一下protected和默认修饰符的作用。

public：公共的，所有地方都可以访问。
protected：本类，本包，其他包中的子类都可以访问。
默认（没有修饰符）：本类，本包可以访问。

注意：默认是空着不写，不是default
private：私有的，当前类可以访问。
public > protected > 默认 > private

3.2 不同权限的访问能力

	同一个类中	同一包中的其他类	不同包下的子类	不同包下的无关类
private	√
空着不写	√	√
protected	√	√	√
public	√	√	√	√

private：
- 同一个类中使用：
空着不写：
- 同一个类中使用：
- 同一个包中其他类使用：
protected：
- 同一个类中使用：
- 同一个包中其他类使用
- 不同包下子类使用
protected：全都能用
- 比如不同包下无关无关类

可见，public具有最大权限。private则是最小权限。

编写代码时，如果没有特殊的考虑，建议这样使用权限：

成员变量使用private ，隐藏细节。
构造方法使用 public ，方便创建对象。
成员方法使用public ，方便调用方法。
特例：如果方法中的代码是抽取其他方法中共性代码，且不想让外界使用这个方法，这个方法一般也私有

小贴士：不加权限修饰符，就是默认权限

第四章 final关键字

4.1 概述

学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。

如果有一个方法我不想别人去改写里面内容，该怎么办呢？

Java提供了final 关键字，表示修饰的内容不可变。

final：不可改变，最终的含义。可以用于修饰类、方法和变量。
- 类：被修饰的类，不能被继承。
- 方法：被修饰的方法，不能被重写。
- 变量：被修饰的变量，有且仅能被赋值一次。

4.2 使用方式

4.2.1 修饰类

final修饰的类，不能被继承。

格式如下：

final class 类名 {
}

代码:

final class Fu {
}
// class Zi extends Fu {} // 报错,不能继承final的类

查询API发现像 public final class String 、public final class Math 、public final class Scanner 等，很多我们学习过的类，都是被final修饰的，目的就是供我们使用，而不让我们所以改变其内容。

4.2.2 修饰方法

final修饰的方法，不能被重写。(应用场景就是：不希望被别人重写改变的函数，比如某种规则)
格式如下：

修饰符 final 返回值类型 方法名(参数列表){
    //方法体
}

代码:

class Fu2 {
	final public void show1() {
		System.out.println("Fu2 show1");
	}
	public void show2() {
		System.out.println("Fu2 show2");
	}
}

class Zi2 extends Fu2 {
//	@Override
//	public void show1() {
//		System.out.println("Zi2 show1");
//	}
	@Override
	public void show2() {
		System.out.println("Zi2 show2");
	}
}

4.2.3 修饰变量

在这里插入图片描述

第五章代码块

5.1 局部代码块（了解）

作用：提前结束变量生命周期，减少内存消耗
在这里插入图片描述

5.2 构造代码块（了解）

写在成员位置的代码块
作用: 可以把多个构造方法中重复的代码抽取出来
执行时机: 我们在创建本类对象的时候会先执行构造代码块再执行构造方法
在这里插入图片描述
现在基本上不用，替代方法有两个，使用，写一遍，然后使用this调用其他构造方法，或者抽出来一个方法

5.3 静态代码块（掌握）

在这里插入图片描述

海绵宝宝丶哈

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
day14-多态&final&包&权限修饰

多态：是指同一行为，具有多个不同表现形式。从上面案例可以看出，Cat和Dog都是动物，都是吃这一行为，但是出现的效果（表现形式）是不一样的。前提【重点】有继承或者实现关系方法的重写【意义体现：不重写，无意义】父类引用指向子类对象【格式体现】父类类型：指子类对象继承的父类类型，或者实现的父接口类型。学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。如果有一个方法我不想别人去改写里面内容，该怎么办呢？Java提供了final关键字，表示修饰的内容不可变。final。
复制链接

扫一扫