java学习代码一（01-50）

约德尔535

已于 2024-09-27 18:11:46 修改

阅读量388

点赞数 3

文章标签： java 学习 python

于 2024-09-07 20:49:53 首次发布

本文链接：https://blog.csdn.net/qq_62150460/article/details/140813731

版权

01.变量的使用

描述：输出个人信息

public class changeobject {
    public static void main(String args[]) {
        //定义个人信息
        String name = "king";
        int age = 25;
        char gender = '男';
        int height = 185;
        //输出个人信息
        System.out.println("个人信息为:");
        System.out.println(name);
        System.out.println(age);
        System.out.println(gender);
        System.out.println(height);
    }
}

02.字符串转换成整数

描述：给出一个字符串，提取所有字符，转换成int类型，最后拼凑成一个整数

03.求三个数中最大值

描述：使用三元运算符求最大值

public class three {
    public static void main(String[] args) {
        //需求：找到三个数中最大值
        int a=1,b=2,c=3;
        int max1 = a>b?a:b;
        int max2 = max1>c?max1:c;
        System.out.println(max2);
        //简写
        int max = (a>b?a:b)>c?(a>b?a:b):c;
        System.out.println(max);
    }
}

04.分数是否合格

描述：对学生成绩大于60分的，输出“合格”，低于60分的，输出"不合格"。输入的成绩不能大于100

import java.util.Scanner;
public class switch_exam2 {
    public static void main(String[] args) {
        Scanner myscan = new Scanner(System.in);
        System.out.println("请输入一个1-99的分数");
        int temp = myscan.nextInt();
       //用if-else完成
     /*   if(temp >= 60 && temp <=99 ){
            System.out.println("合格");
        }else if(temp >=1 && temp <60){
            System.out.println("不合格");
        }else{
            System.out.println("分数不合法");
        }*/
        //用switch完成 用 分数/60,分数>60，则为1   分数<60 则为0
        if(temp >= 1 && temp <100){
            switch((int)temp/60){
                case 1:
                    System.out.println("合格");
                    break;
                case 0:
                    System.out.println("不合格");
                    break;
                default:
                    System.out.println("分数不合法");
                    break;
            }
        }else{
            System.out.println("分数不合法");
        }
    }
}

05.金字塔图形

/**
 * 接受一个整数，表示层数，打印出金字塔
 * */
import javax.swing.plaf.basic.BasicInternalFrameTitlePane;
import java.util.Scanner;
public class pyramid {
    public static void main(String[] args) {
        Scanner myscan = new Scanner(System.in);
        System.out.println("请输入金字塔层数");
        int num = myscan.nextInt();
        //半边金字塔
        for (int i =1;i<=num;i++){
            for (int j=1;j<=i;j++){
                System.out.print("*");
            }
            System.out.println();
        }
        //全金字塔
        for (int i =1;i<=num;i++){
            //输出空行
            for (int j=1;j<=num-i;j++){
                System.out.print(" ");
            }
            //输出星星
            for (int q=1;q<=2*i-1;q++){
                System.out.print("*");
            }
            //输出换行符
            System.out.println();
        }
        //空心金字塔 输出空格，当 列数=行数 或 列数=num-行数 时输出星星
       /*
            *                   1个*   4个空格
           * *                  2个*   3个空格
          *   *                 2个*   2个空格
         *     *                2个*   1个空格
        *********               9个*   0个空格  星星在第一个位置和最后一个位置

       * */
        for(int i=1;i<=num;i++){
            //空格
            for(int j = 1;j<=num-i;j++){
                System.out.print(" ");
            }
            //星星
            for(int j=1;j<=2*i-1;j++){
                if(j==1 || j==2*i-1 || i==num){
                    System.out.print("*");
                }else {
                    System.out.print(" ");
                }
            }
            //换行
            System.out.println();
        }
        /*
        * 空心棱形
    1          *                    5个空格 1个*
    2         * *                   4个空格 2个*  一个在第一位，一个在最后一位
    3        *   *                  3个空格 2个*
    4       *     *                 2个空格 2个*
    5      *       *                1个空格 2个*
    6     *         *               0个空格 2个*         逐级递减
    7      *       *                第7行对应第5行，2*6-7=5                   
    8       *     *                 第8行对应第4行，2*6-8=4
    9        *   *                    ...
    10        * *                    得到对应公式，2*num - 上部分 = 下部分对应层数
    11         *
        *  */
        for(int i=1;i<=2*num-1;i++){
            if(i<=num) { //上半部分
                //空格
                for (int j = 1; j <= num - i; j++) {
                    System.out.print(" ");
                }
                //星星
                for(int j=1;j<=2*i-1;j++){
                    if(j==1 || j==2*i-1){
                        System.out.print("*");
                    }else {
                        System.out.print(" ");
                    }
                }
            }else{//下半部分
                //空格
                for (int j = 1; j <= i-num; j++) {
                    System.out.print(" ");
                }
                //星星 
                for(int j=1;j<=2*(2*num-i)-1;j++){
                    if(j==1 || j==2*(2*num-i)-1){
                        System.out.print("*");
                    }else {
                        System.out.print(" ");
                    }
                }
            }
            //换行
            System.out.println();
        }
    }
}

06.数组扩容

/**
 * 需求：静态分配一个数组 int[] arr1 = {1,2,3}
 * 增加元素4，直接放在数组最后 arr1 = {1,2,3,4}
 *
 * 分析：
 * 1）创建一个新数组arr2，开辟空间大小为 arr1长度+1，即arr1.length+1
 * 2）使用for循环将arr1中元素赋值給arr2
 * 3）把新元素值放在arr2数组最后一个位置，即arr2[length-1]
 * 4）使用while循环，让用户可以续杯或者结束
 * */
import java.util.Scanner;
public class array_7 {
    public static void main(String[] args) {
        Scanner myscan = new Scanner(System.in);
        int[] arr1 = {1,2,3};
        while(true){
            System.out.println("是否扩容y/n");
            char flag = myscan.next().charAt(0);
            switch (flag){
                case 'y':   //进行扩容
                    //扩容
                    System.out.println("请输入要扩容的元素");
                    int num = myscan.nextInt();
                    int[] arr2 = new int[arr1.length+1];
                    for (int i = 0;i<=arr1.length-1;i++){
                        arr2[i] = arr1[i];
                    }
                    arr2[arr2.length-1] = num;
                    //原数组指向新数组
                    arr1 = arr2;
                    //输出
                    for (int i = 0;i<=arr1.length-1;i++){
                        System.out.print(arr1[i]+" ");
                    }
                    System.out.println();
                    break;
                case 'n':
                    return;
                default:
                    System.out.println("输入错误");
                    break;
            }
        }
    }
}

07.冒泡排序

/*
* 需求：冒泡排序
* 分析：{1,2,3,4,5}，从左到右递减排列
* 第一轮
*  第一次 1和2比较，并交换位置 {2,1,3,4,5}
*  第二次 1和3比较，并交换位置 {2,3,1,4,5}
*  第三次 1和4比较，并交换位置 {2,3,4,1,5}
*  第四次 1和5比较，并交换位置 {2,3,4,5,1}
* 第二轮 1已经在最右边，则只需要比较三次
*  第一次 2和3比较，并交换位置 {3,2,4,5,1}
*  第二次 2和4比较，并交换位置 {3,4，2,5,1}
*  第三次 2和5比较，并交换位置 {3,4,5,2,1}
* 第三轮 比较两次
*  {4,5,3,2,1}
* 第四轮 比较一次
*  {5,4,3,2,1}
*
* 简化：
*   1)需要进行length-1轮，每一轮进行length-轮数 次
*   2)每一次都是j和j+1进行比较
* */
public class array_8_bubble {
    public static void main(String[] args) {
        int[] arr = {1,4,3,2,5};
        for (int i = 0;i<=arr.length-1-1;i++){  //每一轮 因为数组下标从0开始，需要-1
            for (int j = 0;j<= arr.length-i-1-1;j++) {  //每一次 因为数组下标从0开始，需要-1
                if(arr[j]<arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        //输出
        for (int i =0;i<=arr.length-1;i++){
            System.out.print(arr[i]+" ");
        }
    }
}

08.二维数组遍历

/*
* 需求：int arr[][] ={{4,6},{1,4,5,7},{-2}}，遍历该数组，并求和
* 分析：
* 1）该数组为二维数组，一共有arr.length组，每组各有arr[i].length个元素。（0<=i<=arr.length-1）
* 2)使用for循环两层嵌套，i代表组数，i=0，i<=arr.length-1，j代表元素个数，j=0,j<=arr[i].length-1
* */
public class secondArray_1 {
    public static void main(String[] args) {
        int arr[][] = {{4,6},{1,4,5,7},{-2}};
        int sum = 0;    //储存数组之和
        for (int i = 0;i<=arr.length-1;i++){
            for(int j = 0;j<=arr[i].length-1;j++){
                sum += arr[i][j];
                System.out.print(arr[i][j]+" ");
            }
        }
        System.out.println();
        System.out.println("数组之和为："+sum);
    }

}

09.杨辉三角（二维数组）

/*
* 需求：使用打印一个10行的杨辉三角
* 1
* 1 1
* 1 2 1
* 1 3 3 1
* 1 4 6 4 1
* 1 5 10 10 5 1
* ...
* 分析：
* 1）第一行有一个元素，第n行有n个元素
* 2）每一行第一个元素和最后一个元素都是1
* 3）从第三行开始，除了第一个和最后一个元素，所有的元素都等于上方同一列数加上其左侧数的和
*   arr[i][j] = arr[i-1][j] + arr[i-1][j-1]
* */
public class yanghuisanjiao {
    public static void main(String[] args) {
        int[][] arr = new int[10][];    //給二维数组开辟空间
        for(int i = 0;i<=arr.length-1;i++){
            //给一维数组开辟空间
            arr[i] = new int[i+1];
            for(int j = 0;j<=arr[i].length-1;j++){    //元素个数与行数相同
                if(j==0 || j==arr[i].length-1){       //第一位和最后一位
                    arr[i][j] = 1;
           } else{
                    arr[i][j] = arr[i-1][j] + arr[i-1][j-1];
                }
            }
        }
        //输出
        for(int i = 0;i<=arr.length-1;i++) {
            for (int j = 0; j <= i; j++) {
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

10.升序数组插入元素

/*
* 需求：已知一个升序的数组，要求插入一个元素，该数组顺序依然是升序
*{10，12,45,90} 添加23
*
* 分析：
* 1）从左至右遍历数组arr，将num与其元素一一比较，当第一次arr[i]>num时，返回其下标 index
* 2）扩容数组
* 3）从下标arr.length-2 到 index 向右移动一位
*  arr[i+1] = arr[i]
* 4)赋值num給下标index所在位置
* */
public class secondArr_2 {
    public static void main(String[] args) {
        int num = -524;
        int[] arr = {10,12,45,90};
        int index = -1;
        //01.定位 如果num不为最大，则会定义需要插入的位置，如果num为最大，则index变量不会变化
        for(int i = 0;i<=arr.length-1;i++){
            if(arr[i] > num) {
                index = i;
                break;
            }
        }
        //02.扩容
        int[] arr_temp = new int[arr.length+1];
        for (int i = 0;i<=arr.length-1;i++){
            arr_temp[i] = arr[i];
        }
        arr = arr_temp;
        //03.移位
        if(index != -1){  //如果nun最大，则不需要移位
            for (int i =arr.length-2;i>=index;i--){
                arr[i+1] = arr[i];
            }
        }
        //04.赋值
        if(index == -1){    //当index==-1，这代表要插入的元素是最大的
            arr[arr.length-1] = num;
        }else{
            arr[index] = num;
        }
        //05.输出
        for(int i = 0;i<=arr.length-1;i++){
            System.out.print(arr[i]+"\t");
        }
    }
}

11.随机数数组的处理

/*
* 需求：随机生成10个整数（1-100）保存到数组，并倒序打印，求平均值，求最大值和最小值下标，并查找是否存在元素 8
* 分析：
*   1）获取数组，循环10次
*   2）排序，使用冒泡排序进行排序，从左往右递减
*   3）边遍历打印，边获取平均值，最大值，最小值下标，检测元素8
* */
public class secondArr_3 {
    public static void main(String[] args) {
        int[] arr = new int[10];
        int sum = 0;    //和
        int min_index = 0; //最小值下标
        int max_index = 0; //最大值下标
        int flag = 0;       //检测是否有元素8，当检测到时，flag = 1
        //01.获取数组
        for (int i  = 0;i<=arr.length-1;i++){
            arr[i] = (int)(Math.random()*100+1);
        }
        //02.冒泡排序
        for(int i = 0;i<= arr.length-2;i++){
            for(int j = 0;j<=arr.length-i-2;j++){
                if(arr[j] < arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        //03.遍历数组，边打印数组元素，边边获取平均值，最大值，最小值下标，检测元素8
        for (int i  = 0;i<=arr.length-1;i++){
            sum += arr[i];
            if(arr[i]>arr[max_index]){max_index = i;}
            if(arr[i]<arr[min_index]){min_index = i;}
            if(arr[i] == 8){flag = 1;}
            System.out.print(arr[i]+"\t");
        }
        System.out.println();
        System.out.println("平均值："+sum/arr.length+"  最大值下标："+max_index+"  最小值下标："+min_index);
        if(flag == 1){System.out.print("数组中有元素8");}else{System.out.print("数组中没有有元素8");}
    }
}

12.对象的成员方法使用

public class method_1 {
    public static void main(String[] args) {
        //方法的使用：
        //1.方法写好后，如果不去调用，不会输出
        //2.先创建对象，然后调用其方法
        //3.调用方法时，在方法的（）中写入的参数叫做实参（实际参数）
        Person zhangSan = new Person();
        zhangSan.speak();
        int sum = zhangSan.getSum(10,20);
        System.out.println(sum);
    }
}

class Person{
    String name;
    int age;
    //方法（成员方法）
    //添加speak 成员方法，输出“我是一个好人”
    //解读：
    //1. public ： 表示方法是公开的
    //2. void ： 表示方法没有返回值
    //3.speak() ： speak是方法名，（）是形参列表
    //4.{} 是方法体，可以写要执行的代码
    //5. System.out.println("我是一个好人"); 表示方法是输出一句话
    public void speak(){
        System.out.println("我是一个好人");
    }
    //添加getSum方法，计算两个数的和并返回
    //1. int ：表示方法执行后，返回一个 int 值
    //2.（int num1，int num2）表示可以接受两个参数，这里的参数称之为形参（形式参数）
    //3.return 表示返回值給调用该方法的位置
    public int getSum(int num1,int num2){
        return num1 + num2;
    }
}

13.递归实现阶乘

/*
* 需求：编写Method2类，创建factorial方法，使用递归实现1-10的阶乘
* */
public class recursion2 {
    public static void main(String[] args) {
        Method2 m1 = new Method2();
        System.out.print(m1.factorial(10));
    }
}

class Method2{
    public int factorial(int i){
        if(i == 1){     //递归出口
            return 1;
        }else{      //递归语句
            return i*factorial(i-1);
        }
    }
}

14.递归实现斐波那契数列

/*
* 需求：使用递归实现斐波那契数列
* 分析：
* 1）数列 1 1 2 3 5 8 13 21 ...
* 2）从第三个数开始，每个数等于前两个数之和；第一个数和第二个数都是 1
* 3）递归规律是 fun(i) = fun(i-1) + fun(i-2)
* */
public class recursion3 {
    public static void main(String[] args) {
        Method3 m1 = new Method3();
        System.out.print(m1.fibonacci(8));
    }
}

class Method3{
    public int fibonacci(int i){
        if(i == 1 || i == 2){
            return 1;
        }else{
            return fibonacci(i-1) + fibonacci(i-2);
        }
    }
}

15.猴子吃桃

public class recursion3 {
    public static void main(String[] args) {
        System.out.println(m1.monkey(1));
    }
}

class Method3{
    /*
    * 需求：猴子吃桃问题，有一堆桃子，猴子第一天吃了其中的一半，并再多吃一个，
    * 以后每天都吃其中的一半，并再多吃一个
    * 当第十天还没吃，就发现还剩一个
    * 问最初有几个
    *
    * 分析：
    * 1）递归问题 当day = 10时，return 1
    * 2）方法名为monkey(int day)
    * 3)除了第十天，每一天的桃子数 = (monkey(day+1)+1)*2
    * */
    public int monkey(int day){
        if(day == 10){
            return 1;
        }else{ 
            return (monkey(day+1)+1)*2;
        }
    }
}

16.老鼠走迷宫

/*
 * 需求：用二维数组创建一个8行7列的迷宫，使用递归实现走迷宫
 * */
public class recursion_maze {
    public static void main(String[] args) {
        //01创建迷宫
        /*
         * 迷宫8行7列，0代表可以走，1表示障碍物
         * 1 1 1 1 1 1 1
         * 1 0 0 0 0 0 1
         * 1 0 0 0 0 0 1
         * 1 1 1 0 0 0 1
         * 1 0 0 0 0 0 1
         * 1 0 0 0 0 0 1
         * 1 0 0 0 0 0 1
         * 1 1 1 1 1 1 1
         * 老鼠的初始位置为[1][1]，终点是[6][5]
         * */
        int[][] map = new int[8][7];
        for(int i = 0;i<7;i++){
            map[0][i] = 1;
            map[7][i] = 1;
        }
        for (int i = 1;i<7;i++){
            map[i][0] = 1;
            map[i][6] = 1;
        }
        map[3][2] = 1;
        map[3][1] = 1;
        //开始走迷宫
        M m1 = new M();
        m1.findWay(map,1,1);
        //地图输出
        for (int i = 0;i<map.length;i++){
            for(int j = 0;j<map[i].length;j++){
                System.out.print(map[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

class M {
    //使用递归回溯的思想来解决老鼠出迷宫
    //分析
    //1.findWay方法用来寻找出迷宫的路径
    //2.如果找到，就返回true，否则返回false
    //3.map 就是二维数组，即迷宫
    //4.i,j是老鼠的位置，初始化的位置为（1,1）
    //5.因为递归寻路，所以先规定map数组各个值的含义
    //  0 表示可以走 1 表示障碍物  2 表示可以走  3 表示走过但是死路
    //6.当终点[6][5] = 2 时，说明到达终点
    //7.寻路策略 上->右->下->左
    public boolean findWay(int[][] map,int i,int j){
        if(map[6][5] == 2){     //说明已经找到
            return true;
        }else{
            if(map[i][j] == 0){//当前这个位置0，表示可以走
                //假定可以走通
                map[i][j] = 2;
                //使用找路策略，来确定该位置是否可以走通
                //下->右->上->左
                if(findWay(map,i + 1,j)){   //向下走
                    return true;
                } else if(findWay(map,i,j + 1)){   //向右走
                    return true;
                } else if(findWay(map,i - 1,j)){   //向上走
                    return true;
                } else if(findWay(map,i,j - 1)){   //向左走
                    return true;
                }else{
                    map[i][j] = 3;
                    return false;
                }
            }else{  //map[i][j] = 1,2,3
                return false;
            }
        }
    }
}

17.方法重载例题

public class kebiancanshu {
    public static void main(String[] args) {
        HspMethod m = new HspMethod();
        //sum方法
        System.out.println(m.sum(1,2,4,5));
        System.out.println(m.sum(1,2));
        //arrPrint方法
        m.arrPrint(new int[]{1,2,3},new int[]{4,5,6});
        //sum的方法重载
        System.out.println(m.sum(1.7,5,8,7,6));
    }
}

class HspMethod{
    //创建一个sum方法，已接收2个、3个、4个、n个参数，并求和
    //分析：
    //1） int... 表示这是可变参数，类型是int，可以接受0-多个参数
    //2） 使用可变参数时，可以当做数组使用
    public int sum(int... para){
        int sum = 0;
        for(int i = 0;i < para.length;i++){
            sum += para[i];
        }
        return sum;
    }
    //创建一个arrPrint方法，可以接受n个int数组参数，并输出
    public void arrPrint(int[]... para){
        for(int i = 0;i<para.length;i++){
            for(int j = 0;j<para[i].length;j++){
                System.out.print(para[i][j]+" ");
            }
            System.out.println();
        }
    }
    //创建一个sum的重载方法，可以接受一个double类型，n个int类型参数，并求和
    public double sum(double para1,int... para2){
        double sum = para1;
        for (int i = 0;i<para2.length;i++){
            sum += para2[i];
        }
        return sum;
    }
}

18.可变参数例题

public class kebiancanshu {
    public static void main(String[] args) {
        HspMethod m = new HspMethod();
        System.out.println(m.sum(1,2,4,5));
        System.out.println(m.sum(1,2));
    }
}

class HspMethod{
    //创建一个sum方法，已接收2个、3个、4个、n个参数，并求和
    //分析：
    //1） int... 表示这是可变参数，类型是int，可以接受0-多个参数
    //2） 使用可变参数时，可以当做数组使用
    public int sum(int... para){
        int sum = 0;
        for(int i = 0;i < para.length;i++){
            sum += para[i];
        }
        return sum;
    }
}

18.作用域例题

public class scop {
    public static void main(String[] args) {
        P p = new P();
        p.speak();
    }
}

class P {
    String name = "Jack";
    public void speak(){
        //可以同时存在局部变量name和属性name，
        //当调用时，先调用最近的局部变量name，如果不存在局部变量name，则调用属性name
        String name = "King";
        System.out.println(name);   //输出King
    }
}

19.构造器例题

public class constructor {
    public static void main(String[] args) {
        //当new Person4(18)被执行时，对象会被创建，然后执行构造器中语句
        Person4 p = new Person4(18);    //此时age->18
        Person4 p2 = new Person4(15,"王");
        Person4 p3 = new Person4("李",23);
        p.speak_age();
    }
}

class Person4{
    int age;
    String name;
    //创建一个构造器，当Person4实例化时，自动将age设置为18
    public Person4(int age){
    //this关键字指代当前对象，this.age表示属性，age表示局部变量
        this.age = age;
    }
    //构造器2 自动设置name属性
    public Person4(String name){
        this.name = name;
    }
    //构造器3 4 自动设置age属性 和 name属性
    public Person4(int age,String name){
        this.name = name;
        this.age = age;
    }
    public Person4(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void speak_age(){
        System.out.println("我的年龄是"+age);
    }
}

20.类相关的学习题目总结

import java.text.DecimalFormat;
import java.util.Scanner;

public class object_work1 {
    public static void main(String[] args) {
        //需求01
        A01 a = new A01();
        double[] arr = {1,2,3,4,5,87,21,524};
        System.out.println(a.max(arr));
        //需求02
        A02 a2 = new A02();
        char[] arr_char = {'a','b','c','d'};
        System.out.println(a2.find(arr_char,'c'));
        //需求03
        //假设两本书，一本185.45，一本100.21
        Book book1 = new Book(84.45);
        Book book2 = new Book(100.21);
        book1.updatePrice(book2);
        System.out.println(book2.price);
        //需求05
        Circle c = new Circle(5);
        c.showPerimeter();
        c.showArea();
        //需求06
        Cale c1 = new Cale(54,12);
        Cale c2 = new Cale(0,7);
        c2.quot();
        System.out.println(c1.mult());
        //需求07
         Dog d = new Dog(4,"wangCai","black");
         d.show();
         //需求09
        Music m1 = new Music("《大风吹》",2.12);
        m1.play();
        String[] temp = m1.show();
        System.out.println( "音乐的名字为："+temp[0]+"音乐的总时长为："+Double.parseDouble(temp[1]));
        //需求12
        Employee e1 = new Employee("zhang","m",23);
        //需求13
        PassObject po = new PassObject();
        Circle2 c3 = new Circle2();
        po.printAreas(c3,5);
        System.out.println("当前半径为"+c3.radius);
        //需求14
        Tom tom = new Tom();
        tom.fingerGuessing();
    }
}
//需求01：编写类A01，定义方法max，实现求某个double数组的最大值
class A01{
    public double max(double[] arr){
        int max_index = 0;
        for (int i = 1;i<arr.length;i++){
            if(arr[i] > arr[max_index]){
                max_index = i;
            }
        }
        return arr[max_index];
    }
}
//需求02：编写类A02，定义方法find，实现查找某字符串数组中的元素，返回索引，找不到返回-1
class A02{
    public int find(char[] arr,char para){
        for(int i = 0;i<arr.length;i++){
            if(arr[i] == para){
                return i;
            }
        }
        return -1;
    }
}
//需求03：编写类Book，定义方法updatePrice，实现更改某本书的价格，
//如果价格>150，则修改为150；如果价格>100，则修改为100,否则不变
class Book{
    double price;
    Book(double price){
        this.price = price;
    }
    public void updatePrice(Book book){
        if(book.price>150){
            book.price = 150;
        }else if(book.price>100){
            book.price = 100;
        }
    }
}
//需求04：编写类A03，定义方法copyArr，实现 输入旧数组，返回新数组，元素和旧数组一样
class A03{
    public int[] copyArr(int[] arrOld){
        int[] arrNew = new int[arrOld.length];
        for (int i = 0; i < arrOld.length; i++) {
            arrNew[i] = arrOld[i];
        }
        return arrNew;
    }
}
//需求05：定义一个圆类Circle，定义属性 半径、显示周长的方法，提供面积的方法
class Circle {
    Circle(int radius){
        this.radius = radius;
    }
    int radius;
    public void showPerimeter(){
        //DecimalFormat类的format()方法可以格式化浮点数小数点后个数
        DecimalFormat df = new DecimalFormat("0.00");
        System.out.println("周长为"+df.format(radius*2*3.14));
    }
    public void showArea(){
        System.out.println("面积为"+radius*radius*3.14);
    }
}
//需求06:变成一个Cale计算类，
// 1）在其中定义个两个变量表示两个操作数，
// 2）定义四个方法实现和、差、乘、商（被除数为0的话，要提示，
// 3）并创建两个对象进行提示）
class Cale {
    int paraA;
    int paraB;
    public Cale(int paraA,int paraB){
        this.paraA = paraA;
        this.paraB = paraB;
    }
    public double sum(){
        return paraA + paraB;
    }
    public double diff(){
        return paraA - paraB;
    }
    public double mult(){
        return paraA * paraB;
    }
    public double quot(){
        if(paraA == 0){System.out.println("被除数不能为0"); return 0.0;}
        return paraA / paraB;
    }
}
//需求07.设计一个Dog类，有名字、颜色、年龄属性，定义输出方法show()显示其属性
class Dog {
    String name;
    String color;
    int age;
    Dog (int age,String name,String color) {
        this.age = age;
        this.name = name;
        this.color = color;
    }
    public void show(){
        System.out.println("狗狗的名字叫："+name+"，年龄："+age+"，颜色为："+color);
    }
}
//需求09：定义Music类，里面有音乐名name，音乐时长times属性，
//并有播放功能play()和返回本身属性信息功能show()
class Music{
    String name;
    double times;
    Music (String name,double times){
        this.name = name;
        this.times =times;
    }
    public void play(){
        System.out.println("---==正在播放音乐==---");
    }
    public String[] show(){ //将两个属性转换成String数组返回
        String times_str = times +"";
        String[] temp = {name,times_str};
        return temp;
    }
}

//需求12 创建一个Employee类，
// 1）属性有（名字、性别、年龄、职位、薪水）
// 2）构造方法 1.初始化（名字，性别，年龄，职位，薪水）
//            2.初始化（名字，性别，年龄） 3.（职位，薪水）
class Employee {
    String name,gender,position;
    int age;
    double salary;
    //1.初始化（名字，性别，年龄，职位，薪水）
    Employee(String name,String gender,int age,String position,double salary){
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.position = position;
        this.salary = salary;
    }
    //2.初始化（名字，性别，年龄）
    Employee(String name,String gender,int age){
        this.name = name;
        this.gender = gender;
        this.age = age;
    }
    //3.初始化 (职位，薪水）
    Employee(String position,double salary){
        this.position = position;
        this.salary = salary;
    }
}
//需求13：将对象作为参数传递给方法
//题目要求
//（1）定义一个Circle2类，包含一个double型的radius属性代表半径，一个findArea()方法，返回圆面积
//（2）定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义如下：
//public void printAreas(Circle2 c,int times)
//（3）在printAreas方法中打印输出1到times之间的每个整数半径值，以及对应的面积
//（4）在main方法中调用printAreas()方法，调用完毕后输出当前半径值
class Circle2 {
    double radius;
    public double findAreas(){
        return radius*radius*3.14;
    }
}

class PassObject {
    public void printAreas(Circle2 c,int times){
        for (int i = 1; i <= times; i++) {
            c.radius = i;
            System.out.println("半径值为："+i+"面积为："+c.findAreas());
        }
    }
}
//需求14
//Tom类，猜拳方法fingerGuessing(),每次随机生成0,1,2（0石头，1剪刀，2布）
//随机数0-2 (int)((Math.random()*10)%3)
//显示输赢日志
class Tom {
    public void fingerGuessing() {
        String[] act = {"石头","剪刀","布"};
        String date ="";
        int index = 1;
        Scanner myscan = new Scanner(System.in);
        while(true){
            System.out.println("请输入行动: c比赛  e退出");
            char choose = myscan.next().charAt(0);
            switch (choose){
                case 'c':
                    System.out.println("请输入行动: 0-石头 1-剪刀 2-布");
                    int ai = (int)((Math.random()*10)%3);
                    int player = myscan.nextInt();
                    if (player == 0) {   //玩家出石头
                        switch (ai){
                            case 0: //电脑出石头
                                date += index++ + "\t玩家-"+act[player]+" 电脑-"+act[ai]+" 平局\n";
                                System.out.println("\t玩家-"+act[player]+" 电脑-"+act[ai]+"\n");
                                break;
                            case 1: //电脑出剪刀
                                date += index++ + "\t玩家-"+act[player]+" 电脑-"+act[ai]+" 玩家胜利\n";
                                System.out.println("\t玩家-"+act[player]+" 电脑-"+act[ai]+"\n");
                                break;
                            case 2: //电脑出布
                                date += index++ + "\t玩家-"+act[player]+" 电脑-"+act[ai]+" 电脑胜利\n";
                                System.out.println("\t玩家-"+act[player]+" 电脑-"+act[ai]+"\n");
                                break;
                        }
                    } else if (player == 1) {   //玩家出剪刀
                        switch (ai){
                            case 0: //电脑出石头
                                date += index++ + "\t玩家-"+act[player]+" 电脑-"+act[ai]+" 电脑胜利\n";
                                System.out.println("\t玩家-"+act[player]+" 电脑-"+act[ai]+"\n");
                                break;
                            case 1: //电脑出剪刀
                                date += index++ + "\t玩家-"+act[player]+" 电脑-"+act[ai]+" 平局\n";
                                System.out.println("\t玩家-"+act[player]+" 电脑-"+act[ai]+"\n");
                                break;
                            case 2: //电脑出布
                                date += index++ + "\t玩家-"+act[player]+" 电脑-"+act[ai]+" 玩家胜利\n";
                                System.out.println("\t玩家-"+act[player]+" 电脑-"+act[ai]+"\n");
                                break;
                        }
                    } else if (player ==  2) {  //玩家出布
                        switch (ai){
                            case 0: //电脑出石头
                                date += index++ + "\t玩家-"+act[player]+" 电脑-"+act[ai]+" 玩家胜利\n";
                                System.out.println("\t玩家-"+act[player]+" 电脑-"+act[ai]+"\n");
                                break;
                            case 1: //电脑出剪刀
                                date += index++ + "\t玩家-"+act[player]+" 电脑-"+act[ai]+" 电脑胜利\n";
                                System.out.println("\t玩家-"+act[player]+" 电脑-"+act[ai]+"\n");
                                break;
                            case 2: //电脑出布
                                date += index++ + "\t玩家-"+act[player]+" 电脑-"+act[ai]+" 平局\n";
                                System.out.println("\t玩家-"+act[player]+" 电脑-"+act[ai]+"\n");
                                break;
                        }
                    }
                    break;
                case 'e':
                    System.out.println(date);
                    return;
            }
        }
    }
}

21.封装例题

package com.encap;
//需求：
//Person类，允许查看的属性（name），私有属性（age，salary），对设置器的年龄进行合理验证，不合理就给默认18
//年龄必须在1-120之间，工资不能查看，name长度2-6之间
public class Test1 {
    public static void main(String[] args) {
        Person xiaoHua = new Person();
        xiaoHua.setAge(15);
        xiaoHua.setName("Hua");
        xiaoHua.setSalary(3500.00);
        System.out.println("姓名："+xiaoHua.name+"\t年龄："+xiaoHua.getAge()+"\t工资"+xiaoHua.getSalary());
    }
}

class Person{
    String name;
    private int age;
    private double salary;
    //构造器，直接调用setter进行初始化
    public Person(){

    }

    public Person(String name, int age, double salary) {
        this.setName(name);
        this.setAge(age);
        this.setSalary(salary);
    }

    //设置器和提取器 alt+insert 快捷设置
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age >=1 && age <= 120){  //年龄验证
            this.age = age;
        }else {
            this.age = 18;
        }
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        if(name.length() >= 2 && name.length() <= 6){   //姓名验证
            this.name = name;
        } else{
            System.out.println("姓名设置字符数应在2-6之间");
        }
    }
}

22.继承例题1

package com.extends01;

public class extends_3 {
    public static void main(String[] args) {
        Son son = new Son();
        //son类继承了GrandPa类和Father类的name属性，所以此时在内存中，son对象有三个name属性
        //当调用name属性时，会先查找Son类的name属性，如果存在且可调用，则会直接调用
        //如果无法调用，则会查找父类Father的属性，如果没有，则会继续往上一层父类GrandPa查找，直到查找到Object类。
        System.out.println(son.name);
        //如果父类的某些属性是私有的（private），则可以通过父类提供的共有方法进行调用。
        System.out.println(son.getHobby());
    }
}

class GrandPa{  //爷类
    String name = "大头爷爷";
    private String hobby = "旅游";

    public String getHobby(){
        return hobby;
    }
}
class Father extends GrandPa{   //父类
    String name = "大头爸爸";
    int age = 39;
}
class Son extends Father{       //子类
    String name = "大头儿子";
}

23.封装例题2

package com.extends01;

public class extendsExam_1 {
    public static void main(String[] args) {
        new E();
        //分析：
        // 1.创建了一个E类对象
        // 2.使用E类无参构造器进行初始化，先执行this("abc")，执行E类有参构造器
        // 3.先执行有参构造器中的默认super(); 即其父类D的无参构造器，执行D类无参构造器中语句System.out.println("d");
        // 4.然后执行下一句System.out.println("e name");
        // 5.最后执行E类中this("abc")语句的下一条语句System.out.println("e");
        //最后输出 d e name e
    }
}

class D{
    D(){System.out.println("d");}
    D(String name){System.out.println("d name");}
}
class E extends D{
    E(){this("abc");System.out.println("e");}
    E(String name){System.out.println("e name");}
}

24.重写例题

package com.override_exam1;

public class test1 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.speak();

    }
}

class Animal{   //父类
    public void speak(){
        System.out.println("动物在叫");
    }

    public AAA exam(){return null;}
}

class Dog extends Animal{   //子类
    //重写方法必须与父类方法的方法名、参数列表相同
    public void speak(){
        System.out.println("狗在叫");
    }
    //重写方法的返回类型可以为父类方法返回类型的子类
    @Override
    public BBB exam() {
        return null;
    }
}

class AAA{}

class BBB extends AAA{}

25.instanceof例题

package com.poly.polyExam_2;

public class test2 {
    public static void main(String[] args) {
        //AA是BB的父类
        AA aa = new BB();       //创建一个向上转型的BB对象
        System.out.println(aa instanceof AA);
        System.out.println(aa instanceof BB);
        //输出两个true，说明instanceof判断的是 aa的运行类型是否为类的对象或其子类的对象
    }
}

class AA{}
class BB extends AA{}

26.多态例题-向上向下转型

package com.poly;

public class polyExam_3 {
    public static void main(String[] args) {
        //创建一个向上转型的Animal对象引用
        Animal animal = new Dog();
        //输出10，即输出编译类型的变量name值，如果编译类型没有name，则会报错
        System.out.println(animal.name);
        //输出“我是Dog”，即执行运行类型的方法，如果Dog类有没此方法，则会同继承一样向父类查找调用
        animal.say();

        //向下转型 将父类引用对象强转成子类引用对象，强转前，父类引用对象必须指向强转的类型
        Dog dog = (Dog)animal;
        //此时编译类型为Dog类，则输出的name属性值是Dog类的属性值
        System.out.println(dog.name);
    }
}

class Animal{
    int name = 10;
    public void say(){
        System.out.println("我是animal");
    }

}

class Dog extends  Animal{
    int name = 20;

    public void say(){
        System.out.println("我是Dog");
    }
}

27.动态绑定机制例题

package com.poly.dynamicBinding;

import java.sql.SQLOutput;

public class test3 {
    public static void main(String[] args) {
        //A是编译类型  B是运行类型
        A a = new B();
        //动态绑定机制，方法与对象的运行类型绑定，所以调用的是B类的getI()
        //输出20
        System.out.println(a.getI());
        //此时注释掉了子类的sumI方法，根据继承机制，调用的是父类的sumI方法
        //因为动态绑定机制，父类sumI()方法中的getI()方法与运行类型绑定，所以运行的是子类的get()，返回20
        //因为属性没有动态绑定机制，哪里声明，哪里调用，所以调用的是父类的属性值10
        //输出20 + 10 = 30
        System.out.println(a.sumI());
    }
}

class A {       //父类
    int count = 10;
    public int getI(){
        return count;
    }

    public int sumI(){
        return count + getI();
    }
}

class B extends  A {    //子类
    int count = 20;
    public int getI(){
        return count;
    }

//    public int sumI(){
//        return count + getI();
//    }
}

28.多态数组例题

package com.poly.polyArray;
//父类 Person  子类 Teacher Student
//公有属性 name
//Teacher类特有方法supervision()   Student类特有方法examine()
public class test5 {
    public static void main(String[] args) {
        //创建Person类数组，元素个数为3，使用向上转型赋值給数组
        Person[] persons = new Person[3];
        persons[0] = new Person("人类");
        persons[1] = new Teacher("老师");
        persons[2] = new Student("学生");
        //say()方法是公有方法，所以可以直接用父类数组名调用
        //两个子类的特有方法无法直接调用，因为编译类型是Person类，而Person类没有子类的特有方法
        for (int i = 0; i < persons.length; i++) {
            persons[i].say();
            if(persons[i] instanceof Student){      //判断运行类型是否为Studnet类
                //向下转型成Student类,然后就可以使用Student类的特有方法
                ((Student) persons[i]).examine();
            }else if(persons[i] instanceof  Teacher){ //判断运行类型是否为Teacher类
                //向下转型成Teacher类,然后就可以使用Teacher类的特有方法
                ((Teacher) persons[i]).supervision();
            }else{} //如果是Person类，则没有特有方法
        }
    }
}

class Person{
    private String name;
    //构造器

    public Person(String name) {
        this.name = name;
    }

    //setter和getter
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    //共有方法 say
    public void say(){
        System.out.println(name);
    }

}

class Teacher extends Person{
    public Teacher(String name) {
        super(name);
    }
    //Teacher类特哟
    public void supervision(){
        System.out.println(getName() + "正在监考");
    }

}

class Student extends Person{
    public Student(String name) {
        super(name);
    }

    //Student类的特有方法examine()
    public void examine(){
        System.out.println(getName() + "正在考试");
    }
}

29.equals重写，hashCode，toString重写例题

package com.equalsExam;

import javax.swing.*;

public class test1 {
    public static void main(String[] args) {
        //测试equals()
        Person p1 = new Person("wang", 15, 'm');
        Person p2 = new Person("li",17,'f');
        Person p3 = new Person("wang", 15, 'm');
        //p1和p3为不同对象，但是属性值全部相同
        System.out.println(p1.equals(p2));      //输出false
        System.out.println(p1.equals(p3));      //输出true
        //测试hashCode()
        //p4 和 p1 是同一个对象，则哈希值相同，p1 和 p2不是同一个对象，则哈希值不同
        //哈希值是内存地址的另一种表现形式
        Person p4 = p1;
        System.out.println(p1.hashCode() == p4.hashCode());     //输出true
        System.out.println(p1.hashCode() == p2.hashCode());     //false
        //测试toString,
        // 输出对象时，默认调用toString方法
        //未重写时，输出为 全类名+@+哈希码16进制
        System.out.println(p1);     //输出 com.equalsExam.Person@4554617c
        System.out.println(p1.toString());  //输出 com.equalsExam.Person@4554617c
        //重写toString 方法后，输出对象属性信息，可以使用alt+insert快捷生成
        System.out.println(p1.toString());  //输出 Person{name='wang', age=15, gender=m}
        //测试finalize方法
        //finalize方法会在垃圾回收机制执行前自动调用
        //可以重写来实现自己的业务逻辑功能
        p2 = null;  //此时p2 原先指向的对象变成了垃圾对象，自动调用finalize方法
        System.gc();    //垃圾回收机制有自己的算法，但是可以通过System.gc()方法强制回收

    }
}

class Person{
    private String name;
    private int age;
    private char gender;

    public Person(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    //重写equals方法
    public boolean equals(Object obj) {
        //先判断是否为同一个对象,如果为一个对象，则为真
        if(obj == this){
            return true;
        }else{  //如果不是一个对象，则判断是否为同类对象
            if(obj instanceof Person){  //若为同类，则比较属性值
                Person objPerson = (Person)obj;     //向下转型，使比较对象可以调用Person类属性
                if(this.getName().equals(objPerson.getName())){ //比较name属性
                    if (this.getAge() == objPerson.getAge()){   //比较age属性
                        if(this.getGender() == objPerson.getGender()) {   //比较gender属性
                            return true;                //属性值全部相同，则返回true
                        }
                    }
                }
            }
        }
        return false;
    }
    //重写toString方法，使其能输出属性信息
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender=" + gender +
                '}';
    }
    //重写finalize方法

    @Override
    protected void finalize() throws Throwable {
        System.out.println("对象被销毁了");
    }
}

30.零钱通项目（过程编程）

package com.smallChangeSys;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class test_process {
    public static void main(String[] args) {
        //1.零钱通菜单
        //2.完成功能 零钱通明细
        //3.完成功能 收入入账
        //4.完成功能 消费

        //定义相关变量
        boolean flag = true;    //菜单退出控制变量

        //2.零钱通明细 功能
        //  使用字符串拼接
        String details = "\t\t\t零钱通明细";

        //3.收入入账 功能
        //定义新的变量
        double money = 0;
        double balance = 0;
        Date date = null;
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");            //用于日期格式化

        //4.消费 功能
        String reason = "";          //消费理由

        do{
            System.out.println("===========零钱通菜单  余额：" + balance + "===========");
            System.out.println("\t\t\t1 零钱通明细\t\t\t");
            System.out.println("\t\t\t2 收益入账\t\t\t");
            System.out.println("\t\t\t3 消   费\t\t\t");
            System.out.println("\t\t\t4 退   出\t\t\t");
            System.out.println("=============================");
            System.out.println("请输入指令编号（1-4）");
            Scanner myscan = new Scanner(System.in);
            int code = myscan.nextInt();
            switch (code){
                case 1:     //零钱通明细
                    System.out.println(details);
                    break;
                case 2:     //收益入账
                    System.out.println("收益入账金额：");
                    money = myscan.nextDouble();
                    //验证金额合法性 *
                    if(money <= 0 ){ //收入不能小于等于0
                        System.out.println("收入数额不合法");
                        continue;
                    }
                    balance += money;
                    //拼接明细信息
                    date = new Date();          //获取当前时间
                    details += "\n收益入账\t\t+" + money + "\t\t" + sdf.format(date) + "\t" + balance;
                    break;
                case 3:     //消费
                    System.out.println("消费原因：");
                    reason = myscan.next();
                    System.out.println("消费金额：");
                    money = myscan.nextDouble();
                    //验证余额是否大于消费额,消费金额是否大于0
                    if(money > balance || money <= 0){    //消费大于余额，则不允许消费
                        System.out.println("抱歉，您的余额不足或消费金额非法，当前余额：" + balance);
                        continue;
                    }
                    balance -=  money;
                    details += "\n消费\t\t-" + money + "\t\t" + sdf.format(date) + "\t" + balance;
                    break;
                case 4:     //退出
                    flag = false;
                    System.out.println("退出成功");
                    break;
                default:
                    System.out.println("输入有误，请重新选择");
            }
        }while(flag);
    }
}

31.零钱通项目（OOP编程）

package com.smallChangeSys_OOP;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class test {
    public static void main(String[] args) {
        CashSys cashSys = new CashSys();
        cashSys.menu();
    }
}

//创建一个零钱通类CashSYs
class CashSys{
    //1.创建一个menu方法，实现对菜单的显示
    //2.零钱通明细 功能，实现details方法
    //3.收入入账 功能，实现moneyInput方法
    //4.消费 功能，实现moneyOutput方法

    //相关变量定义
    private boolean flag = true;        //菜单退出控制变量
    private String details = "\t\t\t零钱通明细";     //零钱通明细变量
    private double balance = 0;     //余额
    private double money = 0;       //用于表示收入 或 支出 金额
    private Date  date = null;      //用于获取当前时间
    private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");        //时间格式化对象
    private Scanner myscan = new Scanner(System.in);        //用户输入对象
    private String reason = "";     //消费原因

    //Menu方法
    public void menu(){
        do{
            System.out.println("===========零钱通菜单  余额："+ balance +"  ===========");
            System.out.println("\t\t\t1 零钱通明细\t\t\t");
            System.out.println("\t\t\t2 收益入账\t\t\t");
            System.out.println("\t\t\t3 消   费\t\t\t");
            System.out.println("\t\t\t4 退   出\t\t\t");
            System.out.println("=============================");
            System.out.println("请输入指令编号（1-4）");
            Scanner myscan = new Scanner(System.in);
            int code = myscan.nextInt();
            switch (code){
                case 1:     //零钱通明细
                    this.details();
                    break;
                case 2:     //收益入账
                    this.moneyInput();
                    break;
                case 3:     //消费
                    this.moneyOutput();
                    break;
                case 4:     //退出
                    flag = false;
                    break;
                default:
                    System.out.println("输入有误，请重新选择");
            }
        }while(flag);
    }

    //零钱通明细功能 details()方法，显示当前账单明细
    public void details(){
        System.out.println(details);
    }

    //收入入账功能 moneyInput()方法，余额增加，并计入明细
    public void moneyInput(){
        System.out.println("收益入账金额：");
        money = myscan.nextDouble();
        //验证金额合法性 *
        if(money <= 0 ){ //收入不能小于等于0
            System.out.println("收入数额不合法");
        }else{
            balance += money;
            //拼接明细信息
            date = new Date();          //获取当前时间
            details += "\n收益入账\t\t+" + money + "\t\t" + sdf.format(date) + "\t" + balance;
        }
    }
    //消费 功能，moneyOutput()方法，余额减少，并计入明细
    public void moneyOutput(){
        System.out.println("消费原因：");
        reason = myscan.next();
        System.out.println("消费金额：");
        money = myscan.nextDouble();
        //验证余额是否大于消费额,消费金额是否大于0
        if(money > balance || money <= 0){    //消费大于余额，则不允许消费
            System.out.println("抱歉，您的余额不足或消费金额非法，当前余额：" + balance);
        }else{
            balance -=  money;
            details += "\n消费\t\t-" + money + "\t\t" + sdf.format(date) + "\t" + balance;
        }
    }


}

32.房屋租赁系统

（1）架构图

实现功能的三步：明确功能->思路分析->代码实现

（2）功能展示

功能展示
主菜单
新增
查找
修改
删除
显示
退出

（3）源码

1）HouseRentApp.java 运行类

package com.exam.HouseSys;

import com.exam.HouseSys.view.HouseView;

public class HouseRentApp {
    public static void main(String[] args) {
        //创建HouseRentApp对象，和显示菜单
        new HouseView().mainMenu();
        System.out.println("===你退出了=房屋出租系统==");
    }
}

2）House.java

package com.exam.HouseSys.domain;
//House类，表示房屋信息

public class House {
    //属性：编号、房主、电话、地址、月租、状态（未出租/已出租）
    private int id;
    private String name;
    private String phone;
    private String address;
    private double rent;
    private String state;

    //构造器
    public House(int id, String name, String phone, String address, double rent, String state) {
        this.id = id;
        this.name = name;
        this.phone = phone;
        this.address = address;
        this.rent = rent;
        this.state = state;
    }

    //getter和setter方法
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public double getRent() {
        return rent;
    }

    public void setRent(double rent) {
        this.rent = rent;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    //为了方便输出对象信息，实现toString方法
    @Override
    public String toString() {
        return id + "\t\t" +
               name + "\t\t" +
               phone + "\t\t" +
               address + "\t\t" +
               rent + "\t\t" +
               state;
    }

}

3）Service.java

package com.exam.HouseSys.service;

import com.exam.HouseSys.domain.House;
import com.exam.HouseSys.utils.Utility;
import com.sun.org.apache.bcel.internal.generic.RETURN;

public class Service {
    private int size = 10;          //House储存空间默认大小
    Utility utility = new Utility();        //工具类
    private House[] houses = new House[size];     //House 数据储存数组
    private int count = 0;      //计数当前数组中元素个数

    //房屋信息显示操作
    public void house_list(){
        for (int i = 0;i < houses.length;i++){
            if(houses[i] != null){
                System.out.println(houses[i]);
            }
        }
    }

    //房屋信息增加操作
    public boolean house_add(){
        if(count < houses.length){  //数组未满
            System.out.println("请依次输入ID、房主、电话、地址、月租、状态（已租出/未租出），每次输入一个数据并回车");
            int id = utility.readInt();
            String name = utility.readString();
            String phone = utility.readString();
            String address = utility.readString();
            double rent = utility.readDouble();
            String state = utility.readString();
            houses[count] = new House(id,name,phone,address,rent,state);
            count++;
            return true;        //添加成功
        }
        return false;           //添加失败
    }
    //房屋信息删除操作
    public boolean house_delete(){
        //判断用户是否真要删除
        System.out.println("请确实是否要删除Y/N");
        char key = utility.readChar();
        if(key == 'Y'){ //删除操作
            System.out.println("请输入要删除信息的编号");
            int id = utility.readInt();
            int index = utility.arrayIdFind(houses,id);     //获取下标
            //验证是否查找成
            if(index == -1){
                return false;
            }else {
                if(utility.arrayLeft(houses,index + 1)){    //删除成功
                    return true;
                }
            }

        }
        return false;
    }
    //房屋信息查找操作
    public boolean house_find(){
        System.out.println("请输入要查询的房屋编号：");
        int id = utility.readInt();
        int index = utility.arrayIdFind(houses,id); //获取目标房屋信息所在数组下标
        //判断是否查找到
        if(index == -1){    //index == -1,说明查找失败
            System.out.println("查找失败");
            return false;
        }
        System.out.println(houses[index]);  //查找成功，输出信息
        return true;
    }

    //房屋信息修改
    public boolean house_update(){
        System.out.println("请输入要修改的房屋信息编号：");
        int id = utility.readInt();
        int index = utility.arrayIdFind(houses,id);
         if(index == -1){      //查找失败
             System.out.println("不存在该编号房屋信息，修改失败");
             return false;
         }else{
             System.out.println("请依次输入房主、电话、地址、月租、状态（已租出/未租出），每次输入一个数据并回车");
             String name = utility.readString();
             String phone = utility.readString();
             String address = utility.readString();
             double rent = utility.readDouble();
             String state = utility.readString();
             houses[index].setName(name);
             houses[index].setPhone(phone);
             houses[index].setAddress(address);
             houses[index].setRent(rent);
             houses[index].setState(state);
             return true;
         }
    }
}

4）Utility.java

package com.exam.HouseSys.utils;
import com.exam.HouseSys.domain.House;

import java.util.Scanner;
public class Utility {
    private Scanner myscan = new Scanner(System.in);

    //接收一个Scanner类的char类型用户输入，然后将该值返回
    public char readChar(){
        return myscan.next().charAt(0);
    }
    //接收一个String类型
    public String readString(){
        return myscan.next();
    }
    //接收一个Double类型
    public Double readDouble(){
        return myscan.nextDouble();
    }
    //接收一个Int类型
    public int readInt(){
        return myscan.nextInt();
    }
    //实现 用户输入一个编号，在数组中寻找出一个编号相等的元素，并返回数组下标
    public int arrayIdFind(House[] house,int id){
        if(house != null){
            for (int i = 0; i < house.length; i++) {
                if(house[i] == null){       //跳过空的房屋信息对象
                    continue;
                }
                if(house[i].getId() == id){
                    return i;
                }
            }
        }
        return -1;
    }


    //实现数组从第k个元素到开始左移，并覆盖掉第k个元素
    public boolean arrayLeft(House[] house,int k){
        if(house != null){      //数组不为空
            for (int i = k - 1; i < house.length - 1; i++) {
                house[i] = house[i+1];
            }
            return true;
        }
        return false;
    }
}

5）HouseView.java

package com.exam.HouseSys.view;

import com.exam.HouseSys.domain.House;
import com.exam.HouseSys.utils.Utility;
import com.exam.HouseSys.service.Service;
/**
* 1.显示界面
* 2.接受用户输入
* 3.调用HouseService 完成对房屋信息的各种操作
* */
public class HouseView {
    private boolean loop = true;    //控制显示菜单
    private char key = ' ';     //接收用户输入操作
    private Utility utility = new Utility();
    private Service service = new Service();

    //房屋列表显示方法
    public void house_list_view(){
        System.out.println("================房屋列表================");
        System.out.println("编号\t\t\t房主\t\t\t电话\t\t\t地址\t\t\t月租\t\t\t状态");
        service.house_list();
    }

    public void mainMenu(){
        do{
            System.out.println("================房屋出租系统================");
            System.out.println("\t\t\t1 新 增 房 源");
            System.out.println("\t\t\t2 查 找 房 屋");
            System.out.println("\t\t\t3 删 除 房 屋 信 息");
            System.out.println("\t\t\t4 修 改 房 屋 信 息");
            System.out.println("\t\t\t5 显 示 房 屋 列 表");
            System.out.println("\t\t\t6 退 出");
            System.out.println("请输入你的选择（1-6）");

            key = utility.readChar();
            switch (key){
                case '1':   //添加        （完成）
                    if (service.house_add()){
                        System.out.println("添加成功");
                    }else{
                        System.out.println("添加失败，列表已满");
                    }
                    break;
                case '2':           //查找 (完成)
                    service.house_find();
                    break;
                case '3':   //删除 （完成）
                    System.out.println("删除");
                    if(service.house_delete()){
                        System.out.println("删除成功");
                    }else{
                        System.out.println("编号不存在,删除失败");
                    }
                    break;
                case '4':       //修改 ()
                    if(service.house_update()){
                        System.out.println("修改成功");
                    }
                    break;
                case '5':  //房屋列表 （完成）
                    house_list_view();
                    break;
                case '6':   //退出（完成）
                    loop = false;
                    break;
            }
        }while(loop);
    }


}

33.静态变量例题

package com.staticLearn;

public class test {
    public static void main(String[] args) {
        //1.静态变量不依赖于对象实例，可以由 类名.变量名 直接调用。
        AA.count++;
        //2.也可以由 对象名.变量名 调用
        AA a = new AA();
        a.count++;
        AA a2 = new AA();
        a2.count++;
        //3.所有该类对象共用该 静态变量
        //相当于jvm内存中有一个独立的空间存放该静态变量，所有该类对象的该变量都指向这片独立空间
        System.out.println(a.count);        //输出3
        System.out.println(a2.count);       //输出3
        System.out.println(AA.count);       //输出3
    }
}

class AA{
    public static int count = 0;    //记录该类对象的个数

    public void addCount(){
        count++;
    }
}

34.静态方法例题

package com.staticLearn.staticMethod;

public class test2 {
    public static void main(String[] args) {
        //静态成员（类方法和类变量）可以不创建对象直接调用
        Person.say();
        System.out.println(Person.age);
        //普通成员（普通方法和普通变量）必须要创建对象实例才能调用
        new Person().speak();
        System.out.println(new Person().name);
    }
}

class Person{
    public String name = " ";           //普通变量
    public static int age = 18;         // 静态变量/类变量/静态字段

    public static void say(){   //静态方法
        //静态方法无法调用普通成员，只能调用静态成员，且不允许使用this和super关键字
        System.out.println("我的年龄是：" + age + "岁");
    }

    public void speak(){
        //普通方法可以调用静态成员和普通成员，也可以使用this和super关键字
        System.out.println( this.name + "的年龄是" + age + "岁");
    }
}

35.代码块例题

package com.codeBlock;

public class test {
    public static void main(String[] args) {
        new Film(15);
    }
}

class A{
    public A(){
        System.out.println("A");
    }
}

class Film extends A{

    private String name;
    private double price;
    //假如所有构造器都有一个共同的操作，这时就可以使用代码块调用，减少了代码的冗余
    //不管调用哪个构造器，都会优先调用代码块
    //如果有父类，那执行顺序是 父类构造器->子类代码块->子类构造器

    {
        System.out.println("电影正在上映");
    };

    public Film(String name) {
        //System.out.println("电影正在上映");
        this.name = name;
    }

    public Film(double price) {
        //System.out.println("电影正在上映");
        this.price = price;
    }

    public Film(String name, double price) {
        //System.out.println("电影正在上映");
        this.name = name;
        this.price = price;
    }
}

36.代码块细节1

package com.codeBlock.details;

public class test2 {
    public static void main(String[] args) {
        //1.调用了静态成员、创建了新对象或子类对象，类会被加载，调用静态代码块
//        Person.age = 1;     //输出 "人类的静态代码块"
//        //创建了两个新的对象实例，静态代码块只能调用一次，所以不会再调用
//        //普通代码块在每次创建新对象时都会被调用
//        new Person();     //输出 "人类的普通代码块"
//        new Person();     //输出 "人类的普通代码块"

        //2.当子类调用静态成员时，父类也会被加载，然后先调用父类静态代码块，然后是子类静态代码块
//        System.out.println(Student.age);
        //当子类创建对象时，执行顺序是 父类静态代码块 -> 子类静态代码块 -> 父类普通代码块 -> 父类构造器 -> 子类普通代码块 -> 子类构造器
          new Student();
    }
}

class Person{
    //静态变量
    public static int age = 0;

    //静态代码块，在类被加载时调用，且只会调用一次
    static {
        System.out.println("人类的静态代码块");
    };
    //普通代码块，每次（new）创建新对象都会被调用
    {
        System.out.println("人类的普通代码块");
    };

    public Person(){
        System.out.println("人类构造器");
    }
}

class Student extends Person{
    public static int age = 0;

    static {
        System.out.println("学生的静态代码");
    }

    {
        System.out.println("学生的普通代码块");
    }

    public Student(){
        System.out.println("学生构造器");
    }
}

37.单例模式-饿汉式例题

package com.danLiMoShi.hungry;

public class test {
    public static void main(String[] args) {
        //当GrilFriend类加载后，其对象就会被创建
        //且无法使用GirlFriend类的构造器创建新的对象
        GrilFriend girl = GrilFriend.getInstance();
        System.out.println("姓名：" + girl.getName() + "\t年龄：" + girl.getAge());
    }
}

class GrilFriend{
    //单例模式-饿汉式
    //2.在类中创建对象
    public static GrilFriend instance = new GrilFriend();

    private String name = "红";
    private int age = 18;

    //1.设置私有构造器
    private GrilFriend(){}

    //3.创建一个公开的方法，用于返回对象地址 getInstance
    public static GrilFriend getInstance(){
        return instance;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

38.单例模式-懒汉式例题

package com.danLiMoShi.lazy;

public class test {
    public static void main(String[] args) {
        Cat cat = Cat.getInstance();
        System.out.println("猫猫的名字是" + cat.getName());
    }
}

class Cat{
    //单例模式-懒汉式
    private String name  = "三花";


    //1.创建私有构造器
    private Cat(){}

    //2.在类中定义该类的对象引用
    public static Cat instance;

    //3.提供一个公有方法，当该方法被调用时，才会給对象分配空间
    public static Cat getInstance(){
        if(instance == null){       //只有第一次调用时会被分配
            instance = new Cat();
        }
        return instance;
    }

    public String getName() {
        return name;
    }
}

39.用抽象类实现模板模式

package com.abstractClass.exam;
//模板模式
//假设有几个类，他们都有一个job方法，工作内容不同，但是都需要计算用时
//将计算用时的操作封装为一个方法 calculate()
//将job内容封装成一个抽象方法 job()，由子类实现各自的工作内容
//在calculate()方法内调用job方法
//所有子类都继承了calculate方法，实现了job方法，在同时实现计时功能的同时，实现各自不同的工作操作

public class test {
    public static void main(String[] args) {
        AAA a = new AAA();
        a.calculate();
        BBB b = new BBB();
        b.calculate();
    }
}

abstract class Template{
    public void calculate(){
        //获取开始时间
        long start = System.currentTimeMillis();
        //抽象方法job()，由子类实现
        job();
        //获取结束时间
        long end = System.currentTimeMillis();
        System.out.println("耗时：" + (end - start));
    }

    abstract public void job();
}

class AAA extends Template{
    public void job(){
        for (long i = 0; i < 1000000 ; i++) {}
    }
}

class BBB extends Template{
    public void job(){
        for (long i = 0; i < 9000000 ; i++) {}
    }
}

40.接口例题1

interface AA{
    //接口中可以有属性
    int a = 5;
    //接口中的抽象方法可以不写 abstract关键字修饰
    public void speak();
    //接口中可以写有具体实现的方法， 静态方法 和 默认方法
    public static void say(){}
    public default void say2(){}
}

class BB implements AA{
    //类 实现接口后，必须实现所有的抽象方法
    public void speak(){
        System.out.println(a);
    }
}

41.接口例题

package com.interfaceExam.extendsVsimplements;

public class test {
    public static void main(String[] args) {
        LittleMonkey money = new LittleMonkey("悟空");
        money.climbing();
        money.flyable();
        money.swimming();
    }
}

//猴子
class Monkey{
    private String name;

    public Monkey(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void climbing(){
        System.out.println("猴子" + name +"在爬树");
    }
}

//鱼接口
interface fishable{
    void swimming();
}
//鸟接口
interface birdable{
    void flyable();
}
//小猴子
class LittleMonkey extends Monkey implements fishable,birdable{

    public LittleMonkey(String name) {
        super(name);
    }

    @Override
    public void swimming() {
        System.out.println(  "猴子" + getName() +"在游泳");
    }

    @Override
    public void flyable() {
        System.out.println("猴子" + getName() + "在飞行");
    }
}
//总结
//java的类是单继承机制
//java在继承父类时会自动获取父类的方法
//如果想要扩展功能，就需要实现接口

42.接口的多态参数和多态数组

public class test4 {
    //形参为Usb 接口
    //实参为实现了该接口的类的实例对象
    //根据动态绑定，调用的类自己实现的方法
    public static void say(Usb usb){
        usb.start();
        usb.end();
    }

    public static void main(String[] args) {
        //1.多态参数
        say(new Phone());   //输出 手机开启了\n手机关闭了
        say(new Computer());    //输出 电脑开启了\n电脑关闭了
        //2.多态数组
        //Usb接口类型的数组中 可以存放实现了该接口的 类对象实例
        Usb[] usb = new Usb[2];
        usb[0] = new Phone();
        usb[1] = new Computer();
        //向下转型，实现类的特有方法
        Phone phone = (Phone)usb[0];
        phone.call();



    }
}
//Usb接口
interface Usb{
    void start();
    void end();
}
//手机类 实现Usb 接口
class Phone implements Usb{

    @Override
    public void start() {
        System.out.println("手机开启了");
    }

    @Override
    public void end() {
        System.out.println("手机关闭了");
    }

    public void call(){
        System.out.println("手机可以打电话");
    }
}
//电脑类 实现Usb 接口
class Computer implements Usb{

    @Override
    public void start() {
        System.out.println("电脑开启了");
    }

    @Override
    public void end() {
        System.out.println("电脑关闭了");
    }
}

43.接口的多态传递

public class test5 {
    public static void main(String[] args) {
        //现在有 接口I1,I2，接口I2继承了接口I1
        //类AA 实现了接口I2
        //因为I2 继承 I1，所以类AA相当于也实现了接口I1，接口I1的对象引用可以指向AA类的对象空间
        // 这就是多态传递
        AA aa = new AA();
        I2 i2  = aa;
        I1 i1 = i2;
    }
}

interface I1{}
interface I2 extends I1{}
class AA implements I2{}

44.局部内部类例题

package com.innerClass.partInnerClass;

public class test {
    public static void main(String[] args) {
        //3.局部内部类的作用域仅仅在定义他的方法中
        //        Inner a = new Inner();
        new Outer().say();
        //输出：
        // 5
        //王五
        //张三
        //外部类的jump方法
    }
}

class Outer{    //外部类
    private String name = "张三";
    private void jump(){
        System.out.println("外部类的jump方法");
    }
    //3.局部内部的作用范围仅仅在定义他的代码块中
//    Inner a = new Inner();
    public void say(){
        //2.局部内部类不能添加访问修饰符，但是可以添加final修饰
        final class Inner{        //局部内部类
            private String name = "王五";
            private int a = 5;
            //1.局部内部类可以直接访问外部类的私有成员
            private void speak(){
                //当局部内部类和外部类拥有同名属性时，遵循就近原则
                //如果想要调用外部类的同名属性 ，可以使用 外部类名.this.属性名 的形式
                System.out.println(name);
                System.out.println(Outer.this.name);
                jump();
            }
        }
        //5.外部类访问局部内部类成员需要先创建对象再访问
        //外部类可以直接访问局部内部类的私有成员
        System.out.println(new Inner().a);
        new Inner().speak();

    }
}

45.匿名内部类例题

package com.innerClass.anonymousInnerClass;

public class test2 {
    public static void main(String[] args) {
        new AA().say();

    }
}

class AA{

        public static void say(){

            //匿名内部类相当于 实现了该接口
            //匿名内部类的定义是在底层完成的，在类定义的同时，也创建了对象
            //匿名内部类在底层的类名为 外部类类名$编号
            //因为动态绑定机制，运行的方法会是运行类型，即匿名内部类的方法
            //匿名内部的调用方式 第一种 是通过对象引用 第二种是在定义语句后直接调用
            //1.基于接口的匿名内部类
            IA ia  = new IA() {     //将匿名内部类的对象地址赋值給接口对象引用，然后调用
                @Override
                public void jump() {
                    System.out.println("匿名内部类的jump方法");
                }
            };
            ia.jump();
            System.out.println(ia.getClass()); //输出 class com.innerClass.anonymousInnerClass.AA$1
            //2.基于普通类的匿名内部类
            //匿名内部类相当于 继承了Person类
            Person person = new Person(){
                @Override
                public void sing() {    //重写父类的sing方法
                    System.out.println("匿名内部类的重写sing方法");
                }
            };
            person.sing();
            System.out.println(person.getClass());  //输出 class com.innerClass.anonymousInnerClass.AA$2
            //3.基于抽象类的匿名内部类
            //匿名内部类相当于 实现了Animal抽象类
            Animal animal = new Animal() {
                @Override
                void eat() {    //实现Animal抽象类的eat方法
                    System.out.println("匿名内部类实现的eat方法");
                }
            };
            animal.eat();
            System.out.println(animal.getClass());// 输出 class com.innerClass.anonymousInnerClass.AA$3
            //另一种调用方式，定义匿名内部类后直接调用
            new IA() {
                @Override
                public void jump() {
                    System.out.println("我是匿名内部类的另一种调用方式");
                }
            }.jump();       //定义后直接调用方法
        }

    }

    interface IA{       //接口IA
        void jump();
    }

    class Person{   //Person类
        public void sing(){}
    }


    abstract class Animal { //抽象类Animal
        abstract void eat();
    }

46.匿名内部类例题2-作为参数

package com.innerClass.anonymousClass_2;

public class test {
    public static void main(String[] args) {
        //传统方法，定义一个实现IA接口的类，然后创建一个对象作为实参
        AA a = new AA();
        say(a);
        //使用匿名内部类
        //直接在实参位置定义匿名内部类
        //如果该类只用一次，那么使用匿名内部类会更加简洁
        say(new IA() {
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        });


    }

    public static void say(IA ia){  //参数是一个 实现了IA接口的对象
        ia.show();
    }
}

interface IA{
    void show();
}

class AA implements IA{

    @Override
    public void show() {
        System.out.println("传统派");
    }
}

47.匿名内部类例题-作为参数

package com.innerClass.anonymouseInnerClass3;
//需求
//1.有一个铃声接口Bell，里面有个ring方法
//2.测试手机类Cellphone，具有闹钟功能alarmclock，参数是Bell类型
//3.测试手机类的闹钟功能，通过匿名内部类（对象）作为参数，打印：懒猪起床了
//4.再传入另一个匿名内部类（对象），打印小伙伴上课了
public class test {
    public static void main(String[] args) {
        Cellphone cellphone = new Cellphone();
        cellphone.alarmclock(new Bell() {       //匿名内部类作为实际参数
            @Override
            public void ring() {
                System.out.println("懒猪起床了");
            }
        });
        cellphone.alarmclock(new Bell() {
            @Override
            public void ring() {
                System.out.println("小伙伴上课了");
            }
        });
    }
}

//Bell接口
interface Bell{
    void ring();
}

//测试手机类Cellphone，具有闹钟功能alarmclock，参数是Bell类型
class Cellphone{
    public void alarmclock(Bell bell){
        bell.ring();
    }
}

48.成员内部类例题

package com.innerClass.memberInnerClass;

public class test {
    public static void main(String[] args) {
        //外部其他类调用成员内部类 方法一
        //第一种方式是先创建外部类对象，然后通过外部类调用成员的方式创建内部类成员
        //外部类对象.new 内部类名();
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        //外部其他类调用成员内部类 方法二
        //外部类提供一个公共方法，返回内部类的对象地址
        Outer.Inner inner1 = outer.getInnerClass();
    }
}

class Outer{    //外部类
    private String name = "张三";


    //1.成员内部类可以使用访问修饰符
    //2.成员内部类可以调用外部类的所有成员
    public class Inner{    //成员内部类，定义在外部类成员位置上
        public void say(){
            System.out.println(name);
        }
    }

    public void speak(){
        //外部类调用内部类，需要先创建对象，然后调用
        new Inner().say();
    }

    public Inner getInnerClass(){       //返回内部类的方法
        return new Inner();
    }
}

49.静态成员内部类

package com.innerClass.memberInnerClass;

public class test {
    public static void main(String[] args) {
        //外部其他类调用成员内部类 方法一
        //第一种方式是先创建外部类对象，然后通过外部类调用成员的方式创建内部类成员
        //外部类对象.new 内部类名();
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        //外部其他类调用成员内部类 方法二
        //外部类提供一个公共方法，返回内部类的对象地址
        Outer.Inner inner1 = outer.getInnerClass();
    }
}

class Outer{    //外部类
    private String name = "张三";


    //1.成员内部类可以使用访问修饰符
    //2.成员内部类可以调用外部类的所有成员
    public class Inner{    //成员内部类，定义在外部类成员位置上
        public void say(){
            System.out.println(name);
        }
    }

    public void speak(){
        //外部类调用内部类，需要先创建对象，然后调用
        new Inner().say();
    }

    public Inner getInnerClass(){       //返回内部类的方法
        return new Inner();
    }
}

50.线程例题1

package threadUse;

public class test {
    public static void main(String[] args) {
        //创建一个线程对象
        myThread myThread = new myThread();
        //start方法开启了一个子线程
        //如果直接调用线程对象的 run方法，那只是调用了run方法，而没有真正开启一个子线程，仍然是在main线程中运行
        myThread.start();
    }
}
//1.当一个类继承了 Thread类，该类就可以当做线程使用
//2. 我们会重写run方法，写上自己的业务代码
//3.Thread类 的 run方法 实现了 Runnable 接口的run方法
class myThread extends Thread{
    @Override
    public void run() {
        //该线程每隔一秒，在控制台输出“喵喵，我是小猫猫”
        System.out.println("喵喵，我是小猫猫");

        //让控制台休眠一秒 使用ctrl + alt + t 快速抛出异常
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}