面向对象进阶二:final、多态

已于 2024-02-03 21:03:59 修改
阅读量795 收藏 25
点赞数 23
文章标签： java 开发语言 idea
于 2024-02-03 21:03:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_76719419/article/details/136016340
版权

第一章 final关键字

1.1 概述

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

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

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

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

1.2 使用方式

1.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修饰的，目的就是供我们使用，而不让我们所以改变其内容。

1.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");
	}
}

1.2.3 修饰变量-局部变量

  1. 局部变量——基本类型
    基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。代码如下：
public class FinalDemo1 {
    public static void main(String[] args) {
        // 声明变量，使用final修饰
        final int a;
        // 第一次赋值 
        a = 10;
        // 第二次赋值
        a = 20; // 报错,不可重新赋值

        // 声明变量，直接赋值，使用final修饰
        final int b = 10;
        // 第二次赋值
        b = 20; // 报错,不可重新赋值
    }
}

思考，下面两种写法，哪种可以通过编译？

写法1：

final int c = 0;
for (int i = 0; i < 10; i++) {
    c = i;
    System.out.println(c);
}

写法2：

for (int i = 0; i < 10; i++) {
    final int c = i;
    System.out.println(c);
}

根据 final 的定义，写法1报错！写法2，为什么通过编译呢？因为每次循环，都是一次新的变量c。这也是大家需要注意的地方。

1.2.4 修饰变量-成员变量

成员变量涉及到初始化的问题，初始化方式有显示初始化和构造方法初始化，只能选择其中一个：

  • 显示初始化(在定义成员变量的时候立马赋值)（常用）；
public class Student {
    final int num = 10;
}

  • 构造方法初始化(在构造方法中赋值一次)（不常用，了解即可）。

    注意：每个构造方法中都要赋值一次！

public class Student {
    final int num = 10;
    final int num2;

    public Student() {
        this.num2 = 20;
//     this.num2 = 20;
    }
    
     public Student(String name) {
        this.num2 = 20;
//     this.num2 = 20;
    }
}

被final修饰的常量名称，一般都有书写规范，所有字母都大写。

第二章 多态

2.1 多态的形式

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

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

多态体现的格式：

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

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

2.2 多态的使用场景

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

在这里插入图片描述

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

要注意的是：

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

在这里插入图片描述

代码示例：

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

    空参构造
    带全部参数的构造
    get和set方法

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

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

子类2：
public class Student extends Person{

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

子类3：
public 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);
        register(t);
        register(admin);


    }



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

2.3 多态的定义和前提

多态： 是指同一行为，具有多个不同表现形式。

从上面案例可以看出，Cat和Dog都是动物，都是吃这一行为，但是出现的效果（表现形式）是不一样的。

前提【重点】

  1. 有继承或者实现关系

  2. 方法的重写【意义体现：不重写，无意义】

  3. 父类引用指向子类对象【格式体现】

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

    演示多态的使用:

    // 创建父类动物类型
public class Animal {

    public void load(){
        System.out.println("动物叫.....");
    }
}

    创建子类 驴

    package com.itheima.duotai01;

public class Lv extends Animal {

    // 因为驴的叫声 别致 所以重写 叫的方法

    @Override
    public void load() {
        System.out.println("a~o~哦！~啊~额~~哦~~~");
    }
}

    测试类测试

    package com.itheima.duotai01;

public class Demo {

    /*
      研究多态
        什么是多态
           简单理解 就是一种事物多种形态，代码中体现是 对象的多种形态。
        特征
            父类引用 指向 子类对象  (子类以父类的形态示人)
        前提:
          1:有继承(实现)关系
          2:父类引用 指向 子类对象
          3:一般有方法重写
     */
    public static void main(String[] args) {
       // 多态写法
        Animal a = new Lv();//远看是个动物
        // 多态的本质 还是new 哪个对象。。。
        a.load();//执行重写的方法
        // 执行的 时候 真正的调用的还是 儿子的功能
    }
}

2.4 多态的运行特点–扩展看一下即可(因为属性将来是私有的)

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

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

代码示例：

Fu f = new Zi()；
//编译看左边的父类中有没有name这个属性，没有就报错
//在实际运行的时候，把父类name属性的值打印出来
System.out.println(f.name);
//编译看左边的父类中有没有show这个方法，没有就报错
//在实际运行的时候，运行的是子类中的show方法
f.show();

多态好处

在这里插入图片描述

package com.itheima.duotai02;

public class Animal {

    public void load(){
        System.out.println("动物叫.....");
    }

    public void sleep(){
        System.out.println("静静睡觉....");
    }
}


package com.itheima.duotai02;

public class Cat extends Animal{

    @Override
    public void load() {
        System.out.println("喵~~喵~~喵~~喵~~");
    }

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


package com.itheima.duotai02;

public class Lv extends Animal {

    // 因为驴的叫声 别致 所以重写 叫的方法
    @Override
    public void load() {
        System.out.println("a~o~哦！~啊~额~~哦~~~");
    }

    public void laMo(){
        System.out.println("懒驴拉磨...屎尿多....");
    }
}


package com.itheima.duotai02;

public class Demo {

    public static void main(String[] args) {


        //子健 要睡觉了  靖轩管家---拉过来一只动物  让它叫
       Animal a = new Lv();//多态形式
       listenAnimalLoad(a);
       System.out.println("=================");
       listenAnimalLoad(new Cat()); //
    }

    /*
      子健---听动物的叫声 才能睡着
       要求设计一个方法
      方法 不调用不执行！！
     */                              //          = new Cat()
    public static void listenAnimalLoad(Animal a){//参数 是父类类型
        a.load();
    }
}

2.5 多态的弊端

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

接着上面的案例

package com.itheima.duotai02;

public class Demo02 {

    public static void main(String[] args) {
        Animal a = new Lv();//向上转型

        a.load();
        a.sleep();
        //拉磨
       // a.laMo();//编译期报错 --检查语法问题
        // 现在是动物的形态  动物不会拉磨的
        // 编译只看 多态式子的左边 检查左边的这个类型里面是不是有 该方法
        // 多态的弊端  在父类形态下 只能使用父类的功能  无法使用子类特有功能
       
    }
}

2.6 引用类型转换

2.6.1 为什么要转型

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

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

回顾基本数据类型转换

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

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

2.6.2 向上转型（自动转换）

  • 向上转型：多态本身是子类类型向父类类型向上转换（自动转换）的过程，这个过程是默认的。
    当父类引用指向一个子类对象时，便是向上转型。
    使用格式：
父类类型  变量名 = new 子类类型();
如：Animal a = new Cat();

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

2.6.3 向下转型（强制转换）

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

使用格式：

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

2.6.4 案例演示

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

转型演示，代码如下：

定义类：

package com.itheima.duotai02;

public class Demo02 {

    public static void main(String[] args) {
        Animal a = new Lv();//向上转型

        a.load();
        a.sleep();
        //拉磨
       // a.laMo();//编译期报错 --检查语法问题
        // 现在是动物的形态  动物不会拉磨的
        // 编译只看 多态式子的左边 检查左边的这个类型里面是不是有 该方法
        // 多态的弊端  在父类形态下 只能使用父类的功能  无法使用子类特有功能
        /*
        向上转型 -- 自动转型--多态形式
          父类类型 变量名 = 子类对象。
        向下转型 -- 强制转换 -- 还原回去
          子类类型 变量名 = (子类类型)父类变量;
         */
        Lv lv = (Lv)a;
        lv.laMo();
        //类型转换 作用  还原会子类类型  调用子类特有功能
    }
}

定义测试类：

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

2.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对象的。

2.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
        }
    }  
}

2.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("没有这个类型，无法转换");
}
梳理案例 – Ga子装爹

父类

package com.itheima.duotai03;

public class GaZiDie {
    //父年龄
    int age = 50;

    public void teach(){
        System.out.println("教Java基础,名声显赫.....");
    }

}

子类

package com.itheima.duotai03;

public class GaZi extends GaZiDie{
    //子年龄
    int age = 18;
    //存在重写
    public void teach(){
        System.out.println("教....喝酒.....");
    }

    public void play(){
        System.out.println("玩..LOL...");
    }
}

测试类

package com.itheima.duotai03;
/*
   多态形式下
     编译  看左边  检查语法错误
     运行
        成员变量 看左边 因为堆空间中是有这份数据的
        成员方法 看右边 因为方法形成了覆盖
 */
public class Demo {
    public static void main(String[] args) {
        //潘子...想挣钱---做程序员
        // 找 教java好的人 ...拨通了 gazidie 家里电话
        // ga子正在lol 没有钱买皮肤 很郁闷  1W
        // ga子 装爹  用爹的形态  粘上胡子 带上眼镜 格子衫
        // 向上转型
        GaZiDie gzd = new GaZi();//多态
        //到潘子家了
        System.out.println("潘子见到的老师:"+gzd.age+"岁");
        // 教课
        System.out.println("想写出更好的代码,先喝点酒");
        gzd.teach();
        // 潘子喝蒙了 嘎子 就准备走人 钱到手...
        // 回到家了 想玩游戏
//        gzd.play();
       // 向下转型 还原回去
        GaZi gz = (GaZi)gzd;

        gz.play();
    }
}

2.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中调用特有方法？

画图分析：

在这里插入图片描述

前四问代码示例:

第一问 第二问 结合分析 设计出三个类

在这里插入图片描述

动物类

package com.itheima.test;

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 something){
        System.out.println("正在吃:"+something);
    }
}

猫类

package com.itheima.test;

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

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

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

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

狗类

package com.itheima.test;

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

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

    @Override
    public void eat(String something) {
        System.out.println(getAge()+"岁的"+getColor()+"色的狗两只前腿实时的抱住"+something+"正在猛吃...");
    }

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

第三问设计 饲养员类 Person

在这里插入图片描述

package com.itheima.test;

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

    /**
     *
     * @param dog 饲养的狗
     * @param something  喂得食物
     */
    public void keepPet(Dog dog ,String something){
        System.out.println("年龄为"+age+"岁的"+name+"养了一只"+dog.getColor()+"颜色的"+dog.getAge()+"岁的狗");
       dog.eat(something);
   }

 
}

第四问测试

在这里插入图片描述

步骤
    1 创建 Person对象  老王 30
      老王养狗
    2 创建 狗对象
    3 老王对象调用keepPet方法 
    同理 老李

测试代码

package com.itheima.test;

public class Demo {

    public static void main(String[] args) {
        //想调用 keepPet方法 方法属于 饲养员对象
        //创建 饲养员对象
        Person p = new Person("隔壁老王",30);
        //调用方法 方法重载
        //  方法需要什么参数 我就给什么类型数据
//        p.keepPet(狗对象,食物);
        Dog dog = new Dog(2, "黑色");
        String gouShi = "蓝翔";
        p.keepPet(dog,gouShi);

        System.out.println("=============");
        Person p2 = new Person("隔壁翠花",28);
//        p.keepPet(猫对象,食物);
        Cat cat = new Cat(3,"黑白花");
        String maoShi = "小鱼";
        p2.keepPet(cat,maoShi);
    }
}

在这里插入图片描述

 // 5.1 优化
    public void keepPet(Animal a ,String something){
        System.out.println("年龄为"+age+"岁的"+name+"养了一只"+a.getColor()+"颜色的"+a.getAge()+"岁的小动物");
        a.eat(something);
        
        //5.2 优化
        // 是猫 就去 抓老鼠
        if(a instanceof Cat cat){//判断同时完成转换 jdk14的新特性
//            Cat cat = (Cat)a;
            cat.catchMouse();
        }
        // 是狗 就去 看门
        if(a instanceof Dog dog){
            dog.lookHome();
        }
    }
小秦来喽
关注
  • 23
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++进阶：继承和多态
2301_79969994的博客
07-09 1470
面向对象编程中的一个核心概念，它允许对象以多种形式出现，并通过相同的接口来调用不同的实现。在 C++ 中，多态通常通过函数重载、运算符重载和虚函数来实现。多态的主要类型包括编译时多态（静态多态）和运行时多态（动态多态）。简单来说多态就是：就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。例如：每个动物都有叫声，我们将叫声写为一个函数，然后每个动物去继承这个 动物类，每个动物去调用叫声这个函数都会得到不同的结果，这就是多态。
面向对象进阶5:类和泛型
qq_55630615的博客
03-31 867
在一个类的内部定义的类,内部类可以访问外部类的成员变量和成员方法,包括私有成员,内部类可以分为成员内部类,局部内部类,静态内部类和匿名内部类。
Java面向对象进阶&接口&多态&内部类
weixin_43785284的博客
10-07 150
Java面向对象进阶&接口&多态&内部类
【C++进阶】：多态
m0_73790767的博客
07-27 176
多态的定义和实现（协变和析构函数重写），多态原理（虚函数表），单继承和多继承，抽象类
C++进阶篇：继承与多态一篇拿下
MaoRuofeng的博客
04-23 1033
多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象买票半价。那么在继承中要构成多态还有两个条件1.必须通过基类的指针或者引用调用虚函数2.被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。
【C++进阶：多态】多态的构成条件 | 虚函数的重写 | 抽象类 | 多态的原理 | 多继承的虚函数表
wh128341的博客
07-11 1132
本文我们将学习面向对象三大特性中的最后一个特性 —— 多态。需要声明的是，多态一文包括继承一文中所演示的测试用例都是按我的编译器 VS2017 来演示的，我们会演示底层细节，如果你换一个编译器，包括 VS 系列，可能展示出来的效果会有一点变动，因为 C++ 并没有规定具体的实现细节。顾名思义，多态就是多种形态，具体就是去完成某种行为时，不同的对象去完成时会产生不同的状态。举个粟子，比如买票这种行为，当普通人去买票时，是全价买票；当学生去买票时，是半价买票；当军人买票时，是优先买票。再举个粟子，为了争夺在线支
JAVA基础（面向对象进阶） —— 多态
hdakj22的博客
02-24 199
多态的概念引入、多态调用成员变量、方法特点以及多态的优缺点
Java基础：面向对象进阶（多态）
weixin_44404541的博客
08-10 262
java 面向对象 多态 抽象
Java面向对象的特性：封装，继承与多态
个人练习生
02-19 875
面向对象四大特性：封装、继承和多态
面向对象进阶（多态&包&final&权限修饰符&代码块）
11-17
本篇将深入探讨面向对象进阶中的几个关键概念：多态、包、final关键字、权限修饰符以及代码块。 1. **多态（Polymorphism）**： 多态是指同一个接口，使用不同的实例而产生不同的效果。在Java中，多态主要体现在...
5 Java的基本程序设计结构（基本语法5）- 面向对象进阶（继承、多态（父类强转子类）、包、接口、内部类、抽象类和抽象方法）
smalltorch的博客
07-30 440
定义：被static修饰的成员变量，叫做静态变量。特点：**被该类所有对象共享（简单来说你修改任意一个对象里面的static成员变量，所有对象的该成员变量的值都会变）调用方式**（1）直接类名调用（推荐）（2）对象名调用关于被该类所有对象共享这个举个例子说明一下。一个学生类，里面有一个静态成员变量是老师，修改任意一个学生对象的老师这个成员变量，其余学生对象的老师也会统一修改。简单来说，静态成员变量是属于这个类，是属于所有对象，修改一个对象就会影响所有对象。
【Java学习】第13节：面向对象进阶 - 多态&包&final&权限修饰符&代码块-
m0_46013789的博客
05-16 1171
Java是一种广泛使用的编程语言，由Sun Microsystems（现在是Oracle Corporation）首次推出。它是一种跨平台的编程语言，意味着您可以编写一次代码，然后在多个不同的计算机系统上运行，而无需对其进行修改。Java被广泛用于开发各种类型的应用程序，包括企业级应用、移动应用、Web应用、游戏等。
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 3937
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 3988
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 4203
linux上datax 安装以及使用
《深入理解 Java 中的适配器模式》
最新发布
面团到油条的成长日记
08-29 2348
在软件开发的广阔领域中，不同接口之间不匹配的问题时常像个棘手的难题困扰着开发者。而适配器模式就像是一位得力的助手，专门用来解决这类问题。它的关键作用在于把一个类的接口有效地转化为客户端所期望的另一种接口，让原本因接口不相符而不能一起工作的两个类可以共同协作，学习本文希望你能有所收获
操作系统原子操作
zzt_is_me的博客
08-28 2425
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值