包装类 Object类 内部类

2023.02.15 星期三 包装类 Object类 内部类

1 包装类

在Java中有8种基本数据类型。（int）
Java是一种面向对象的语言。
在Java中为每一个基本数据类型，都提供了一个包装类。（Integer）
只有int,char 不太一样。其他都是首字母大写。
float —> Float类

1.1 包装类的作用

包装类的作用，就是将基本数据类型封装成引用数据类型。
比如：整形变量的最大值。
int i = 19;
如果换成包装类，就可以打点调用一系列的方法。

Integer integer = new Integer(i);

1.2 自动折箱和自动装箱

在Java1.5时，提供了自动折装箱的能力。

Integer i = 5;	//自动装箱
sout(i);	//自动折箱

1.3 推荐使用包装类

因为包装类比基本数据类型多了一个特殊的值（null）。

Integer i = null;

1.4 使用包装类获取相关信息

Integer是int的包装类。int是整形。
所以使用Integer可以获得整形的相关信息。

public static void main(String[] args) {
    Integer i = 10;

    System.out.println(i);
    System.out.println(i.intValue());

    System.out.println(Integer.MAX_VALUE);
    System.out.println(Integer.MIN_VALUE);
    
    //进制转换的方法
    System.out.println(Integer.toHexString(10));
    System.out.println(Integer.toOctalString(10));
    System.out.println(Integer.toBinaryString(10));

}

1.5 使用包装类进行类型转换

String —> 基本数据类型转换

public class Test02 {
    public static void main(String[] args) {
        String score = "95";

        int i = Integer.parseInt(score);

        double d = Double.parseDouble("3.14");

        System.out.println((i+105)*d);
    }
}

2 Object类

java.lang.Object类。
所有类的顶层父类。
当创建的类。没有指定一个父类时，默认继承Object。
在Object类中声明的方法，在每一个类中都可以使用。

2.1 所有类的父类

使用Object做多态时，表示任意类的实例都可以使用。

public class ATest {
    /**
     * dis方法，可以适用到任意类
     * @param obj 任意一个类的实例都可以做为参数传递进来
     */
    public static void dis(Object obj){
    }
    public static void main(String[] args) {
        A a = new A();
        a.toString();

        Object obj = new A();
    }
}

2.2 toString()方法

toString()方法的作用是返回当前对象的字符串表示格式。

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

一般我们都建议大家，在我们自己编写的实体类中重写toString方法。
实体类（domain）：表示现实世界中某一具体实物的类。例如：手表，水杯，电脑，人，狗。
当我们输入一个对象时，系统自动调用对象的toString方法获得对象的字符串表示格式。
A a = new A();
sout(a); 与 sout(a.toString()); 完成一样。

2.3 equals(Object o)方法

equals方法是用来进行二个对象是否相等的比较。
只有引用相同的二个对象才是相等的。

public boolean equals(Object obj) {
    return (this == obj);
}
this表示当前调用equals方法的对象
obj 表示要判断相等的另一个对象
this == obj  两个引用数据类型。比较引用是不是同一个位置。

我们在自己编写的类中如何使用equals的方法
重写equals方法

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Stu stu = (Stu) o;
    return Objects.equals(sid, stu.sid);
}

3 内部类

3.1 什么是内部类

在一个类中声明的类，称为内部类。

3.2 内部类的分类

在Java中内部类分为4种：
1 局部内部类
2 成员内部类
3 静态内部类
4 匿名内部类（必须会）

3.3 局部内部类

public class A {
    public void fun(){
        //局部内部类
        class B {
        }
        B b = new B();
    }
}

3.4 成员内部类

public class B {
private Integer i;
    public class InnerB {
        public void innerFun(){
            System.out.println("成员内部类的方法！");
        }
    }
    private InnerB innerB = new InnerB();

    public void dis(){
        innerB.innerFun();
    }
    public void fun(){
        InnerB innerB = new InnerB();
    }
}


public class BTest {
    public static void main(String[] args) {
        B.InnerB innerB = new B().new InnerB();
        innerB.innerFun();
    }
}

3.5 静态内部类

public class C {
    private Integer i;
    public static class InnerC {
        public void innerFun(){
            System.out.println("静态内部类的方法！");
        }
    }
    private InnerC innerC = new InnerC();
}


public class CTest {
    public static void main(String[] args) {
        C.InnerC innerC = new C.InnerC();
        innerC.innerFun();
    }
}

3.6 匿名内部类

匿名：就是没有名。
匿名内部类就是一个没有名字的内部类。
匿名内部类一般配合：
1 抽象类
2 接口
3 普通类

抽象类的使用：

public abstract class D {
    public abstract void fun();
}

以前的做法是要创建一个D的子类。对fun方法进行重写。
现在可以使用匿名内部类的方式：

public class DTest {
    public static void main(String[] args) {
        D d = new D(){
            @Override
            public void fun() {
                System.out.println("匿名内部类的方法重写！");
            }
        };
        d.fun();
        System.out.println(d);
    }
}

接口的使用：

public interface E {
    void fun();
}


public class ETest {
    public static void main(String[] args) {
        E e = new E() {
            @Override
            public void fun() {
                System.out.println("匿名内部类的接口实现！");
            }
        };
        e.fun();
        System.out.println(e);
    }
}

普通类：

public class F {
    public void fun(){
        System.out.println("F.fun()！");
    }
}
public class FTest {
    public static void main(String[] args) {
        F f = new F(){
            @Override
            public void fun() {
                System.out.println("匿名内部类的fun方法重写！");
            }
        };
        f.fun();
        System.out.println(f);
    }
}

4 引用数据类型的类型转换

基本数据类型的类型转换分为 自动类型转换 和 强制类型转换
自动类型转换 小 向 大
强制类型转换 大 向 小 （小类型）变量

4.1 引用类型的类型转换前提是继承

在Java中引用数据类型进行类型转换的前提条件一定子类与父类之间的。

4.2 引用类型的转换的分类

引用数据类型的转换的分为：向上转型 和 向下转型
向上转型 ： 子类 向 父类 （自动）
向下转型 ： 父类 向 子类 （强制）

4.3 向上转型

Pet pet = new Cat();//自动向上转型

4.4 向下转型

向下转型是父类 向 子类 转换。
强制要求 父类对象 必须 是当前这个子类对象 转上去的。

如果父类不是当前子类向上转型的对象。会出现 类型转换异常ClassCastException

Pet pet = new Cat();//自动向上转型

Cat cat = (Cat) pet;//强制向下转型

4.5 判断是否是指定类型的运算符

public class Test {
    public static void main(String[] args) {
        Pet pet = new Cat();//自动向上转型

        Cat cat = (Cat) pet;//强制向下转型

//        Dog s = (Dog) pet;

        System.out.println(pet instanceof Cat);
        System.out.println(pet instanceof Dog);

        System.out.println("end");
    }
}