常用类

this 的注意事项和使用细节

1) this 关键字可以用来访问本类的属性、方法、构造器

2) this 用于区分当前类的属性和局部变量

3) 访问成员方法的语法：this.方法名(参数列表);

4) 访问构造器语法：this(参数列表); 注意只能在构造器中使用(即只能在构造器中访问另外一个构造器, 必须放在第一条语句)

5) this 不能在类定义的外部使用，只能在类定义的方法中使用。

一，包装类

　　1.包装类的分类

　　　　1）针对八种基本数据类型相应的引用类型

　　　　2）有了类的特点，可以调用类的方法

　　2.基本数据类型 ---------------》包装类

　　　　1）通过构造器：Integer i = new Integet(11)

　　　　2）通过字符串参数： Float f = new Float("25.2f")

        Integer i = new Integer(33);
        System.out.println("i =  " + i);
        Byte b = new Byte((byte) 12); //可以双引号 也可以强转
        System.out.println("b =" + b);
        Short s = new Short("25");
        System.out.println("s = " + s);

　　　　3) 自动装箱

         自动装箱
        Integer i1 = 33;
        System.out.println("i1"+i1);
        Byte b = 23;
        System.out.println("b = " + b);
        Character c = '国';
        System.out.println("c =" + c);

　　3.包装类 ------------》基本数据类型

　　　　1) 调用xxxValue 方法

        Integer i = 33;
        int i1 = i.intValue();  
        System.out.println("ii = " + i1);
        Byte b = 25;
        byte b1 = b.byteValue(); 
        System.out.println("b1 = " + b1);      
       Character c = '国';
        char c1 = c.charValue();
        System.out.println("c1 = " + c1);

　　　　2）自动拆箱

        Integer i = 33;
        int iValue = i;
        System.out.println(iValue);
        Byte b = 55;
        byte bValue = b;
        System.out.println(bValue);

　　4.字符串 -----------》包装类

        Integer i = new Integer("33");
        System.out.println("i = "+ i);
        Double d = new Double("55.0");
        System.out.println("d = "+ d);

　　5.包装类 ---------------》字符串

        Integer i = 33;
        String iValue = i.toString();
        System.out.println("iValue =" + iValue);
        Character c = '古';
        String cValue = c.toString();
        System.out.println("cValue = "+ cValue);

　　6.基本数据类型 ----------》字符串

        int i = 33;
        //1.通过字符串拼接
        String iValue = i + "";
        System.out.println("iValue=" + iValue);
        //2.通过String.valueOf方法
        String s = String.valueOf(i);
        System.out.println("s = "+ s);

　　7.字符串---------》基本数据类型

       String i = "34";
        String d = "33.5";
//        通过静态方法 类名.parseXxx
        int iValue = Integer.parseInt(i);
        System.out.println("iValue=" + iValue);
        double dValue = Double.parseDouble(d);
        System.out.println("dValue= " + dValue);
//        通过包装类的构造器和拆箱操作  面试高频知识点
        String i1 = "33";
        Integer i1Value = new Integer(i1);
        System.out.println("iValue=" + i1Value);

Object 类

　　1. == 和 equals 的对比

　　　　== 是比较运算符，即可以判断基本数据类型，又可以判断引用数据类型

　　　　== 如果判断基本数据类型，判断的是值是否相等

　　　　== 如果判断的是引用数据类型，判断的是地址是否相等，判定是不是同一个对象

public class Equals01 {
    public static void main(String[] args) {
        int a = 10;
        double b = 10.0;
        System.out.println(a == b); //true
        A a1 = new A();
        A a2 = a1;
        A a3 = a1;
        System.out.println(a1 == a2); //true
        System.out.println(a2 == a3); //true
        A a4 = a1; //向上转型   父类的引用指向子类的对象
        System.out.println(a1 == a4);//true
    }
}
class A{}
class B extends A{}

　　equals : 是Object类中的方法，只能判断引用类型

　　默认判断的是地址是否相等，子类中往往从写了该方法，用于判断内容是否相等比如Integer , String

Integer integer = new Integer(20);
        Integer integer1 = new Integer(20);
        System.out.println(integer == integer1); //false ==比较的的对象内存地址
        System.out.println(integer.equals(integer1)); //true 重写了equals方法 比较内容

　　　　2. hashCode方法

　　　　1）提高具有哈希结构的容器的效率

　　　　2) 两个引用，如果指向的是同一个对象，则哈希值肯定是一样的

　　　　3）两个引用，如果指向的是不同对象，则哈希值是不一样的

　　　　4）哈希值主要根据地址号来的，不能完全等价于哈希值等价于地址

public class HashCode {
    public static void main(String[] args) {
        AA aa = new AA();
        AA aa1 = new AA();
        AA aa2 = aa1;
        System.out.println("aa哈希值" + aa.hashCode());  //aa哈希值460141958
        System.out.println("aa1哈希值" + aa.hashCode()); //aa1哈希值460141958
        System.out.println("aa2哈希值" + aa.hashCode()); //aa2哈希值460141958
    }
}
class AA{}

　　3. toString 方法

　　　　1）基本介绍

　　　　　　默认返回：全类名 + @ +哈希值的十六进制子类往往会重写 toString 方法，用于返回对象的属性信息

　　　　2）重写 toString 方法，打印对象或拼接对象时，会自动调用该方法的toString 形式

　　　　3）当直接输出一个对象时，toString 方法会被默认的调用，

public class ToString {
    public static void main(String[] args) {
        AAA aaa = new AAA("小明", 52);
        System.out.println(aaa.toString());  //toString 可以默认被调用 可以省略
    }
}
//------------------------------
class AAA{
    private String name;
    private int age;
    @Override
    public String toString() {  //重写了 toString 方法  一般是把对象的属性值输出，当然程序员也可以自己定制
        return "AAA{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

　　4. finalize 方法

　　　　1）当对象被回收时，系统会自动调用该对象的finalize方法，子类可以重写该方法，做一些释放资源的操作

　　　　2）什么时候被回收，当某个对象没有任何引用时，则jvm就会认为这个对象是一个垃圾对象，就会使用垃圾回收机制销毁该对象，在销毁该对象前，则先调用finalize方法。

　　　　3）垃圾回收机制的调用，是由系统来决定，也可通过System.gc() 主动触发垃圾回收机制

//演示 Finalize 的用法
public class Finalize {
    public static void main(String[] args) {
        Car bmw = new Car("宝马");
//这时 car 对象就是一个垃圾,垃圾回收器就会回收(销毁)对象,  在销毁对象前，会调用该对象的finalize 方法
// ,程序员就可以在 finalize 中，写自己的业务逻辑代码(比如释放资源：数据库连接,或者打开文件..)
//,如果程序员不重写 finalize,那么就会调用 Object 类的 finalize,  即默认处理
//,如果程序员重写了 finalize,  就可以实现自己的逻辑
        bmw = null;
        System.gc();//主动调用垃圾回收器
        System.out.println("程序退出了....");
    }
}
class Car {
    private String name;
    //属性,  资源。。
    public Car(String name) {
        this.name = name;
    }
    //重写 finalize
    @Override
    protected void finalize() throws Throwable {
        System.out.println("我们销毁 汽车" + name );
        System.out.println("释放了某些资源...");
    }
}
//输出  程序退出了....
//我们销毁 汽车宝马
//释放了某些资源...

posted @ 2022-11-24 09:32 阿文程序猿阅读(25) 评论(0) 收藏举报

刷新页面返回顶部

p1121

常用类

公告