Java入坑指南（1）面向对象

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量129 收藏
点赞数
分类专栏： Java入坑指南 文章标签： java 抽象类 面向对象编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42446016/article/details/103821494
版权

1. 类和对象

1.1 定义

  • 三种最常见的成员：构造器、成员变量和方法

定义类：
修饰符：public、protected、private三个最多只能出现1个；它们可以与static、final组合起来修饰方法

定义成员变量：
修饰符：public、final、abstract三个最多只能出现1个

定义方法：
修饰符：public、protected、private三个最多只能出现1个；final、abstract最多最多只能出现其一，它们可以与static组合起来修饰方法
返回值：可以是Java语言允许的任何数据类型
方法名：方法名的命名规则与成员变量的命名规则相同
形参列表：用于定义该方法可以接受的参数

定义构造器：
修饰符：public、protected、private三个最多只能出现1个
构造器名：必须和类名相同
形参列表：用于定义该方法可以接受的参数

1.2 this引用

使用this有两种情形：

  • 构造器中引用该构造器正在初始化的对象
  • 在方法中引用调用该方法的对象
  • 它所代表的对象是不确定的，但它的类型是确定的

静态成员不能直接访问非静态成员，因为static修饰的方法中不能使用this

2. 方法详解

2.1 方法参数传递

  • 方法只能通过值传递来传递参数，即将实际参数的副本传入方法内，而参数本身不会受到影响
  • 引用变量通过栈内存指向堆内存进行分配，非引用变量只在栈内存进行分配

2.2 形参个数可变的方法

  • 本质就是一个数组参数
  • 一个方法最多只能有一个个数可变参数
    public static void test(int a, String...books){
        for(String  book : books){
            System.out.println(book);
        }
    }

2.3 递归方法

public class Recursive {

    public static int febonaci(int n){
        if(n == 1){
            return 1;
        }
        if(n == 2){
            return 2;
        }
        else{
            return febonaci( n -1) + febonaci(n - 2);
        }
    }
    public static void main(String[] args){
        System.out.println(febonaci(8));
    }
}

2.4 方法重载

  • Java允许同一个类里定义多个同名方法，只要形参列表不同就行

3. 成员变量和局部变量

3.1 变量分类

变量分类图

  • 同名局部变量会覆盖成员变量，如果这个是后需要引用被覆盖的成员变量，则可使用this或类名来作为调用者

3.2 成员变量的初始化过程

  • 成员变量系统会自动进行初始化过程
    成员变量初始化示意图
  • eyeNum属于Person类，name属于对象

3.3局部变量的初始化过程

  • 局部变量定义后，必须进行显式初始化才能使用，系统不会为局部变量执行初始化

3.4 变量的使用规则

成员变量适用情形：

  • 描述类的固有信息
  • 某个类中需要以一个变量来保存该类或者实例运行时的状态信息
  • 需要在某个类或者多个方法之间进行共享的信息

4. 隐藏和封装

4.1 封装

  • 将对象的状态信息隐藏在对象内部，不允许外部程序直接访问

4.2 使用访问控制符

private：当前类访问权限
default：包访问权限
protected：子类访问权限
public：公共访问权限

  • 类里绝大部分成员变量都应该使用private修饰，只有一些static修饰的成员变量才可考虑用public
  • 如果一个类主要用作其他的父类，则主要使用protected
  • 希望暴露出来的用public

4.3 package、import和import static

  • 同一个包中的类不必位于相同的目录下，源文件里通过package语句来指定包名，class文件必须放在对应的路径下
  • 包名应该全部是小写字母，由单词连缀
  • 同一个包下的类可以互相访问，不处于同一个类则需要使用类的全名来访问
  • import导入包下的类，import static导入类中特定的静态成员变量、方法

5. 构造器详解

5.1 使用构造器执行初始化

  • 当使用构造器时，系统先会为该对象分配内存空间，并为这个对象进行默认初始化。这个对象还不能被外部所访问，只能在该构造器中通过this来引用

5.2 构造器重载

  • 让程序更简洁，降低软件的维护成本
public class Orange {
    private int price;
    private String orangeName;
    
    public Orange(int price){
        this.price = price;
    }
    
    public Orange(int price, String orangeName){
        this(price);
        this.orangeName = orangeName;
    }
}

5.6 类的继承

5.6.1 继承基础

  • 每个类最多只有一个直接父类，否则编译错误
  • 调用父类方法和变量
public class Fruit {
    public double weight;
    public void info(){
        System.out.println("My weight is"+this.weight);
    }
}


public class Orange extends Fruit{
    private int price;
    private String orangeName;

    public Orange(int price){
        this.price = price;
    }

    public Orange(int price, String orangeName){
        this(price);
        this.orangeName = orangeName;
    }

    public static void main(String[] args){
        Orange orange = new Orange(1, "Orange1");
        System.out.println(orange.weight); //0.0
        System.out.println(orange.price); //1
        System.out.println(orange.orangeName); //Orange1
        orange.info(); //My weight is0.0
    }
}

5.6.2 重写父类方法

  • 重写后，子类执行重写后的方法，若需要使用父类方法，可使用super或者父类类名
  • private方法不能重写
    @Override
    public void info() {
        super.info();
        System.out.println("Now I have extended the original class");
    }

5.6.3 super

  • 不能出现在static修饰的方法内
  • 限定访问该实例的父类的变量、方法

如果在某个方法中访问名为a的成员变量，但没有指定调用者，则系统查找a的顺序为：

  1. 查找该类方法中是否有名为a的局部变量
  2. 查找该类中是否有名为a的成员变量
  3. 查找该类的父类是否有包含a的成员变量，直至Object类

5.6.4 调用父类构造器

  • 使用super来调用
  • 不管是否使用super来显式调用父类构造器，子类构造器总会调用父类构造器一次
public class Fruit {
    public double weight;
    public Fruit(){
        System.out.println("这是一个无参构造器");
    }
    public Fruit(double weight){
        this.weight = weight;
    }
    public void info(){
        System.out.println("My weight is"+this.weight);
    }
}

public class Orange extends Fruit{
    private int price;
    private String orangeName;

    public Orange(int price){
        this.price = price;
        System.out.println("Orange构造器，带price");
    }

    public Orange(int price, String orangeName){
        this(price);
        this.orangeName = orangeName;
        System.out.println("Orange构造器，带price和name");
    }
    public static void main(String[] args){
        Orange orange = new Orange(1, "Orange1");
    }
}

结果

父类指定了有参构造函数时，子类必须要重写父类的构造函数；父类只有无参构造函数时，子类无需重写

5.7 多态

5.7.1 多态性

Java引用变量有两个类型，一个是编译时类型，一个是运行时类型，如果编译类型和运行类型不一致，就可能出现所谓的多态

  • 向上转型：子类赋值给父类，当运行该变量时，总是体现出子类的特征；但是方法都是父类的方法，变量还是子类的变量

向上转型

  • 向下转型：父类变量通过显式语句转化为子类变量，转化情形：
    1. 基本类型：只能在数值类型之间进行
    2.引用类型：只能在具有继承关系的两个类型之间进行。如果一个父类实例转换为子类对象，则这个对象必须实际上是子类实例才行（执行时为子类对象）

  • instanceof：判断A所属类型是否是B的实例

5.8 继承与组合

  • 继承表达”是“的关系，组合表达”有“的关系

5.9 初始化块

5.9.1 初始化块基本用法

  • 与构造器功能类似
  • 当创建Java对象时，系统总会先调用该类里定义的初始化块，如果一个类里定义了2个普通初始化块，则前面定义的初始化块先执行，后面定义的初始化块后执行

5.9.2 静态初始化块

  • 静态初始化块属于类的静态成员，也遵守静态成员不能访问非静态成员的规则

5.9.3 初始化块和构造器

  • 初始化块在构造器之前执行
public class Fruit {
    static{
        System.out.println("Fruit的静态初始化块");
    }
    public double weight;
    {
        System.out.println("这是Fruit的初始化块");
    }
    public Fruit(){
        System.out.println("这是一个无参构造器");
    }
    public Fruit(double weight){
        this.weight = weight;
    }
    public void info(){
        System.out.println("My weight is"+this.weight);
    }
}

public class Orange extends Fruit{
    private int price;
    private String orangeName;
    static{
        System.out.println("orange的静态初始化块");
    }
    {
        System.out.println("这是Orange的初始化块");
    }

    public double weight = 3.0;

    public Orange(){
        System.out.println("orange无参");
    }

    public Orange(int price){
        this.price = price;
        System.out.println("Orange构造器，带price");
    }

    public Orange(int price, String orangeName){

        this.orangeName = orangeName;
        System.out.println("Orange构造器，带price和name");
    }

    @Override
    public void info() {
        super.info();
        System.out.println("Now I have extended the original class");
    }

    public static void main(String[] args){
        Orange orange = new Orange(1, "Orange1");
    }
}

初始化块和构造器

6. 处理对象

6.1 打印对象和toString方法

    @Override
    public String toString() {
        return "the price of orange is" + this.price;
    }

toString重写

6.2 ==和equals方法

==：两个变量是否指向同一个堆内存空间
equals：Object提供的方法

  • 对于引用变量，如果equals没重写，二者没什么区别，都需要指向同一个对象才返回true
  • 对于基本类型，==判断二者值是否相等，equals不能用在基本类型

基本类型不能使用equals

String s1 = new String("123");
String s2 = new String("123");
String s3 = "123";
String s4 = "123";
System.out.println(s1==s2); // false
System.out.println(s3==s4); // true

new创建出来的变量s1和s2保存在堆内存中，所以二者==会输出false。他们在创建的时候都首先保存在常量池再保存在堆内存

7. 类成员

7.1 理解类成员

  • 类成员不能访问实例成员

7.2 单例类

  • 一个只允许创建一个对象的类
public class singleInstance {
    private static singleInstance singleIns;
    public static singleInstance getInstance(){
        if (singleIns == null){
            singleIns = new singleInstance();
        }
        return singleIns;
    }

    public static void main(String[] args){
        singleInstance s1 = singleInstance.getInstance();
        singleInstance s2 = singleInstance.getInstance();
        System.out.println(s1 == s2);
    }
}

7.3 final修饰符

  • 表示它修饰的类、方法和变量不可变

7.3.1 final成员变量

  • final修饰的成员变量必须显式指定其初始值
  • 实例final变量只能在构造器，初始化块和声明三个地方初始化
  • 静态final变量只能在声明和初始化块两个地方初始化

7.3.2 final局部变量

  • 只能在通过声明初始化

7.3.3 final修饰基本类型和引用类型

  • final只能保证引用变量的地址不变
final int[] a = new int[]{1,2,3};
a[0] = 2;
System.out.println(Arrays.toString(a)); //[2,2,3]

7.3.4 final方法

  • 不可被重写

7.3.5 final类

  • 不可以有子类

7.3.6 不可变类

  • 创建该类的实例后，该实例的实例变量是不可变的
  • Java的8个包装类和String类都是不可变类

7.4 抽象类

7.4.1 抽象方法和抽象类

  • 用abstract修饰，不能有方法体
  • 抽象类不能被实例化
  • 抽象类可以包含成员变量，方法，构造器，初始化块，内部类5中成分，但构造器不能用来创建实例
  • 含有抽象方法的类只能被定义成抽象类
  • 继承抽象类必须实现抽象类的所有抽象方法
  • final和abstract不能一起使用;static和abstract不能同时修饰某一个方法

7.5 接口

  • interface定义
  • 一个接口可以有多个直接父类接口，但接口只能继承接口，不能继承类
  • 接口可以包含成员变量（静态常量public static final）、方法（抽象实例方法、类方法、默认方法或私有方法 public abstract），内部类（public static）
  • 默认方法必须使用default修饰，不能使用static，系统回味默认方法自动添加public修饰符 默认方法：就是实例方法，不需要实现类去实现其方法
    public static void main(String[] args){
        Orange orange = new Orange(1, "Orange1");
        orange.goodForHealth();
    }

public interface healthyable {
    public default void goodForHealth() {
        System.out.println("健康增加");
    }
}
  • static方法不能用default方法修饰，类方法也总是由public修饰

7.5.1 接口的继承

  • 一个接口可以有多个直接父接口
  • 使用extends继承接口

7.5.2 接口的使用

  • 一个类可以继承多个接口
  • 接口不能显式继承任何类，但所有接口类型的引用变量都可以直接赋值给Object类型的引用变量，利用向上转型来完成

7.5.3 接口和抽象类

  • 接口里不包含构造器，抽象类里可以包含构造器
  • 接口里不能包含初始化块，但抽象类里有
  • 方法
  • 变量
  • 继承

7.5.4 面向接口编程

1. 简单工厂模式

工厂模式

  • computer从OutputFactory获取Output对象，并进行使用
  • OutputFactory通过实现Printer类来返回output对象
2.命令模式
  • 适用情况：某个方法需要完成某一个行为，但这个行为的具体实现无法确定，必须等到执行该方法才可以确定
    命令模式

8. 内部类

  • 内部类提供了更好的封装，不允许同一个包中的其他类访问该类
  • 内部类成员可以直接访问外部类的私有数据
  • 匿名内部类适合用于创建那些仅需要一次使用的类

8.1 非静态内部类

  • 内部类比外部类可以多使用三个修饰符：private，protected，static
  • 非静态内部类不能拥有静态成员
  • 非静态内部类成员可以访问外部类private成员，但反过来不成立，即外部类不能访问非静态内部类private成员
  • 如果存在一个非静态内部类对象，则一定存在一个外部类对象，但外部类对象里不一定寄生了非静态内部类对象

8.2 静态内部类

  • 静态内部类可以包含静态成员和非静态成员
  • 静态内部类不能访问外部类的实例成员
  • Java允许在接口里定义内部类，默认使用public static修饰

8.3 使用内部类

下面分3中情况讨论内部类的用法
1. 在外部类内部使用内部类
定义和使用都没有太大的区别
2. 在外部类以外使用非静态内部类

  • 内部类不能使用private修饰
  • 定义内部类的语法为OuterClass.InnerClass varName
class OutClass {
    class In{
     public In(String msg){
         System.out.println(msg);
     }
    }
}

class Out extends OutClass.In{

    public Out(OutClass outClass){
        outClass.super("hello"); //注意这里的用法，通过outclass调用In的构造函数
    }
    public static void main(String[] args){
        OutClass.In in = new OutClass().new In("has been created");
        Out out = new Out(new OutClass());
    }
}

3. 在外部类以外使用静态内部类

StaticOut.StaticIn in = new StaticOut.StaticIn()
  • 内部类不可以被子类重写

8.4 局部内部类

  • 生成的class文件遵循OuterClass$NInnerClass命名规则
  • 用法比较鸡肋，很少使用

8.5 匿名内部类

  • 适合于创建那种只需要一次使用的类
  • 创建匿名类时会立即创建一个该类的实例，这个类定义就消失
  • 匿名内部类不能是抽象类，因为在创建匿名内部类的时候，会立即创建匿名内部类对象
  • 匿名内部类不能定义构造器，因为匿名内部类没有类名

实现Interface

public class man {
    String msg = "123";
    public man(Runnable runnable){
        runnable.RunStart();
        runnable.RunFinish(this.msg);
    }
    
    public static void main(String[] args){
        man m1 = new man(new Runnable() {
            @Override
            public void RunStart() {
                
            }

            @Override
            public void RunFinish(String msg) {

            }
        });
    }
}

实现子类

    public static void main(String[] args){
        Orange orange = new Orange(1, "Orange1"){
            @Override
            public String toString() {
                return super.toString();
            }
        };

    }

9. Lambda表达式

三部分组成：
1）形参列表
2）箭头
3）代码块

public interface Runnable {
    public void RunStart();
}

public class man {
    String msg = "123";
    public man(Runnable runnable){
        runnable.RunStart();
    }

    public static void main(String[] args){
        man m1 = new man(() ->{
            System.out.println("123");
        });
    }
}
  • Lambda的目标类型必须是“函数式接口”
  • 如果带有@FunctionalInterface， 则可以实行强制类型转换

9.1 方法引用与构造引用

1. 引用类方法
public class man {
    String msg = "123";
    public man(Runnable runnable){
    }

    public static void main(String[] args){
        Runnable runnable = Integer::valueOf;
        Integer val = runnable.RunStart("123");
        System.out.println(val);
    }
}
  • 当调用Converter接口中的唯一的抽象方法时，调用参数将回传给Integer类的valueOf()
2. 引用特定对象的实例方法
public int info(String s) {
     System.out.println(s);
     return s.length();
}

Orange orange = new Orange(1);
Runnable runnable = orange::info;
3. 引用某类对象的实例方法
MyTest mt = String::substring;
4. 引用构造器
YourTest yt = JFrame:: new

9.2 Lambda表岛是与匿名类的联系

-lambda表达式是匿名内部类的一种简化

10. 枚举类

10.1 枚举类入门

  • 枚举类可以实现一个或多个接口，不能显式继承其他父类。
  • java.lang.Enum 类实现了 Serializable 和 Comparable 两个接口
  • 默认使用final修饰，因此枚举类不能派生子类
  • 只能用 private修饰，如果省略了构造器的访问控制符，则默认使用private
  • 枚举类所有实例在第一行显示列出
public enum SeasonNum {
    SPRING,SUMMER,FALL,WINTER;
}


public class EnumTest {
    public static void judge(SeasonNum s){
        switch (s) {
            case SPRING:
                System.out.println("SPring");
                break;
            case SUMMER:
                System.out.println("SUmmer");
                break;
            default:
                System.out.println("have no idea");
        }
    }

    public static void main(String[] args){
        for(SeasonNum s: SeasonNum.values()){
            judge(s);
        }
    }
}

java.lang.Enum的方法：

  • int compareTo：用于与指定枚举对象比较顺序
  • String name()：返回此枚举类实例的名称
  • int ordinal：返回枚举值在枚举类中的索引值
  • String toString()：返回枚举常量的名称
  • valuieOf()：枚举类中指定名称的枚举值
  • values()：所有枚举名称

10.2 枚举类的成员变量、方法和构造器

public class EnumTest {
    public static void judge(SeasonNum s){
        switch (s) {
            case SPRING:
                System.out.println("SPring");
                break;
            case SUMMER:
                System.out.println("SUmmer");
                break;
            default:
                System.out.println("have no idea");
        }
    }

    public static void main(String[] args){
        SeasonNum s = Enum.valueOf(SeasonNum.class, "SPRING");
        s.seansonName = "春天";
        System.out.println(s + s.seansonName);
    }
}

构造器

public enum SeasonNum {
    SPRING("春天"),SUMMER("夏天"),FALL("qiutian"),WINTER("dongtian");
    private final String name;
    private  SeasonNum(String seansonName){
        this.name = seansonName;
    }
    public String seansonName;

}
官子寒
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java知识-面向对象思维导图
04-02
Java知识-面向对象思维导图
面向对象编程（Java）.pdf
06-27
包含面向对象编程所有基础知识和实战代码
Java 入坑指南
m0_50414588的博客
04-30 1433
1. 想入坑，那我应该学什么？怎么学? 新手上路，最重要的就是选对方向，茫茫的语言海洋中，不同的开发语言被应用在不同的领域中，虽然以“某某语言程序员”自居过于片面，毕竟开发语言只是工具，更重要的是设计与思想，但是就入门甚至入门后的几年内，你或许始终是围绕你所选择的这门语言的主线和支线进行探索。所以，就前期而言，选择则一门适合的入门语言，这很重要！ 分析具体的语言选择前，我们先来简单的讲一下，现在有哪些常见的技术方向。 1.1选择一个适合自己的技术方向 就现在看来，常见的技术方向有：前端、后端、And.
java enum 总数_Java入坑指南（1）面向对象
weixin_29356815的博客
02-16 157
1. 类和对象1.1 定义三种最常见的成员：构造器、成员变量和方法定义类：修饰符：public、protected、private三个最多只能出现1个；它们可以与static、final组合起来修饰方法定义成员变量：修饰符：public、final、abstract三个最多只能出现1个定义方法：修饰符：public、protected、private三个最多只能出现1个；final、abstrac...
Java入坑指南
weixin_33937913的博客
09-19 347
Java入坑指南是滴，下面是一个最低的入坑 还应该有23种设计模式应该掌握的。╮(╯▽╰)╭注意，第一个j是大写。 Java的特点跨平台，风格接近C++最重要的api文档 https://docs.oracle.com/javas... 语言特点 面向对象 跨平台，运行在JRE上，JRE包括JVM 具有自动垃圾回收的机制 属于强类型，...
Java入坑指南—JAVA 基础
第四维度
10-29 140
Java入坑指南—JAVA 基础 点击蓝字关注☞尚学堂今天 Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。 学 java 编程，一般有两种情况。 一种是已经掌握了其他语言，那学习 java 比较简单，语言...
Java入坑指南2.0(B站Up主CodeSheep搬运)
有道无术，术尚可求；有术无道，止于术。
05-11 1037
B站原视频 直通车 Java入坑指南1.0 直通车 一、编程基础 Java语言 语言基础：基础语法 面向对象 接口 容器 异常 泛型 反射 注解 I/O 图形化 JVM：类加载机制 字节码执行机制 JVM内存模型 GC垃圾回收 JVM性能监控与故障定位 JVM调优 并发/多线程：并发编程基础 线程池 锁 并发容器 原子类 JUC并发工具类 数据结构和算法 数据结构：字符串 数组 链表 二叉树 堆、栈、队列 哈希 算法：查找 排序 贪心 分治 动态规划 回溯 计算机网络 ARP协议 IP/ICMP协议
如何学java基础_Java入坑指南—JAVA 基础如何学习，才能又快又稳？
weixin_29801195的博客
02-20 55
Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。学 java 编程，一般有两种情况。一种是已经掌握了其他语言，那学习 java 比较简单，语言只是工 具，编程能力才是根本。另一种是零基础，对于编程未入门或者懵懵懂懂。本文针...
给新入坑的小伙伴们的郑氏Java入门指南及其它建议
m0_54524462的博客
07-25 1093
给集美大学网络工程专业的大二Java初学者的小建议。
koa2快速入坑指南
didi_cloud的博客
11-26 186
因为最近一个项目的原因，简单了解了koa2框架。为了帮助小伙伴们刚好的入坑，特整理此文。为啥入坑koa2？koa2小而美，相比express更小、更健壮、更富有表现力；全面支持ES6/ES7语法；结构优雅，易于扩展，360的thinkjs，阿里的egg.js全部基于koa2开发，源代码只有4个文件，500行代码；站在 2018 年的节点来看，Koa2 的学习大潮已经到来Node.js技术栈Web服...
Web前端框架开发入坑指南
热门推荐
Enweitech Software Works
06-18 1万+
都2020年了，尽管 Web 开发的典型应用场景除了将服务器用作平台、浏览器用作客户端之外，几乎很少活跃于其他业务领域，但不可否认 JavaScript 语言和框架的使用已经成为了主流。Angular、React 和 Vue，作为 JavaScript 的三大框架已逐步发展成熟，三者的差异性也越发明显，假设 JavaScript 还会继续流行十年左右，未来十年，你将会作何选择？ 企业现状 多个项目组协同开发多个业务应用：大一点公司叫做敏捷或者协同开发，小的公司就是一锅粥开发人干的事杂。 业务和产品
基于java面向对象实现扫雷程序源码
08-04
基于java面向对象实现扫雷程序源码 基于java面向对象实现扫雷程序源码 基于java面向对象实现扫雷程序源码 基于java面向对象实现扫雷程序源码 基于java面向对象实现扫雷程序源码 基于java面向对象实现扫雷程序源码 ...
Java基础之理解面向对象
10-15
java基础-理解面向对象
JAVA面向对象.docx
07-07
JAVA的面向对象思想，至关重要。即万物皆对象。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 1005
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明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 800
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 294
【代码】Java手动启动jar包。
java调用cmd执行命令
weixin_45210565的博客
05-28 260
3、exec(String command, String[] envp) ，在调用外部程序之前设置系统环境变量，该变量仅供command入参使用，envp每个元素为一个系统环境变量，并且字符串格式为“环境变量名=环境变量值”。2、exec(String[] cmdArray) ，调用外部程序，入参cmdArray的元素将组合成为一条完整的外部可执行程序的启动路径或命令。1、exec(String command) ，调用外部程序，入参command为外部可执行程序的启动路径或命令。
Java面向对象-类定义1
11-10
Java是一种面向对象的编程语言，类是Java中最基本的编程单元。类定义了对象的属性和方法。以下是一个简单的Java类定义示例： ```java public class Person { // 属性 private String name; private int age; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值