JAVASE面向对象进阶6---多态

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量264 收藏
点赞数
分类专栏： java 文章标签： java
原文链接：https://www.bilibili.com/video/BV1Cv411372m?p=129
版权

JAVASE面向对象进阶—多态

一、多态

1、什么是多态？
  • 同类型的对象，执行同一个行为，会表现出不同的行为特征。

多态常见的形式

父类类型 对象名称 = new 子类构造器;
接口 对象名称 = new 实现类构造器;

/**
 * 目标：认识多态，理解多态的形式。和概念
 */
public class Test {
    public static void main(String[] args) {
        //1、多态的形式 :   父类类型  对象名称 = new  子类构造器
        Animal a = new Dog();
        a.run();//方法调用：编译看左边，运行看右边。
        System.out.println(a.name);    //变量调用：编译看左边，运行也看左边

        System.out.println("==================");
        Animal a2 = new Tortoise();
        a2.run();  //方法调用：编译看左边，运行看右边。
        System.out.println(a2.name);  //变量调用：编译看左边，运行也看左边

    }

}




public abstract class Animal {
    public String name = "父类动物";
    public abstract void run();
}




public class Dog extends Animal{
    public String name = "子类狗";
    @Override
    public void run() {
        System.out.println("狗跑的贼快~~");
    }
}




public class Tortoise extends Animal{
public String name = "子类乌龟";
    @Override
    public void run() {
        System.out.println("乌龟跑的好慢~~~");
    }
}

多态中成员访问特点：

  • 方法调用:编译看左边，运行看右边。
  • 变量调用:编译看左边，运行也看左边。(多态侧重行为多态)

多态的前提：

  • 有继承/实现关系；有父类引用指向子类对象；有方法重写。
2、多态的优势
  • 在多态形式下，右边对象可以实现解耦合,便于扩展和维护。
Animal a = new Dog();
a.run(); //后续业务行为随对象而变，后续代码无需修改
  • 定义方法的时候,使用父类型作为参数,该方法就可以接收这父类的一切子类对象,体现出多态的扩展性与便利。
public class Test {
    public static void main(String[] args) {
        Animal a = new Dog();
        go(a);
        Animal a2 = new Tortoise();
        go(a2);

    }
    /**
     *要求：所以的动物都可以进来比赛
     */
    public static void go(Animal animal){
        System.out.println("开始~~~");
        animal.run();
        System.out.println("结束~~");
        System.out.println();


    }
}

public abstract class Animal {
    public abstract void run();
}

public class Dog extends Animal{
    @Override
    public void run() {
        System.out.println("狗跑的非常快");
    }
}


public class Tortoise extends Animal{
    @Override
    public void run() {
        System.out.println("乌龟跑的非常快");
    }
}

多态下会产生的一个问题:

  • 多态下不能使用子类的独有功能
3、多态下引用数据类型的类型转换

自动类型转化(从子到父)：子类对象赋值给父类类型的变量指向。

强制类型转换吗( 从父到子)

  • 此时必须进行强制类型转换: 子类对象变量= (子类)父类类型的变量
  • 作用: 可以解决多态下的劣势，可以实现调用子类独有的功能。
  • 注意:如果转型后的类型和对象真实类型不是同一种类型，那么在转换的时候就会出现ClassCastException
Animal t = new Tortoise();
Dog d = (Dog)t;  //出现异常   ClassCastException
  • Java建议强转转换前使用instanceof判断当前对象的真实类型，再进行强制转换
 变量名 instanceof 真实类型
 判断关键字左边的变量指向的对象的真实类型,是否是右边的类型或者是其子类类型，是则返回true,反之。

public class Test {
    public static void main(String[] args) {
        //自动类型转换
            Animal a = new Dog();
            a.run();

            //强类型转换

        Animal a2 = new Tortoise();
        a2.run();
        Tortoise t = (Tortoise) a2;  //从父类类型到子类类型 必须强制转换
        t.eat();
         // Dog d = (Dog) a2;  //强制类型转换，编译阶段不报错的；(注意: 有继承或者实现关系编译阶段可以强制，没有毛病)，运行时可能出错的!
        if (a2 instanceof Tortoise){
            Tortoise tortoise = (Tortoise)a2;  //从父类类型到子类类型，必须强制转换类型
            tortoise.eat();
        }else if (a2 instanceof Dog){
            Dog d = new Dog();
            d.look();
        }
        
    }
}

public abstract class Animal {
    public abstract void run();


}

public class Dog extends Animal{
    @Override
    public void run() {
        System.out.println("狗跑的很快~~");
    }
    public void look(){
        System.out.println("看门~~");
    }
}

public class Tortoise extends Animal{
    @Override
    public void run() {
        System.out.println("乌龟跑的很慢~~");
    }
    /**
     * 独有方法
     */

    public void eat(){
        System.out.println("在吃好东西~~~~");
    }
}

总结：1.引用数据类型的类型转换，有几种方式?

  • 自动类型转换、强制类型转换。

2.强制类型转换能解决什么问题?强制类型转换需要注意什么。

  • 可以转换成真正的子类类型，从而调用子类独有功能。
  • 有继承关系/实现的2个类型就可以进行强制转换，编译无问题。
  • 运行时，如果发现强制转换后的类型不是对象真实类型则报错。
4、多态的案例

需求：使用面向对象编程模拟：设计一个电脑对象，可以安装2个USB设备
①鼠标:被安装时可以完成接入、调用点击功能、拔出功能。
②键盘:被安装时可以完成接入、调用打字功能、拔出功能。
分析：
①定义一个USB的接口( 申明USB设备的规范必须是：可以接入和拔出)
②提供2个USB实现类代表鼠标和键盘,让其实现USB接口，并分别定义独有功能。
③创建电脑对象，创建2个USB实现类对象,分别安装到电脑中并触发功能的执行。

/**
 * 需求：使用面向对象编程模拟：设计一个电脑对象，可以安装2个USB设备
 * ①鼠标:被安装时可以完成接入、调用点击功能、拔出功能。
 * ②键盘:被安装时可以完成接入、调用打字功能、拔出功能。
 */
public class Test {
    public static void main(String[] args) {
        //1、创建电脑对象
        Computer c = new Computer("外星人");
        c.start();

        //b、创建鼠标对象。键盘对象。
        USB u = new keyBoard("双飞燕");
        c.installUSB(u);
        System.out.println();
        
        USB u1 = new Mouse("罗技");
        c.installUSB(u1);
    }
}






/**
 * 键盘实现类
 */
public class keyBoard implements USB{

    private String name;

    public keyBoard() {
    }

    public keyBoard(String name) {


        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void connect() {
        System.out.println(name+"键盘成功连接电脑~~");

    }

    @Override
    public void unconnect() {
        System.out.println(name+"键盘成功从电脑中拔出~~");

    }
    /**
     * 独有功能
     */
    public void keyDown(){
        System.out.println(name+"键盘敲击了~~");
    }


}






/**
 * 鼠标实现类
 */
public class Mouse implements USB{

    private String name;

    public Mouse() {
    }

    public Mouse(String name) {


        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void connect() {
        System.out.println(name+"成鼠标连接了成功连接了电脑~~");

    }

    @Override
    public void unconnect() {
        System.out.println(name+"鼠标成功从电脑中拔出~~");

    }
    /**
     * 独有功能
     */
    public void dbClick(){
        System.out.println(name+"鼠标双击点亮小红心~~");
    }
}







import sun.security.provider.certpath.BuildStep;

import javax.swing.*;

public class Computer {
    private  String name;


    public void start(){
        System.out.println(name+"电脑开机了~~");
    }

    public Computer() {
    }

    public Computer(String name) {

        this.name = name;
    }


    /**
     *提供安装设备USB设备的入口
     */

    public void installUSB(USB usb){
        //多态知识  usb 可能是鼠标 也可能是键盘
        usb.connect();


        /**
         * 调用独有功能：先判断 再强转
         */
        if (usb instanceof keyBoard){
            keyBoard k = (keyBoard) usb;
            k.keyDown();
        }else if (usb instanceof Mouse){
            Mouse m = (Mouse) usb;
            m.dbClick();
        }
        usb.unconnect();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }


}

二、内部类

1、内部类
●内部类就是定义在- -个类里面的类,里面的类可以理解成(寄生)，外部类可以理解成(宿主)。

public class People{
//内部类
    public class Heart{
    }
}

2、内部类的使用场景、作用

  • 当一个事物的内部，还有一个部分需要-一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物
  • 提供服务,那么整个内部的完整结构可以选择使用内部类来设计。
  • 内部类通常可以方便访问外部类的成员，包括私有的成员。
  • 内部类提供了更好的封装性，内部类本身就可以用private protectecd等修饰，封装性可以做更多控制。

3、内部类的分类

  • 静态内部类[了解]
  • 成员内部类(非静态内部类) [了 解]
  • 局部内部类[了解]
  • 匿名内部类(重点)
4、内部类之一：静态内部类[了解]

①什么是静态内部类

  • 有static修饰，属于外部类本身
  • 它的特点和使用与普通类hi完全一样的，类有的成分它都有，只是位置在别人里面而已。
public class Outer{
    //静态成员内部类
    public static class Inner{
        
    }
}

②静态内部类创建对象的格式：

格式：外部类名.内部类名  对象名 = new 外部类名.内部类构造器
范例： Outer.Inner in = new Outer.Inner();

public class Test {
    public static void main(String[] args) {

        Outer.Inner inner = new Outer.Inner();
        inner.show();

    }
}


/**
 * 外部类
 */
public class Outer {
    /**
     * 学习静态成员内部类
     */


    public static int a = 100;

    private String hobby;




    public static  class Inner{
        private String name;
        private String age;
        public static String schoolName;


        public void show(){
//            System.out.println(a);
//            Outer o = new Outer();
//            o.hobby


        }

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

        public Inner() {
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getAge() {
            return age;
        }

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

        public static String getSchoolName() {
            return schoolName;
        }

        public static void setSchoolName(String schoolName) {
            Inner.schoolName = schoolName;
        }
    }

}

③静态内部类的访问拓展:
1、静态内部类中是否可以直接访问外部类的静态成员?

  • 可以，外部类的静态成员只有一份可以被共享访问。

2、静态内部类中是否可以直接访问外部类的实例成员?

  • 不可以的,外部类的实例成员必须用外部类对象访问。

(具体代码演示看上面内部类里面所定义的静态成员以及实例成员变量)

④总结：静态内部类的使用场景、特点、访问总结。

  • 如果-一个类中包含了-个完整的成分，如汽车类中的发动机类。
  • 特点、使用与普通类是一样的，类有的成分它都有，只是位置在别人里面而已。
  • 可以直接访问外部类的静态成员,不能直接访问外部类的实例成员。
  • 注意:开发中实际上用的还是比较少。
5、内部类之二 ：成员内部类

①什么是成员内部类?

  • 无static修饰,属于外部类的对象。
  • JDK16之前，成员内部类中不能定义静态成员, jDK 16开始也可以定义静态成员了。
public class Outer {
//成员内部类
public class Inner {
	}
}

②成员内部类创建对象的格式:

格式:外部类名.内部类名对象名= new外部类构造器.new内部类构造器();
范例: Outer.Inner in = new Outer().new Inner();

public class Test {
    public static void main(String[] args) {
//        格式:外部类名.内部类名 对象名 = new 外部类构造器.new内部类构造器();
        Outer.Inner in = new Outer().new Inner();
        in.show();

    }
}

/**
 * 外部类
 */
public class Outer {
    /**
     * 成员内部类：不能加static修饰   属于外部类对象的
     */
    public static int num = 111;
      private String hobby;

    class Inner{
        private String name;
        private  int age;
//  public static int a;   //jkd16开始支持静态成员

            public void show(){
                 System.out.println(num);
                System.out.println(hobby);

            }


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

}

③成员内部类的访问拓展：
1、成员内部类中是否可以直接访问外部类的静态成员?

  • 可以，外部类的静态成员只有–份可以被共享访问。

(具体代码演示看上面内部类里面所定义的静态成员以及实例成员变量)

2、成员内部类的实例方法中是否可以直接访问外部类的实例成员?

  • 可以的，因为必须先有外部类对象,才能有成员内部类对象，所以可以直接访问外部类对象的实例成员。

(具体代码演示看上面内部类里面所定义的静态成员以及实例成员变量)

总结：1.成员内部类是什么样的、有什么特点?

  • 无static修饰，属于外部类的对象。
  • 可以直接访问外部类的静态成员，实例方法中可以直接访问外部类的实例成员。

2.成员内部类如何创建对象?

  • 外部类名.内部类名对象名= new外部类构造器.new内部类构造器();

案例：成员内部类-面试题

  • 请观察如下代码，写出合适的代码对应其注释要求输出的结果。
public class Test2 {
    public static void main(String[] args) {
        People.Heart heart = new People().new Heart();
        heart.show();
    }

}

class People {
    private int heartbeat = 150;

    /**
     * 成员内部类
     */
    public class Heart {
        private int heartbeat = 110;

        public void show() {
            int heartbeat = 78;
            System.out.println(heartbeat); // 78  访问方法的heartbeat
            System.out.println(this.heartbeat); // 110  访问Heart()的heartbeat(成员内部类)
            System.out.println(People.this.heartbeat); // 150  访问People()的heartbeat  （外部类）
        }
    }

}

注意:在成员内部类中访问所在外部类对象,格式:外部类名.this。

6、内部类之三:局部内部类[了解]

①局部内部类(鸡肋语法， 了解即可)

  • 局部内部类放在方法、代码块、构造器等执行体中。

  • 局部内部类的类文件名为:外部类$N内部类 class。

public class Test {
    /**
     *
     *目标：了解局部内部类的语法
     */
    public static void main(String[] args) {
        class Cat{
            private String name;
            //在JDK15之前是不可以定义静态成员的  但是现在都可以定义静态成员了
//            public static int age = 13;



            public String getName() {
                return name;
            }

            public void setName(String name) {
                this.name = name;
            }
        }

        Cat c = new Cat();
        c.setName("叮当猫~~");

    }
}
7、内部类之四：你，匿名内部类[重点]
①匿名内部类:
  • 本质上是一个没有名字的局部内部类,定义在方法中、代码块中、等。

作用:方便创建子类对象,最终目的为了简化代码编写。

②格式
new类 | 抽象类名 | 或者接口名() {
重写方法;
};


Employee a = new Employee() {
public void work( ) {
	}
};
a.work();

public class Test {
    /**
     *目标：学习匿名内部类的形式和特点
     */
    public static void main(String[] args) {
//        Animal animal = new Tiger();   按照多态的思想实例化这个子类(Tiger)  编译看左  运行看右

        //匿名内部类
        Animal animal = new Animal(){   //右边这个Animal叫做匿名内部类对象
            @Override
            public void run() {
                System.out.println("跑的很快~~");

            }
        };
        animal.run();


    }
}

//class Tiger extends Animal{
//
//    @Override
//    public void run() {
//        System.out.println("跑的很快~~"); //匿名内部类子类不需要再定义
//    }
//}


abstract class Animal{
  public   abstract void run();

}
③特点总结：

  • 匿名内部类是一个没有名字的内部类。

  • 匿名内部类写出来就会产生一个匿名内部类的对象。

  • 匿名内部类的对象类型相当于是当前new的那个的类型的子类类型。

④总结：

1、匿名内部类的作用?
●方便创建子类对象,最终目的为了简化代码编写。

2、匿名内部类的格式？

Employee a = new Employee() {
public void work( ) {
	}
};
a.work();

3、匿名内部类的特点：

  • 匿名内部类是一个没有名字的内部类。

  • 匿名内部类写出来就会产生一个匿名内部类的对象。

  • 匿名内部类的对象类型相当于是当前new的那个的类型的子类类型。

⑤匿名内部类常见的使用形式

案例：某个学校需要让老师、学生、运动员一起参加游泳比赛。

/*游泳接口*/
public interface Swimming {
void swim() ;
}



/*测试类*/
public class Jumppi ngDemo{
public static void main(String[] args) {
	// 需求: goSwimming方法
}
    
    
// 定义一个方 法让所有角色进来一起比赛
public static void goSwimming(Swimming swimming) {
swimming.swim();
	}
}

package com.itheima.d8_innerclass_anonymous;

/**
 * 目标：掌握匿名内部类的使用形式(语法)
 */
public class Test2 {
    public static void main(String[] args) {

        Swimming s  = new Swimming() {
            @Override
            public void swim() {
                System.out.println("学生正在快速的游泳~~");

            }
        };
         go(s);
        System.out.println();


        Swimming s1  = new Swimming() {
            @Override
            public void swim() {
                System.out.println("老师正在快速的游泳~~");

            }
        };

        go(s1);
        
        System.out.println();


        Swimming s2  = new Swimming() {
            @Override
            public void swim() {
                System.out.println("运动员正在飞速的游泳~~");

            }
        };
        go(s2);


    }
    /**
     * 学生、老师、运动员可以一起参加游泳比赛
     */

    public static void go(Swimming s){
        System.out.println("开始~~");
        s.swim();
        System.out.println("结束！！！");

    }

}



//
//class Student implements Swimming{
//    @Override
//    public void swim() {
//        System.out.println("学生正在快速的游泳~~");
//
//    }

//};

interface Swimming{
    void swim();
}

代码可以把方法当做参数 是代码更简洁 (结果跟上面代码一致)

package com.itheima.d8_innerclass_anonymous;

/**
 * 目标：掌握匿名内部类的使用形式(语法)
 */
public class Test2 {
    public static void main(String[] args) {

         go(new Swimming() {
             @Override
             public void swim() {
                 System.out.println("学生正在快速的游泳~~");
             }
         });

        System.out.println();

        go(new Swimming() {
            @Override
            public void swim() {
                System.out.println("老师正在快速的游泳~~");
            }
        });

        System.out.println();

        go(new Swimming() {
            @Override
            public void swim() {
                System.out.println("运动员正在飞速的游泳~~");
            }
        });


    }
    /**
     * 学生、老师、运动员可以一起参加游泳比赛
     */

    public static void go(Swimming s){
        System.out.println("开始~~");
        s.swim();
        System.out.println("结束！！！");

    }

}



//
//class Student implements Swimming{
//    @Override
//    public void swim() {
//        System.out.println("学生正在快速的游泳~~");
//
//    }

//};

interface Swimming{
    void swim();
}

使用总结
匿名内部类可以作为方法的实际参数进行传输。

⑥匿名内部类常见的使用形式

1、匿名内部类在开发中的真实使用场景演示
●给按钮绑定点击事件

//为按钮绑定点击事件监听器。
btn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.printIn("登录一下~~"); 
}
});
// btn.addActionL istener(e -> System.out.println("登录一下~~"));


package com.itheima.d8_innerclass_anonymous;

import javax.swing.*;
import java.awt.event.ActionEvent;

/**
 * 目标：通过GUI编程 理解匿名内部类真实使用场景
 */
public class Test3 {
    public static void main(String[] args) {
        //1、创建窗口
        JFrame win = new JFrame("登录界面");
        JPanel panel  = new JPanel();
        win.add(panel);

        //2、创建一个按钮
        JButton btn = new JButton("登录");

        //注意：讲解匿名内部类的使用
        btn.addActionListener(new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent e) {
                JOptionPane.showMessageDialog(win,"静静上课不听课；在划水~~~");
            }
        });

        //3、把按钮对象添加到桌面上展示
        panel.add(btn);

        //4、展示窗口
        win.setSize(400,300);
        win.setLocationRelativeTo(null);
        win.setVisible(true);
        

    }
}

使用总结：

开发中不是我们主动去定义匿名内部类的，而是别人需要我们写或者我们可以写的时候才会使用。
匿名内部类的代码可以实现代码进一步的简化(回扣主题)

程序员就是阿欣
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Javase进阶-day03-面向对象_常用API
qq_45263618的博客
07-13 207
黑马Java笔记
JavaSE进阶-01-面向对象.pdf
09-10
2020动力节点老杜javaSE进阶班面向对象教材，希望各位想学习和巩固javaSE的下载学习。楼主最近也在学习这个，配合视频感觉蛮好的。。。。。。
JavaSE进阶01-面向对象
cry30867的博客
05-06 97
final关键字，抽象类和接口，访问控制权限，内部类
JavaSE进阶篇-面向对象程序设计
qq_48357941的博客
04-17 1066
Java类以及类的成员：属性、方法、构造器；代码块、内部类面向对象的四大特征封装性、继承性、多态性、（抽象性）其他关键字：thissuperstaticfinalabstractinterfacepackage1、UML(统一建模语言)，是一种用于软件系统分析和设计的语言工具，用于帮助软件开发人员进行思考和记录思路的结果。2、UML本身是一套符号的规定，就像数学符号和化学符号一样，这些符号用于描述软件模型中的各个元素和它们之间的关系，如类、接口、实现、泛化、依赖、组合、聚合等。
Java面向对象进阶-封装、继承、多态
AnswerCoder的博客
10-16 968
Java面向对象进阶 1.static关键字 static表示“静态”的意思，可以用来修饰成员变量和成员方法。 static的主要作用在于创建独立于具体对象的域变量或者方法 简单理解： ​ 被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。 并且不会因为对象的多次创建而在内存中建立多份数据 注意 静态成员在类加载时加载并初始化。 无论一个类存在多少个对象 , 静态的属性, 永远在内存中只有一份(可以理解为所有对象公用 ) 在访问时：静态不能访
javaSE进阶学习-01
python_nice的博客
07-17 154
javaSE进阶学习-01 final:表示不可改变，只要被final修饰了的就只能赋值一次 采用 final 修饰的类不能被继承、采用 final 修饰的方法不能被覆盖、采用 final 修饰的变量不能被修改 如果修饰的引用，那么这个引用只能指向一个对象，也就是说这个引用不能再次赋值， 但被指向的对象是可以修改的 final修饰实例变量系统不管，程序员必须手动给一个默认值，不手动就会报错。（因为系统默认的无参构造给变量默认值，发现该变量有final修饰，就报错了）程序员手动赶在
JAVASE进阶---总结接口的基础语法
qq_46509219的博客
09-22 173
文章目录1、接口的基础语法2、接口在开发中的作用(偏理论理解性)3、`is a、 has a、 like a`的区别4、`抽象类和接口`的区别5、接口使用比抽象类多 1、接口的基础语法 1）接口是一种引用数据类型——编译后产生class字节码文件 2）接口是完全抽象的，或者叫特殊抽象 3）接口语法：修饰符 interface 接口名{} public Interface inter01{ //inter01为接口名 } 4）接口中只有常量和抽象方法。方法中无方法体 //常量 pub
JavaSE进阶-面向对象高级（一）
aaa934946088的博客
07-23 96
继承 【重点】 修饰符 【重点】
JavaSE进阶-面向对象高级（二）
aaa934946088的博客
07-25 76
多态 【重点】 抽象类 【重点】 接口 【重点】
JavaSE 进阶 - 集合
Hello_super的博客
11-03 344
JAVA集合 | Collection | List | 泛型 | Map集合 | ArrayList | LinkedList | Vector | 砖石表达式 | HashSet | TreeSet | HashMap | Properties | TreeSet | Comparable | Collections工具类
JAVASE 进阶篇-web资料整理
03-29
JAVASE 进阶篇——web资料整理
JavaSE进阶 面向对象多态
11-12
JavaSE进阶 面向对象多态
JavaSE进阶-03-常用类.pdf
09-10
2020动力节点老杜javaSE进阶班-常用类03教材，希望各位想学习和巩固javaSE的下载学习。楼主最近也在学习这个，配合视频感觉蛮好的。。。。。。
JavaSE进阶-02-数组.pdf
09-10
2020动力节点老杜javaSE进阶班-数组02教材，希望各位想学习和巩固javaSE的下载学习。楼主最近也在学习这个，配合视频感觉蛮好的。。。。。。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 987
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 785
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 286
【代码】Java手动启动jar包。
java调用cmd执行命令
weixin_45210565的博客
05-28 252
3、exec(String command, String[] envp) ，在调用外部程序之前设置系统环境变量，该变量仅供command入参使用，envp每个元素为一个系统环境变量，并且字符串格式为“环境变量名=环境变量值”。2、exec(String[] cmdArray) ，调用外部程序，入参cmdArray的元素将组合成为一条完整的外部可执行程序的启动路径或命令。1、exec(String command) ，调用外部程序，入参command为外部可执行程序的启动路径或命令。
javase篇-第07讲--面向对象1
09-08
在JavaSE中，我们可以通过封装、继承和多态来实现面向对象编程的目标。封装可以提高程序的可维护性和可复用性，继承可以减少重复编码的工作量，多态可以灵活地操作对象。掌握这些基本概念和关键术语，可以帮助我们更...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值