Java学习笔记（四）之类型转换，单例模式

对象类型转换（Casting）

基本数据类型的转换

• 自动类型转换：小的数据类型可以自动转换成大的数据类型

long g = 20; double d = 12.0f

• 强制类型转换：可以把大的数据类型强制转换成小的数据类型

float f = (float) 12.0; int a = (int) 1200L

对Java对象的强制类型转化成为造型

• 从子类到父类的类型转换可以自动进行
• 从父类到子类的类型转换必须通过造型（强制类型转换）实现
• 无继承关系的引用类型间的转换是非法的。

public class Test {
    public static void main(String[] args) {
        Test test = new Test();
        test.method(new Person()); //p不属于Student,这是Person的test方法
        test.method(new Student());//p属于Student,这是Student的getSchool方法
    }

    public void method(Person p) {
        if (p instanceof Student) {
            System.out.println("p属于Student");
            Student s = (Student) p;
            s.getSchool();
        } else {
            System.out.println("p不属于Student");
            p.test();
        }
    }
}

==操作符与equals方法

基本类型比较

只要两个变量的值相等，即为true

int i = 3;
System.out.println(i == 3); //true
System.out.println(i == 4); //false

引用类型比较

只有指向同一个对象时，才返回true

Person p1 = new Person();
Person p2 = new Person();
Person p3 = p1;
System.out.println(p1 == p2); //false
System.out.println(p1 == p3); //true

注意：用“==”进行比较时，符号两边的数据类型必须兼容（可自动转换的基本数据类型除外），否则编译出错。

equals：

所有类都继承了Object，也就获得了equals()方法。还可以重写。

• 对于对象来说，特殊的类如（String、File、Date以及包装类（Wrapper class）等），使用==比较的是对象（对象的地址），equals比较的是内容。因为这些类中重写了Object类的equals()方法。
• 除了特殊的类之外的其他普通的类的对象，==和equals比较的都是对象（对象的内存地址）

public class Order {

    public Order(int orderId, String orderName) {
        this.orderId = orderId;
        this.orderName = orderName;
    }

    private int orderId;
    private String orderName;

    public int getOrderId() {
        return orderId;
    }

    public void setOrderId(int orderId) {
        this.orderId = orderId;
    }

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    @Override
    public boolean equals(Object obj) {
        boolean flag = false;
        if (obj instanceof Order) {
            Order order = (Order) obj;
            if (this.orderId == order.orderId && this.orderName.equals(order.orderName)) {
                flag = true;
            }
        }
        return flag;
    }
}

public class Test {

    public static void main(String[] args) {

        Order order1 = new Order(1, "我是Order1");
        Order order2 = new Order(2, "我是Order2");
        Order order3 = new Order(2, "我是Order2");

        System.out.println(order1.equals(order2));  //false
        System.out.println(order2.equals(order3));  //true
    }
}

包装类

Integer i = 123;  //自动装箱
int i1 = i; //自动拆箱
System.out.println(i);
System.out.println(i1);

字符串转换基本数据类型：

int i = Integer.parseInt("123");
float f = Float.parseFloat("0.32");
boolean b = Boolean.parseBoolean("false");

基本数据类型转换成字符串：

String istr = String.valueOf(i);
String fstr = String.valueOf(f);
String bstr = String.valueOf(true);

toString：是Object类的一个方法，默认输出当前对象的内存地址，如果想要输出其他内容，需重写toString方法

关键字：static

public class Country {
    static String country;  //类变量，不用实例化，直接通过类名.属性就可以使用，是类的一部分，被所有这个类的实例化对象所共享，也叫静态变量
    String name;  //实例变量，只有实例化之后才能使用，输入实例化对象的一部分，不能共用
    int age;

    public static void test() {
        System.out.println("这是一个静态方法");
    }

    public static void main(String[] args) {
        Country.country = "中国";
        System.out.println(Country.country);
        Country.test();
    }
}

• 设计思想：希望有些属性不想因为对象的不同而改变，将这些属性设置为类属性；希望有些方法不想因为对象的不同而频繁通过new对象方法去调用方法，这些方法设置为类方法，也就是静态方法，比如做工具类

public class Utils {

    public static boolean isEmpty(String str) {
        boolean flag = true;
        if (str != null && !str.equals("")) {
            flag = false;
        }

        return flag;
    }
}
public class Country { 
    
    public static void main(String[] args) {
        String str = "";
        System.out.println(Utils.isEmpty(str));
    }
}

设计模式

设计模式就是在我们实际编程的过程中，逐渐总结出的一些解决问题的套路。

单例模式：只有一个实例对象，在整个的软件系统运行过程中，这个类只被实例化一次。

例如：实例化对象的创建要消耗大量的资源和时间。

饿汉式：

首先new一个对象，之后所有调用我的都用这个对象。

public class Single {

    //构造函数私有化
    private Single() {

    }
    //私有的Single类型的类变量
    private static Single single = new Single();

    public static  Single getInstance() {
        return single;
    }
}

//调用
public class Test {

    public static void main(String[] args) {
        Single instance = Single.getInstance();
    }
}

懒汉式：

最开始，对象是null，直到有一个人调用我，才new一个对象，之后所有调用我的都用这个对象。

public class Single1 {

    private Single1() {

    }

    private static Single1 single1 = null;

    public static Single1 getInstance() {
        if (single1 == null) {
            single1 = new Single1();
        }
        return single1;
    }
}

代码块

非静态代码块：没有static修饰的代码块

public class Person {
    String name;

    public Person() {
        this.name = "张三";
        System.out.println("执行的是构造方法");
    }

    //非静态代码块
    {
        System.out.println("执行的是非静态代码块");
    }
}

public class Test {

    public static void main(String[] args) {
        new Person();
        //输出：执行的是非静态代码块
		//	   执行的是构造方法
    }
}

在new Person()执行的时候：

• 1.类的属性的默认初始化和显式初始化
• 2.执行代码块的代码
• 3.执行构造器的代码

静态代码块：用static修饰的代码块

static int age;

 //静态代码块
    static {
        //这里只能使用静态变量和方法
        age = 1;
        show();
    }
    public static void show() {
        System.out.println(age);
    }

在程序运行过程中，非静态代码块每次new对象时都会重新执行，而静态代码块只执行一次。

在实际开发中，static静态代码块用在初始化类的静态属性。用的多一些。

public class Test {
    public static void main(String[] args) {
		
        //匿名内部类
       Person p = new Person(){
           {  //在匿名内部类中用代码块替代构造方法
               super.name = "李四";
           }
            @Override
            public void test() {
                System.out.println("这是重写之后的");
            }
        };

        System.out.println(p.name);  //李四
        p.test();  //这是重写之后的
    }
}

关键字：final

• final修饰的类不能被继承
• final修饰的方法不能被子类重写
• final修饰的变量即为常量，名称大写，且只能被赋值一次。