软件设计之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()方法

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 包 这是很重要的一步
写完代码后在需要执行测试方法的地方，右键测试方法名运行

package test;import org.junit.Test;import java.sql.SQLOutput;
import java.util.Date;public class JUnityTest {@Testpublic void testEquals(){String s1 = "MM";String s2 = "MM";System.out.println(s1);}@Testpublic void testEquals1(){String s1 = "GG";String s2 = "GG";System.out.println(s1);}
}

3、包装类的使用

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

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

package test;import org.junit.Test;public class WrapperTest {//基本数据类型-->包装类：调用包装类的构造器@Testpublic 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); //falseSystem.out.println(order.isFemale);//null}//包装类-->基本数据类型：调用包装类的xxxValue()@Testpublic void test2(){Integer in1 = new Integer(12);int i1 = in1.intValue();System.out.println(i1); //12}@Testpublic 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;
}

自动装箱与自动拆箱

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

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

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

package test;import org.junit.Test;public class WrapperTest {//基本数据类型、包装类-->String类型：调用String重载的ValueOf(Xxx xxx)@Testpublic 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)@Testpublic void test2() {String str1 = "123";int num2 = Integer.parseInt(str1);String str2 = "TrUe";boolean b1 = Boolean.parseBoolean(str2);System.out.println(b1); //ture}
}

训练题1

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

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一个新的。

package test;
import org.junit.Test;
public class WrapperTest {@Testpublic void method1() {Integer i = new Integer(1);Integer j = new Integer(1);System.out.println(i == j); //falseInteger m = 1;Integer n = 1;System.out.println(m == n);//trueInteger 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）对某个类只能存在一个对象实例

饿汉式

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属性}
}

懒汉式

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）坏处：目前写法线程不安全—>多线程再做修改