JAVA面向对象(四)

一、包装类

java中的基本数据类型却不是面向对象的，但是我们在实际使用中经常将基本数据类型转换成对象，便于操作。

包装类和基本数据类型的关系

继承关系

 

基本数据类型转到包装类（直接用构造器）

int num1 = 123;
Integer in1 = new Integer(num1);
Integer in2 = new Integer("123");
Integer in3 = new Integer("123ab");//报异常

System.out.println(in1==in2);//对象，比较的是地址

class Order{
    boolean isMale;
    Boolean isFemale;
}

Order order = new Order();
System.out.println(order.isMale);//false
System.out.println(order.isFemale);//null(对象初始为nul)
 

包装类转到基本数据类型（调用Xxx的xxxValue()方法，自动装箱和拆箱）

Integer in1 = new Integer(12);
int i1 = in1.intValue();
Float f1 = new Float(12.3);
float f2 = f1.floatValue();

JDK5的新特性箱自动装箱和拆箱

int num1 = 10;
Integer in1 = num1;//自动装箱（基本类型到包装类）
boolean b1 = true;
Boolean b2 = b1;//自动装箱
        
int num2 = in1;//自动拆箱（包装类到基本类型）


Java为了提高拆装箱效率，在执行过程中提供了一个缓存区（对象池）【类似于常量数组】，
如果传入的参数是，-128<参数<127会直接去缓存查找数据，如果有有直接产生，
如果没有就隐式调用new方法产生
Integer x = -128;
Integer y = -128;
System.out.println(x==y);//ture;
Integer a = 128;
Integer b = 128;
System.out.println(a==b);//false

基本数据类型、包装类型到String类型（类型+""、调用String重载的valueOf(Xxx，xxx)）

int num1 = 10;
String str1 = num1+"";//方式一
float f1 = 12.3f;
String str2 = String.valueOf(f1);//方式二

String类型到基本数据类型、包装类型（调用包装类的 parseXxx(String s)  ）

String str1 = "123";
//错误情况
//int num1 = (int)str1;
//Integer in1 = (Integer)str1;
//正确情况
int num2 = Integer.parseInt(str1);

常用的就是：自动拆箱装箱、String重载的valueOf(Xxx，xxx)、parseXxx(String s)

 

二、static关键字

有时候希望无论创造多少对象，都希望某些数据在内存空间中只有一份。

1.static：

static表示静态的，可以用来修饰属性、方法、代码块、内部类

2.static修饰属性：

static修饰的属性称为静态变量。

非静态变量：每个对象用于单独的一套非静态变量。

静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量，会导致其他对象调用该变量的时候，是修改过的。

静态变量是随着类的加载而加载的，要早于对象的建立，且只会存在一份在静态域中。可以通过”类.静态变量”的方式来调用

3.static修饰方法：

随着类的加载而加载，可以通过”类.静态变量”的方式来调用

静态方法中只能调用静态的方法或者属性（我们一直写的main函数）

非静态方法中即可以调用静态的，也可以调用非静态的。

在静态方法中不能使用this()和super();

关于静态方法和静态属性都要从生命周期去考虑

4.如何确定一个属性是否要设置为静态的：

属性可以被多个对象共享，不会随着对象的不同而不同

类中的常量也声明为static

5.如何确定一个方法是否要设置为静态的：

操作静态属性的方法，通常设置为static

工具类中的方法（比如Math、Arrays等）

练习：

public class Main {
    public static void main(String[] args) {
        Circle c1 = new Circle(1);
        Circle c2 = new Circle(2);
        System.out.println("一共创建了"+Circle.getTotal()+"个圆");
        System.out.println("c2的id为： "+c2.getId());
    }

}
class Circle{
    private double radius;
    private int id;
    private static int total;//总数
    private static int init = 1001;//初始编号

    public Circle(double radius) {
        this.radius = radius;
        id = init;
        init++;
        total++;
    }
    public static int getTotal() {
        return total;
    }

    public int getId() {
        return id;
    }
}

一共创建了2个圆
c2的id为： 1002

static关键字的应用：单例模式：

饿汉式：

public class Main {
    public static void main(String[] args) {
        Hungry c1 = Hungry.getCC();
        Hungry c2 = Hungry.getCC();
        System.out.println(c1==c2);//true   指向同一对象
    }
}
class Hungry{
    private static Hungry CC = new Hungry();
    private Hungry(){}//构造器私有化
    //提供公共的静态方法，返回对象
    public static Hungry getCC(){
        return CC;
    }
}

懒汉式：

public class Main {
    public static void main(String[] args) {
        Lazy l1 = Lazy.getCC();
        Lazy l2 = Lazy.getCC();
        System.out.println(l1==l2);//true   指向同一对象
    }

}
class Lazy{
    private static Lazy LL = null;
    private Lazy(){}//构造器私有化
    public static Lazy getCC(){
        if(LL == null){
            LL = new Lazy();
        }
        return LL;
    }
}

两者的区别：

饿汉式：

坏处：对象加载时间过长

好处：线程安全

懒汉式：

好处：延迟对象的建立

目前的写法，线程不安全