暑假java第一天

public class IntegerTest01 {
    //入口
    public static void main(String[] args) {
        //有没有这种需求:调用doSome()方法的时候需要传一个数字进去。
        //但是数字属于基本数据类型，而doSome()方法参数的类型是Object。
        //可见doSome()方法无法接受基本数据类型的数字。那怎么办？可以传一个数字对应的包装类进去。

        //把100这个数字经过构造方法包装成对象
        MyInt myInt=new MyInt(100);
        //doSome()方法虽然不能直接传100，但是可以传一个100对应的包装类型。
        doSome(myInt);
    }
    public static void doSome(Object obj){
        System.out.println(obj);//会自动调用toString()，记得重写
    }
}
class MyInt{
    int i;

    public MyInt(){}
    public MyInt(int i){
        this.i=i;
    }

    //重写toString()
    public String toString() {
        return String.valueOf(i);
    }
}

（都在java.lang包下）
byte ~ Byte（父类java.lang.Number）
short ~ Short（父类java.lang.Number）
int ~ Integer（父类java.lang.Number）
long ~ Long（父类java.lang.Number）
float ~ Float（父类java.lang.Number）
double ~ Double（父类java.lang.Number）
boolean ~ Boolean（父类java.lang.Object）
char ~ Character（父类java.lang.Object）

装箱和拆箱的概念：

public class Test01 {
    public static void main(String[] args) {
        //基本数据类型-(转换)->引用数据类型 《装箱》
        Integer x=new Integer(123);

        //引用数据类型-(转换)->基本数据类型 《拆箱》
        float f=x.floatValue();
        System.out.println(f);//123.0
        int i=x.intValue();
        System.out.println(i);//123

    }
}

包装类的构造方法：
以Integer为例:
1)Integer(int)
2)Integer(String)
剩下的以此类推！

public class Test02 {
    public static void main(String[] args) {
        //JDK9之后就不支持这种写法了，出现横线表示已经过时
        //int->Integer
        Integer x=new Integer(100);
        System.out.println(x);
        //String->Integer
        Integer y=new Integer("100");
        System.out.println(y);
        //double->Double
        Double m=new Double(3.14);
        System.out.println(m);
        //String->Double
        Double n=new Double("3.14");
        System.out.println(n);
    }
}

常量的最大值: 包装类型名.MAX_VALUE
常量的最小值: 包装类型名.MIN_VALUE

public class Test03 {
    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);//2147483647
        System.out.println(Integer.MIN_VALUE);//-2147483648
        System.out.println(Byte.MAX_VALUE);//127
        System.out.println(Byte.MIN_VALUE);//-128
        System.out.println(Character.MAX_VALUE);
    }
}

例子1（自动拆箱与自动装箱操作）

public class Test04 {
    public static void main(String[] args) {
        //100是基本数据类型
        //x是包装类型
        //基本数据类型--(自动转换)-->包装类型 《自动装箱》
        Integer x=100;
        System.out.println(x);

        //x是包装类型
        //y是基本数据类型
        //包装类型--(自动转换)-->基本数据类型 《自动拆箱》
        int y=x;
        System.out.println(y);

        //z是一个引用，z还是保存了一个对象的内存地址
        Integer z=1000;//等同于Integer z=new Integer(1000);
        //这里没有报错
        //+两边都是基本数据类型，z是包装类，这里进行了自动类型转换，z自动转换为了基本数据类型
        System.out.println(z+1);

        Integer a=1000;
        Integer b=1000;
        //== 比较的是两个对象的内存地址。a,b引用中保存的对象内存地址不同。
        //== 不会触发拆箱
        System.out.println(a==b);//false
    }
}

样例2（面试题）

public class Test05 {
    public static void main(String[] args) {
        Integer a=127;
        Integer b=127;
        System.out.println(a==b);//true

        
        Integer x=128;
        Integer y=128;
        System.out.println(x==y);//false
    }
}

大型项目中的重要优化手段就是:cache
优点：效率高
缺点：耗费内存

（其他包装类，以此类推）

//Integer类当中有哪些常用的方法呢？
public class Test06 {
    public static void main(String[] args) {
        //1. intValue()
        //将 Integer的值作为 int 。
        //手动装箱
        Integer x=new Integer(1000);
        //手动拆箱
        int y=x.intValue();
        System.out.println(y);

        //2.重点方法
        //static int parseInt(String s)
        //静态方法，传参String，返回int
        //网页文本框上输入的100实际上是"100"字符串。后台数据要求存储100数字，此时java程序需要将"100"字符串转换成100数字。
        int retvalue=Integer.parseInt("123");//String->int
        //int revalue=Integer.parseInt("中文");//异常: NumberFormatException
        System.out.println(retvalue+100);//223
        //照葫芦画瓢(用类名调用方法，说明是静态方法)
        double retvalue2=Double.parseDouble("3.14");
        System.out.println(retvalue2+1);//4.140000000000001（精度问题）
        float retvalue3=Float.parseFloat("1.0");
        System.out.println(retvalue3+1);//2.0

        //3.valueOf(int i)
        //将字符串转换成int型
        Integer c=Integer.valueOf("456");
        System.out.println(c);
    }
}

public class Test07 {
    public static void main(String[] args) {
        //String->int
        String s1="100";
        int i1=Integer.parseInt(s1);
        System.out.println(i1+1);//101

        //int->String
        String s2=i1+"";
        System.out.println(s2+1);//"1001"

        //int->Integer(自动装箱)
        Integer x=1000;

        System.out.println(x);
        //Integer->int(自动拆箱)
        int y=x;
        System.out.println(y);

        //String->Integer
        Integer k=Integer.valueOf("123");
        System.out.println(k);//123

        //Integer->String
        String e=String.valueOf(k);
        System.out.println(e);

    }
}