入门JAVA第八天 包装类

一、包装类

包装类也有叫封装类。

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

二、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()方法的作用是返回当前对象的字符串表示格式。

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

Test：

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

Test:

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

3.6 匿名内部类

匿名：就是没有名。

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

匿名内部类一般配合：

1 抽象类

2 接口

3 普通类

(1) 抽象类的使用

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

(2) 接口的使用

接口：

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

(3) 普通类

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.1 引用类型的类型转换前提是继承

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

4.2 引用类型的转换的分类

引用数据类型的转换分为：向上转型 和 向下转型

向上转型 ： 子类 向 父类 （自动）

向下转型 ： 父类 向 子类 （强制）

4.3 向上转型

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

4.4 向下转型

向下转型是父类 向  子类 转换。

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

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

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