Java学习从入学到放弃，第6天（预热）

目录

一、二进制与十进制相互转换

二、 static 静态的 全局的

三、单元测试 JUnit

1. 概念

2. 单元测试的优点

四、循环，嵌套循环

---

一、二进制与十进制相互转换

##### 十进制 转 二进制 【128 转 1000 0000】 #####

2       128  0  # 128/2 商=64 余数=0
2    64   0  # 64/2  商=32 余数=0
    32   0
    16   0

    8    0
    4    0
    2    0  # 2/2   商=1 余数=0
2    1    1  # 1/2   商=0 余数=1    
    0
二进制结果：余数从低到高 依次打印为 1000 0000

##### 二进制 转 十进制 【1000 0000 转 128】 #####
#从右往左开始计算
   1000 0000
左<---------右 
0 * 2^0 = 0*1 = 0
0 * 2^1 = 0*2 = 0
0 * 2^2 = 0*4 = 0
0 * 2^3 = 0*8 = 0

0 * 2^4 = 0*16 = 0
0 * 2^5 = 0*32 = 0
0 * 2^6 = 0*64 = 0
1 * 2^7 = 1*128 = 128

十进制结果(即所有结果相加)：128+0+0+0……+0=128

例如：

17 转二进制  0001 0001
1010 转十进制 10

二、 static 静态的 全局的

1.
     * 
     * static可以修饰变量 称为 静态变量
     * static可以修饰方法 称为 静态方法
     * 
     * static关键字修饰的资源（变量和方法），可以通过类名直接调用，不需要创建对象调用
     * static修饰的资源作用于这个类，他被这个类的所有对象可见
     * 
     * static声明的资源 只加载一次

 

2. jvm的类加载顺序
         * static > new > constructor(构造方法)

3. 继承 只能单亲继承，一个类只能继承一个父类

public class Son extends Father {

    String type;
    
    public Son() {
        System.out.println("son-->构造方法");
    }

    public static void main(String[] args) {
        Son s = new Son();
        
        /**
         * 子类继承父类
         * 创建子类的 对象 问你：子类和父类的构造方法的加载顺序
         * 
         */
        
    }
}

子类和父类的构造方法的加载顺序

父类 > 子类

三、单元测试 JUnit

打开eclipse，在项目上右键，点击build path-->add libraaies。

1. 概念

java单元测试是最小的功能单元测试代码, 单元测试就是针对单个java方法的测试

java程序的最小功能单元是方法

2. 单元测试的优点

• main方法进行测试的缺点:

  • 只能有一个main()方法, 不能把测试代码分离出来
  • 无法打印出测试结果和期望结果.例如: expected: 3628800, but actual: 123456

• 单元测试的优点:

  • 确保单个方法正常运行
  • 如果修改了方法代码, 只需要保其对应的单元测试通过就可以了
  • 测试代码本省就可以作为示例代码
  • 可以自动化运行所有测试并获得报告

四、循环，嵌套循环

for (int i = 0; i < 10; i++) {
			System.out.print(i + 1);
			for (int j = 0; j < 5; j++) {
				System.out.print("*");//print是不换行打印
			}
			System.out.println();//println是换行打印


//输出如下：

1*****
2*****
3*****
4*****
5*****
6*****
7*****
8*****
9*****
10*****

 

嵌套循环，外围循环执行一次，内部循环执行一遍。

int t = 5;
		for (int i = 0; i < t; i++) {
			int length = i * 2 + 1;
			int size = t - i;
			for (int k = 0; k < size; k++) {
				System.out.print(" ");
			}
			for (int j = 0; j < length; j++) {
				System.out.print("*");
			}
			System.out.println();
		}

//输出结果：

     *
    ***
   *****
  *******
 *********

 

        int t = 5;
		for (int i = 0; i < t; i++) {
			int length = i * 2 + 1;
			int size = t - i;
			for (int k = 0; k < size; k++) {
				System.out.print(" ");
			}
			for (int j = 0; j < length; j++) {
				System.out.print("*");
			}
			System.out.println();
		}
		int x = 4;
		for (int i = 0; i < x; i++) {
			for (int j = 0; j < x; j++) {
				System.out.print(" ");
			}
			System.out.println("***");
		}



//输出结果：

     *
    ***
   *****
  *******
 *********
    ***
    ***
    ***
    ***

 

//输出2000-2020之间的闰年
		for (int i = 2000; i <= 2020; i++) {
			//能被100整除并且能被400整除
			if (i % 100 == 0 && i % 400 == 0) {
				System.out.println(i + "是闰年");
			} 
			//能被4整除
			else if(i % 4 == 0){
				System.out.println(i + "是闰年");
			}
		}