软件设计之Java入门视频(11)

视频教程来自B站尚硅谷：

尚硅谷Java入门视频教程，宋红康java基础视频
相关文件资料（百度网盘）
提取密码：8op3
idea 下载可以关注 软件管家 公众号

学习内容：

该视频共分为1-717部分
本次内容涉及300-329
在写代码时，总是需要来回切换界面来看代码要求，这里推荐Snipaste，可以把截图以窗口形式放在屏幕上
记录内容：

1. toString()
2. JUnit单元测试
3. 包装类的使用
4. static
5. 单例设计模式

1、toString()

1）当输出一个对象的引用时，实际就是调用当前对象的toString()方法
2）像String、Date、File、包装类等都重写了Object类中的toString()方法

java">Customer cust = new Customer (); //构造一个customer类的对象
System.out.println(cust);
System.out.println(cust.toString());//效果相同
//输出 类名+@ +地址
//****toString定义****
  public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
//String类的toString方法
String str = new String("AB");
System.out.println(str.toString());//输出AB

2、JUnit单元测试

目的：将测试代码单独作为单元进行单独测试
创建Java类进行单元测试：
1）此时Java类需要满足两个要求：(1)此类是public（2）此类提供公共的无参构造器
2）此类中声明单元测试方法：（1）方法权限是public（2）没有返回值，没有形参
单元测试方法上一行需要声明注解：@Test
1）在单元测试类中导入 import org.junit.Test;
2) 鼠标放在Test上，alt + enter 导入junit4 包 这是很重要的一步
写完代码后在需要执行测试方法的地方，右键测试方法名运行

java">package test;

import org.junit.Test;

import java.sql.SQLOutput;
import java.util.Date;

public class JUnityTest {
    @Test
    public void testEquals(){
        String s1 = "MM";
        String s2 = "MM";
        System.out.println(s1);
    }
    @Test
    public void testEquals1(){
        String s1 = "GG";
        String s2 = "GG";
        System.out.println(s1);
    }
}

3、包装类的使用

1）Java提供了8种基本数据类型对应的包装类，使得基本数据类型的变量具有类的特征
2）基本数据类型、包装类、String三者之间的转换重点

基本数据类型与包装类的转换

java">package test;

import org.junit.Test;

public class WrapperTest {
    //基本数据类型-->包装类：调用包装类的构造器
    @Test
    public void test1(){
        int num1 = 10;
        Integer in1 = new Integer(num1);
        System.out.println(in1.toString());

        Integer in2 = new Integer("123"); //这里只能是数字
        System.out.println(in2.toString());

        Order order = new Order();
        System.out.println(order.isMale); //false
        System.out.println(order.isFemale);//null
    }
    //包装类-->基本数据类型：调用包装类的xxxValue()
    @Test
    public void test2(){
        Integer in1 = new Integer(12);
        int i1 = in1.intValue();
        System.out.println(i1); //12

    }
    @Test
    public void test3(){
        int num1 = 10;
        method(num1); //JDK5.0特性：自动装箱与自动拆箱
    }
    public void method (Object obj){
        System.out.println(obj.toString());
    }
}
class Order {
    boolean isMale;
    Boolean isFemale;
}

自动装箱与自动拆箱

基本数据类型–>包装类：自动装箱
包装类–>基本数据类型：自动拆箱

java">int num = 10;
Integer in1 = num;  //自动装箱
int num1 = in1 ; //自动拆箱

基本数据类型、包装类与String转换

java">package test;

import org.junit.Test;

public class WrapperTest {
    //基本数据类型、包装类-->String类型：调用String重载的ValueOf(Xxx xxx)
    @Test
    public void test1() {
        int num1 = 10;
        //方法1：连接运算
        String str1 = num1 + "";
        //方法2：
        float f1 = 12.3f;
        String str = String.valueOf(f1);//"12.3"
        System.out.println(str);
    }
    //String类型-->：基本数据类型、包装类 :调用包装类中的parseXxx(String s)
    @Test
    public void test2() {
        String str1 = "123";
        int num2 = Integer.parseInt(str1);
        String str2 = "TrUe";
        boolean b1 = Boolean.parseBoolean(str2);
        System.out.println(b1); //ture
    }
}

训练题1

当三元运算符中的两个表达式类型不同时，编译器会尝试找到一个共同的类型，以确保结果类型兼容。这通常通过自动类型提升（类型转换）来实现。

java">Object o1 = true ? new Integer(1) : new Double(2.0); //new Integer(1)自动提升为double类型了
System.out.println(o1);//1.0

训练题2

1）Integer内部定义了IntegerCache结构，IntegerCache中定义了Interger[]
2）其保存了从-128~127范围的整数，如果使用自动装箱方式给Integer赋值该范围的数值时，可以直接使用数组中的元素，不必在new一个新的。

java">package test;
import org.junit.Test;
public class WrapperTest {
    @Test
    public void method1() {
        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i == j); //false
        Integer m = 1;
        Integer n = 1;
        System.out.println(m == n);//true
        Integer x = 128;//相当于new了一个Integer对象
        Integer y = 128;//相当于new了一个Integer对象
        System.out.println(x == y);//false
    }
}

4、static

1）static：静态的 可以用来修饰：属性、方法、代码块、内部类
2）使用statci修饰属性： 静态变量(类变量)
  a）属性按是否使用static修饰，分为静态属性与非静态属性(实例变量)
  b）实例变量：我们创建类的多个对象，每个对象都单独拥有一套类的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值发生改变
  c）我们创建类的多个对象，每个对象共享同一个静态变量。当通过某一对象修改静态变量时，会导致其他对象调用此静态变量时，静态变量值是修改后的
  d）静态变量随着类的加载而加载，可以通过"类.静态变量"的方式调用
  e）静态变量的加载要早于对象的创建
  f）由于类只会加载一次，则静态变量在内存中也只会存在一份，存在方法区的静态域中
3）使用statci修饰方法：静态方法
  a）静态方法中，只能调用静态的方法或属性
  b）非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
  c）`注意点：``静态方法内不能使用this、super关键字
4）如何确定一个属性/方法是否要声明static？
a）属性可以被多个对象共享的；
b）操作静态属性的方法，通常设置为static
c）工具类中的方法，习惯上声明为static，比如：Math、Arrays

类变量和实例变量的内存解析

5、单例设计模式

1）对某个类只能存在一个对象实例

饿汉式

java">package test;

import java.sql.SQLOutput;

public class CircleTest {
    public static void main(String[] args) {
    Bank bank1 = Bank.getInstance();
    Bank bank2 = Bank.getInstance();
    System.out.println(bank1==bank2);//返回true
    }
}

class Bank{
    //1. 私有化类的构造器
    private Bank(){

    }
    //2. 内部创建类的对象
    //4. 要求此对象也必须声明为静态的
    private static Bank instance = new Bank();
    //3. 提供公共的方法，返回类的对象
    public static Bank getInstance(){ //static原因是外部不让生成对象，只能类去调
        return instance;//static方法只能操作static属性
    }
}

懒汉式

java">package test;
public class CircleTest {
    public static void main(String[] args) {
        Order order1 = Order.getInstance();
        Order order2 = Order.getInstance();
        System.out.println(order1==order2);
    }
}

class Order{
    //1. 私有化类的构造器
    private Order() {
    }
    //2. 声明当前类的变量,没有初始化
    private static Order instance = null;
    //4. 要求此对象也必须声明为静态的
    //3. 提供公共的方法，返回类的对象
    public static Order getInstance() {
        if (instance == null) {
            instance = new Order();
        }
        return instance;
    }
}

区分饿汉式与懒汉式

饿汉式
1）坏处：对象时间加载过长
2）好处：饿汉式是线程安全的
懒汉式
1）好处：延迟对象的创建
2）坏处：目前写法线程不安全—>多线程再做修改