进制/面向对象

二进制

byte类型

 

十六进制

二进制4,可以表示一个十六进制数字

8位可以用两个16进制数字表示

用十六进制可以方便表示一个字节值

 

年月中的天数

package day0601;

 

import java.util.Scanner;

 

public class Test1 {

    public static void main(String[] args) {

        System.out.print("年");

        int y = new Scanner(System.in).nextInt();

        System.out.println("月");

        int m = new Scanner(System.in).nextInt();

 

        int days = f(y, m);

        System.out.println(days);

    }

 

    private static int f(int y, int m) {

        int r = 0;

 

        switch (m) {

            case 1:

            case 3:

            case 5:

            case 7:

            case 9:

            case 11:

                r = 31;

                break;

            case 4:

            case 6:

            case 8:

            case 10:

            case 12:

                r = 30;

                break;

            case 2:

                if (y % 4 == 0 && y % 100 != 0 || y % 400 == 0) {

                    r = 29;

                } else {

                    r = 28;

                }

        }

        return r;

 

    }

}

有序数组并归

package day0602;

 

import java.util.Arrays;

import java.util.Random;

 

public class Test1 {

    public static void main(String[] args) {

        int[] a = suiji();

        int[] b = suiji();

 

        Arrays.sort(a);

        Arrays.sort(b);

        System.out.println(Arrays.toString(a));

        System.out.println(Arrays.toString(b));

 

        int[] c = hebing(a, b);

        System.out.println(Arrays.toString(c));

    }

 

    private static int[] hebing(int[] a, int[] b) {

        int[] c = new int[a.length + b.length];

        for (int i = 0, j = 0, k = 0; i < c.length; i++) {

            if(j==a.length)

            {

//                c[i] = b[k];

//                k++;

//                continue;

                System.arraycopy(b,k,c,i,b.length-k);

                break;

            }else if(k==b.length) {

//                c[i] = a[j];

//                j++;

//                continue;

                System.arraycopy(a,j,c,i,a.length-j);

                break;

            }

            if (a[j] > b[k]) {

                c[i] = b[k];

                k++;

            } else {

                c[i] = a[j];

                j++;

            }

        }

        return c;

    }

 

    private static int[] suiji() {

        int n = new Random().nextInt(6) + 5;

        int[] result = new int[n];

        for (int i = 0; i < n; i++) {

            result[i] = new Random().nextInt(99) + 1;

        }

        return result;

    }

}

 

 

面向对象
人为抽象的编程模型

把复杂问题分解成一个个的小问题,通过解决每个小问题,从而解决复杂问题

 

对象

引用

构造方法

This

重载

继承

Supper

多态

Instanceof

Final

Static

常量

访问控制符

对象创建过程

访问控制符

接口

内部类

 

对事物\算法\逻辑\概念的抽象

把相关的数据\逻辑运算代码封装成一个类组件

,理解成模板\图纸

类是一个抽象的定义

 

对象

丛类创建的具体实例

一个对象,占用独立的内存空间,来保存自己的属性数据

每个对象都可以独立控制执行指定方法的代码

 

引用

引用变量,保存一个对象的内存地址

用引用变量,可以找到一个对象的内存空间,来访问他的属性或控制他执行指定方法

 

引用变量的特殊值null,不保存任何对象的地址

 

士兵

package day0603;



import java.util.Random;



public class Soldier {

    public int id;

    public int blood = 100;



    public Soldier(int id) {

        this.id = id;

    }



    public Soldier(){

        System.out.println("构造方法");

    }



    public void go()

    {

        System.out.println(id+"号 士兵前进");

    }



    public void ac()

    {

        if(blood == 0){

            System.out.println(id+"号士兵已经阵亡");

            return;

        }

        System.out.println(id+"号 士兵进攻");

        int d = new Random().nextInt(10);

        this.blood -= d;

        if(this.blood < 0 ) this.blood = 0;

        System.out.println("血量:"+blood);

        if (blood == 0) System.out.println(id+"号 士兵阵亡");

    }

}



package day0603;



public class Test1 {

    public static void main(String[] args) {

        Soldier s1 = new Soldier();

        Soldier s2 = new Soldier();



        System.out.println(s1);

        System.out.println(s2);



        s1.id = 9527;

        s2.id = 9528;



        s1.go();

        s2.go();



        s2.ac();

        s2.ac();

        s2.ac();

        s2.ac();

        s2.ac();

    }

}