Java 面向对象（基础部分）

麦合学长
已于 2023-11-29 14:05:34 修改
阅读量546
点赞数 9
文章标签： java 开发语言
于 2023-11-28 19:03:33 首次发布
本文链接：https://blog.csdn.net/rassamqi/article/details/134674449
版权
//************************************192***************************************************//
public class Object01 {
    //编写一个main方法
    public static void main(String[] args) {


        张老太养了两只猫猫:一只名字叫小白,今年3岁,白色。
        还有一只叫小花,今年100岁,花色。请编写一个程序，当用户输入小猫的名字时，
        就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，
        则显示 张老太没有这只猫猫。

        单独变量来解决 => 不利于数据的管理(你把一只猫的信息拆解)


        第1只猫信息
         String cat1Name = "小白";
         int cat1Age = 3;
         String cat1Color = "白色";

         //第2只猫信息
         String cat2Name = "小花";
         int cat2Age = 100;
         String cat2Color = "花色";

        数组 ===>(1)数据类型体现不出来(2) 只能通过[下标]获取信息，造成变量名字和内容
                 的对应关系不明确(3) 不能体现猫的行为
        第1只猫信息

         String[] cat1 = {"小白", "3", "白色"};
         String[] cat2 = {"小花", "100", "花色"};

//******************194***********
        使用OOP面向对象解决
        实例化一只猫[创建一只猫对象]
        1. new Cat() 创建一只猫(猫对象)
        2. Cat cat1 = new Cat(); 把创建的猫赋给 cat1
        3. cat1 就是一个对象

        Cat cat1 = new Cat();
        cat1.name = "小白";
        cat1.age = 3;
        cat1.color = "白色";
        cat1.weight = 10;

        创建了第二只猫，并赋给 cat2     cat2 也是一个对象(猫对象)
        Cat cat2 = new Cat();
        cat2.name = "小花";
        cat2.age = 100;
        cat2.color = "花色";
        cat2.weight = 20;

        //怎么访问对象的属性呢
        System.out.println("第1只猫信息" + cat1.name + " " + cat1.age + " " + cat1.color + " " + cat1.weight);
        System.out.println("第2只猫信息" + cat2.name + " " + cat2.age + " " + cat2.color + " " + cat2.weight);
    }
}

使用面向对象的方式来解决养猫问题-----> 定义一个猫类 Cat -> 自定义的数据类型
class Cat {   //属性/成员变量
    String name; //名字
    int age; //年龄
    String color; //颜色
    double weight; //体重
}
//******************************************************************************************//
//******************************************************************************************//
//******************************************************************************************//

栈：cat  0x0001   堆：0x0001--->0x0002  40  0x0003   （string 引用对象，保存地址，值保存在方法区）
方法区：0x0002:小白   0x0003:白色  加载cat类信息：属性，方法

//******************************************************************************************//
//******************************************************************************************//
//******************************************************************************************//
public class Object02 {
    public static void main(String[] args) {
    }
}

class Car {
    String name;//属性, 成员变量, 字段 field
    double price;
    String color;
    String[] master;//属性可以是基本数据类型，也可以是引用类型(对象，数组)
}
//******************************************************************************************//
//**************************************197*************************************************//
//******************************************************************************************//
public class PropertiesDetail {
    public static void main(String[] args) {
        //创建Person对象
        //p1 是对象名(对象引用)

        Person p1 = new Person();   //new Person() 创建的对象空间(数据)-----> 才是真正的对象

        对象的属性默认值，遵守数组规则:
        int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null

        System.out.println("\n当前这个人的信息");
        System.out.println("age=" + p1.age + " name=" + p1.name + " sal=" + p1.sal + " isPass=" + p1.isPass) ;
    }
}

class Person {  //四个属性
    int age;
    String name;
    double sal;
    boolean isPass;
}
//******************************************************************************************//
//**************************************198************************************************//
//******************************************************************************************//
 方法一：Cat cat;    //栈：cat--->null
        cat=new Cat( );     //堆：0x0001--->cat:xxx（默认值）   栈：cat--->0x0001   方法区：加载类的方法，属性
方法二： Cat cat=new Cat();   //堆：0x0001--->cat:xxx(默认值）   栈：cat--->0x0001   方法区：加载类的方法，属性
//******************************************************************************************//
//***********************************************199**************************************//
//******************************************************************************************//
public class Object03 {
    public static void main(String[] args) {

        Person p1=new Person();   //堆：0x0001--->0  0x004(默认值）   栈：person--->0x0001   方法区：加载person类的方法，属性
        p1.age=10;
        p1.name="小明";
        Person p2=p1; //把p1 赋给了 p2 ， 让p2指向p1       p2是p1的外号！！！同一个东西！
        System.out.println(p2.age); // 10      p1=======p2
    }
}

class Person {
    String name;
    int age;
}
//******************************************************************************************//
//*********************************************201*******************************************//
//******************************************************************************************//
        class Person {
            String name;             核心问题：b=a，b指向a指向的内容！！而不是，b指向a。
            int age;
        }                             如果：b指向a，那么，a丢了，b也会丢！但事实，没有这样。
        Person a=new Person( );
        Person b=a;    b指向a指向的内容！！！！不是说：b指向a！！！
        a=null; -------> a指向空指针，a丢了！
        b.age   -------> b依旧指向a指向的内容，正常输出！
        a.age   -------> 此时，a已经丢了！！异常！！
//******************************************************************************************//
//*******************************************202*********************************************//
//******************************************************************************************//
public class Method01 {
    public static void main(String[] args) {
        //方法使用
        //1. 方法写好后，如果不去调用(使用)，不会输出
        //2. 先创建对象 ,然后调用方法即可
        Person p1 = new Person();
        p1.speak(); //调用方法


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("我是一个好人");
    }

    }

//******************************************************************************************//
//*********************************************203*******************************************//
//******************************************************************************************//
public class Method01 {
    public static void main(String[] args) {
        //方法使用
        //1. 方法写好后，如果不去调用(使用)，不会输出
        //2. 先创建对象 ,然后调用方法即可
        Person p1 = new Person();

        p1.cal01(); //调用cal01方法
        p1.cal02(5); //调用cal02方法，同时给n = 5
        p1.cal02(10); //调用cal02方法，同时给n = 10

        调用getSum方法，同时num1=10, num2=20
        把 方法 getSum 返回的值，赋给 变量 returnRes
        int returnRes = p1.getSum(10, 20);
        System.out.println("getSum方法返回的值=" + returnRes);
    }
}

class Person {

    String name;
    int age;
    //添加cal01 成员方法,可以计算从 1+..+1000的结果
    public void cal01() {  //循环完成
        int res = 0;
        for(int i = 1; i <= 1000; i++) {
            res += i;
        }
        System.out.println("cal01方法 计算结果=" + res);
    }

    添加cal02 成员方法,该方法可以接收一个数n，计算从 1+..+n 的结果
    //(int n) 形参列表， 表示当前有一个形参 n, 可以接收用户输入
    public void cal02(int n) {
        int res = 0;
        for(int i = 1; i <= n; i++) {
            res += i;
        }
        System.out.println("cal02方法 计算结果=" + res);
    }

    添加getSum成员方法,可以计算两个数的和
    1. public 表示方法是公开的
    2. int :表示方法执行后，返回一个 int 值
    3. getSum 方法名
    4. (int num1, int num2) 形参列表，2个形参，可以接收用户传入的两个数
    5. return res; 表示把 res 的值， 返回

    public int getSum(int num1, int num2) {
        int res = num1 + num2;
        return res;
    }
}
//******************************************************************************************//
//*********************************************204******************************************//
//******************************************************************************************//
        当程序执行到“方法”时，开辟一个独立的栈空间：getsum栈，在getsum栈里进行运算，
        直到return或者结束后，释放开辟的getsum栈空间，继续主程序。当主程序(main)函数return时，整个函数退出！

        int returnRes = p1.getSum(10, 20);
        public int getSum(int num1, int num2) {
            int res = num1 + num2;
            return res;
//******************************************************************************************//
//*****************************************205*********************************************//
//******************************************************************************************//
public class Method02 {
                                   代码：复用性提高！！实现的细节封装起来，供其他用户使用！
    public static void main(String[] args) {

        //请遍历一个数组 , 输出数组的各个元素值
        int [][] map =  {{0,0,1},{1,1,1},{1,1,3}};

        //使用方法完成输出, 创建MyTools对象
        MyTools tool = new MyTools();

        遍历map数组
        传统的解决方式就是直接遍历   多次的话---->复制粘贴！！
        // 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();
        // }
        //使用方法
        tool.printArr(map);

        //....
        //
        //要求再次遍历map数组
        // 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();
        // }
        tool.printArr(map);


        //...再次遍历
        //
        // 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();
        // }
        tool.printArr(map);

    }
}

//把输出的功能，写到一个类的方法中,然后调用该方法即可
class MyTools {
    //方法，接收一个二维数组

    public void printArr(int[][] map) {
        System.out.println("=======");
        //对传入的map数组进行遍历输出
        for(int i = 0; i < map.length; i++) {
            for(int j = 0; j < map[i].length; j++) {
                System.out.print(map[i][j] + "_");
            }
            System.out.println();
        }
    }
}
//******************************************************************************************//
//************************************207  208**************************************************//
//******************************************************************************************//
/public class MethodDetail {
    public static void main(String[] args) {

        AA a = new AA();
        int[] res = a.getSumAndSub(1, 4);
        System.out.println("和=" + res[0]);
        System.out.println("差=" + res[1]);

        细节: 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型 的参数
        byte b1 = 1;
        byte b2 = 2;
        a.getSumAndSub(b1, b2);//byte -> int
        入a.getSumAndSub(1.1, 1.8);//double ->int(×)
        细节: 实参和形参的类型要一致或兼容、个数、顺序必须一致

        a.getSumAndSub(100);//× 个数不一致
        a.f3("tom", 10); //ok
        a.f3(100, "jack"); // 实际参数和形式参数顺序不对

    }
}

class AA {

    细节: 方法不能嵌套定义
    public void f4() {
        //错误
        // public void f5() {

        // }
    }

    public void f3(String str, int n) {

    }

    1. 一个方法最多有一个返回值  [思考，如何返回多个结果 --> 返回数组 ]
    public int[] getSumAndSub(int n1, int n2) {

        int[] resArr = new int[2];
        resArr[0] = n1 + n2;
        resArr[1] = n1 - n2;
        return resArr;
    }
    2. 返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
      具体看 getSumAndSub
     public void printArr(int[][] map) {}  引用类型

    3. 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值;
       而且要求返回值类型必须和return的值类型一致或兼容
    public double f1() {

        double d1 = 1.1 * 3;
        int n = 100;
        return n; // int ->double
        return d1; //ok? double -> int 错！！
    }

    如果方法是void，则方法体中可以没有return语句，或者 只写 return ;
    老韩提示：在实际工作中，我们的方法都是为了完成某个功能，所以方法名要有一定含义 ，最好是见名知意
    public void f2() {

        System.out.println("hello1");
        System.out.println("hello1");
        System.out.println("hello1");
        int n = 10;
        return ;  可以！不写，也可以~~
    }

}
//******************************************************************************************//
//*****************************************209***********************************************//
//******************************************************************************************//
public class MethodDetail02 {
    public static void main(String[] args) {
        A a = new A();
        a.sayOk();
        a.m1();
    }
}

class A {
    同一个类中的方法调用：直接调用即可      同一个类：方法调用方法，可以！
    public void print(int n) {
        System.out.println("print()方法被调用 n=" + n);
    }

    public void sayOk() { //sayOk调用 print(直接调用即可)
        print(10);
        System.out.println("继续执行sayOK()~~~");
    }

    跨类中的方法A类调用B类方法：需要通过对象名调用

    public void m1() {
        System.out.println("m1() 方法被调用");
        B b = new B();     //创建B对象, 然后在调用方法即可
        b.hi();                              如果，hi方法在同类，直接： hi()就行！

        System.out.println("m1() 继续执行:)");
    }
}

class B {

    public void hi() {
        System.out.println("B类中的 hi()被执行");
    }
}
//******************************************************************************************//
//******************************************************************************************//
//******************************************************************************************//
public class MethodExercise01 {
    public static void main(String[] args) {

        AA a = new AA();
         if(a.isOdd(2)) {//T , 这样的写法以后会看到很多
         	System.out.println("是奇数");
         } else {
         	System.out.println("是偶数");
         }
//**********
         使用print方法
        a.print(4, 4, '#');
    }
}

编写类AA ，有一个方法：判断一个数是奇数odd还是偶数, 返回boolean
class AA {

    1. 方法的返回类型 boolean
    2. 方法的名字 isOdd
    3. 方法的形参 (int num)
    4. 方法体 , 判断

    public boolean isOdd(int num) {
         if(num % 2 != 0) {
         	return true;
         } else {
         	return false;
         }

        //return num % 2 != 0 ? true; false;

        return num % 2 != 0;   //简化
    }
//********************************
    根据行、列、字符打印 对应行数和列数的字符，
    比如：行：4，列：4，字符#,则打印相应的效果
                ####
                ####
                ####
                ####

    思路
    1. 方法的返回类型 void
    2. 方法的名字 print
    3. 方法的形参 (int row, int col, char c)
    4. 方法体 , 循环

    public void print(int row, int col, char c) {
        for(int i = 0; i < row; i++) {
            for(int j = 0; j < col; j++) {//输出每一行
                System.out.print(c);
            }
            System.out.println(); //换行
        }
    }
}
//******************************************************************************************//
//*****************************************211*********************************************//
//******************************************************************************************//
public class MethodParameter01 {
    public static void main(String[] args) {

        int a = 10;
        int b = 20;
        AA obj = new AA();    //创建AA对象 名字 obj
        obj.swap(a, b);    //调用swap
        System.out.println("main方法 a=" + a + " b=" + b);//a=10 b=20
    }
}

class AA {
    String name;
    public void swap(int a,int b){
        System.out.println("\na和b交换前的值\na=" + a + "\tb=" + b);//a=10 b=20
        //完成了 a 和 b的交换
        int tmp = a;
        a = b;
        b = tmp;
        System.out.println("\na和b交换后的值\na=" + a + "\tb=" + b);//a=20 b=10
    }
}
//******************************************************************************************//
//***********************************************213*****************************************//
//******************************************************************************************//
public class MethodParameter02 {
    public static void main(String[] args) {

        B b = new B();
         int[] arr = {1, 2, 3};
         b.test100(arr);   调用方法---->开辟独立的：test100栈空间  arr--->arr首元素的地址

         System.out.println(" main的 arr数组 ");

         for(int i = 0; i < arr.length; i++) {   //遍历数组
         	System.out.print(arr[i] + "\t");
         }
         System.out.println();
    }
}

class B {
    public void test100(int[] arr) {    ····核心：arr指向堆里面的arr！！！！ arr可以直接改变数值！！
        arr[0] = 200;    引用传递：arr--->堆里面的数组，修改第一个元素为200
        //遍历数组
        System.out.println(" test100的 arr数组 ");
        for(int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
    }
}
//******************************************************************************************//
//***************************************213************************************************//
//******************************************************************************************//
public class MethodParameter02 {
    public static void main(String[] args) {
        B b = new B();
        Person p = new Person();
        p.name = "jack";
        p.age = 10;
        b.test200(p);     //你想在类中，调用别的类的方法，必须先创建！！
        System.out.println("main 的p.age=" + p.age);//10000
    }
}
class Person {
    String name;
    int age;
}
class B {
    public void test200(Person p) {    ····核心：p指向堆里面的p！！！！ p可以直接改变数值！！
        p.age = 10000; //修改对象属性
    }
//******************************************************************************************//
//****************************************213*************************************************//
public class MethodParameter02 {
    public static void main(String[] args) {
        B b = new B();
        Person p = new Person();
        p.name = "jack";
        p.age = 10;
        b.test200(p);     //你想在类中，调用别的类的方法，必须先创建！！
        测试题:
        test200 执行的是 p = null -----> p.age=10
        System.out.println("main 的p.age=" + p.age);//10
    }
}
    class Person {
        String name;
        int age;
    }
    class B {
        public void test200(Person p) {  ····核心：p指向堆里面的p！！！！ p可以直接改变数值！！
            p = null;   ···                也可以说，p是地址的副本！！
        }
        栈：test200:p----->堆：p      p = null 之后：p----->null而已
        栈：main:p----->堆：p（依旧指向堆里的p）  你不能改变这个事实！
        问题来了：我就是想把main 里面的p指向null，咋做呀？
            我能想到的本办法：让test200里面的p：p.age=null  p.age=0 ，手动初始化哈哈。
            这时候，main里面的p访问p.age时候，等null。

//******************************************************************************************//
//****************************************213********************************************//
//******************************************************************************************//
public class MethodParameter02 {
    public static void main(String[] args) {

        B b = new B();
        Person p = new Person();
        p.name = "jack";
        p.age = 10;
        b.test200(p);

        测试题, 如果 test200 执行的是 p = new Person();..., 下面输出的是10
        System.out.println("main 的p.age=" + p.age);//
    }
}
class Person {
    String name;
    int age;
}
class B {
    public void test200(Person p) {   ····核心：p指向堆里面的p！！！！
        p = new Person();             原本，test200里的p指向堆里的p来着，现在指向新的person 空间了。
        p.name = "tom";               指向新的空间时，无论改变新的空间做什么，都没有意义！！除非，有返回值
        p.age = 99;                   没有返回值，你创造的都是徒劳无功！
    }

}
//******************************************************************************************//
//***************************************214************************************************//
//******************************************************************************************//
public class MethodExercise02 {
    public static void main(String[] args) {

        Person p = new Person();
        p.name = "milan";
        p.age = 100;
        //创建tools
        MyTools tools = new MyTools();
        Person p2 = tools.copyPerson(p);

        //到此 p 和 p2是Person对象，但是是两个独立的对象，属性相同
        System.out.println("p的属性 age=" + p.age  + " 名字=" + p.name);
        System.out.println("p2的属性 age=" + p2.age  + " 名字=" + p2.name);
        //这里老师提示： 可以同 对象比较看看是否为同一个对象
        System.out.println(p == p2);//false   因为，p和p2的地址不同！
    }
}

class Person {
    String name;
    int age;
}

class MyTools {
    编写一个方法copyPerson，可以复制一个Person对象，返回复制的对象。克隆对象，
    注意要求得到新对象和原来的对象是两个独立的对象，只是他们的属性相同

    public Person copyPerson(Person p) {     ····核心：p指向堆里面的p！！！！
        Person p2 = new Person();
        p2.name = p.name; //p从堆里面的p把name给新的p2
        p2.age = p.age; //p从堆里面的p把age给新的p2
        return p2;
    }
}
//******************************************************************************************//
//*******************************************217********************************************//
//******************************************************************************************//
public class Recursion01 {
    public static void main(String[] args) {

        T t1 = new T();
        t1.test(4);//输出什么？ n=2 n=3 n=4
        int res = t1.factorial(5);
        System.out.println("5的阶乘 res =" + res);
    }
}

class T {
    //分析
    public  void test(int n) {
        if (n > 2) {
            test(n - 1);
        }           // n=2  n=3 n=4
        System.out.println("n=" + n);
    }
//***********218
    public  void test(int n) {
        if (n > 2) {
            test(n - 1);
        }           // n=2  选择语句，后面的不会输出 System.out.println("n=" + n);
        else{
            System.out.println("n=" + n);
        }

    }

    //factorial 阶乘
    public  int factorial(int n) {
        if (n == 1) {
            return 1;
        } else {
            return factorial(n - 1) * n;
        }
    }



//******************************************************************************************//
//*********************************************220******************************************//
//******************************************************************************************//
public class RecursionExercise01 {
    public static void main(String[] args) {

        T t1 = new T();
         int n = 7;
         int res = t1.fibonacci(n);
         if(res != -1) {   //正常输出了
         	System.out.println("当n="+ n +" 对应的斐波那契数=" + res);
        }
    }
}

class T {

    请使用递归的方式求出斐波那契数1,1,2,3,5,8,13...给你一个整数n，求出它的值是多
    思路分析
    1. 当n = 1 斐波那契数 是1
    2. 当n = 2 斐波那契数 是1
    3. 当n >= 3  斐波那契数 是前两个数的和
    4. 这里就是一个递归的思路


    public int fibonacci(int n) {
        if( n >= 1) {
            if( n == 1 || n == 2) {
                return 1;
            } else {
                return fibonacci(n-1) + fibonacci(n-2);
            }
        } else {
            System.out.println("要求输入的n>=1的整数");
            return -1;
        }
    }

}
//******************************************************************************************//
//******************************************************************************************//
//******************************************************************************************//
public class RecursionExercise01 {
    public static void main(String[] args) {

        T t1 = new T();

        桃子问题
        int day = 0;
        int peachNum = t1.peach(day);
        if(peachNum != -1) {
            System.out.println("第 " + day + "天有" + peachNum + "个桃子");
        }


    }
}
//**************************221**************************
class T {

    猴子吃桃子问题：有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个！
    以后每天猴子都吃其中的一半，然后再多吃一个。当到第10天时，
    想再吃时（即还没吃），发现只有1个桃子了。问题：最初共多少个桃子？

    思路分析 逆推
    1. day = 10 时 有 1个桃子
    2. day = 9 时  有 (day10 + 1) * 2 = 4
    3. day = 8 时  有 (day9 + 1) * 2 = 10
    4. 规律就是  前一天的桃子 = (后一天的桃子 + 1) *2//就是我们的能力
    5. 递归

    public int peach(int day) {
        if(day == 10) {//第10天，只有1个桃
            return 1;
        } else if ( day >= 1 && day <=9 ) {
            return (peach(day + 1) + 1) * 2; //递归，核心：溯回！！！
         //拆开看： return peach(day + 1)-----> return (peach(day + 1) + 1) * 2;
        } else {
            System.out.println("day在1-10");
            return -1;
        }
    }

}
//******************************************************************************************//
//**********************************************222******************************************//
//******************************************************************************************//
public class MiGong {
    public static void main(String[] args) {

        思路
        1. 先创建迷宫，用二维数组表示 int[][] map = new int[8][7];
        2. 先规定 map 数组的元素值: 0 表示可以走 1 表示障碍物

        int[][] map = new int[8][7];

        //3. 将最上面的一行和最下面的一行，全部设置为1
        for(int i = 0; i < 7; i++) {
            map[0][i] = 1;
            map[7][i] = 1;
        }
        //4.将最右面的一列和最左面的一列，全部设置为1
        for(int i = 0; i < 8; i++) {
            map[i][0] = 1;
            map[i][6] = 1;
        }
        map[3][1] = 1;
        map[3][2] = 1;
        map[2][2] = 1; //测试回溯
        // map[2][1] = 1;
        // map[2][2] = 1;
        // map[1][2] = 1;

        //输出当前的地图
        System.out.println("=====当前地图情况======");
        for(int i = 0; i < map.length; i++) {
            for(int j = 0; j < map[i].length; j++) {
                System.out.print(map[i][j] + " ");//输出一行
            }
            System.out.println();
        }

        //使用findWay给老鼠找路
        T t1 = new T();
        //下右上左
        t1.findWay(map, 1, 1);

        System.out.println("\n====找路的情况如下=====");

        for(int i = 0; i < map.length; i++) {
            for(int j = 0; j < map[i].length; j++) {
                System.out.print(map[i][j] + " ");//输出一行
            }
            System.out.println();
        }




    }
}

class T  {

    //使用递归回溯的思想来解决老鼠出迷宫

    //老韩解读
    //1. findWay方法就是专门来找出迷宫的路径
    //2. 如果找到，就返回 true ,否则返回false
    //3. map 就是二维数组，即表示迷宫
    //4. i,j 就是老鼠的位置，初始化的位置为(1,1)
    //5. 因为我们是递归的找路，所以我先规定 map数组的各个值的含义
    //   0 表示可以走 1 表示障碍物 2 表示可以走 3 表示走过，但是走不通是死路
    //6. 当map[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;
            }
        }
    }

    修改找路策略，看看路径是否有变化
    下->右->上->左 ==> 上->右->下->左
    public boolean findWay2(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(findWay2(map, i - 1, j)) {//先走上
                    return true;
                } else if(findWay2(map, i, j + 1)){//右
                    return true;
                } else if(findWay2(map, i+1, j)) {//下
                    return true;
                } else if(findWay2(map, i, j-1)){//左
                    return true;
                } else {
                    map[i][j] = 3;
                    return false;
                }
            } else { //map[i][j] = 1 , 2, 3
                return false;
            }
        }
    }
}
//******************************************************************************************//
//*******************************************226******************************************//
//******************************************************************************************//
public class HanoiTower {

    public static void main(String[] args) {
        Tower tower = new Tower();
        tower.move(64, 'A', 'B', 'C');
    }
}

class Tower {

    //方法
    //num 表示要移动的个数, a, b, c 分别表示A塔，B 塔, C 塔
    public void move(int num , char a, char b ,char c) {
        //如果只有一个盘 num = 1
        if(num == 1) {
            System.out.println(a + "->" + c);
        } else {
            //如果有多个盘，可以看成两个 , 最下面的和上面的所有盘(num-1)
            //(1)先移动上面所有的盘到 b, 借助 c
            move(num - 1 , a, c, b);
            //(2)把最下面的这个盘，移动到 c
            System.out.println(a + "->" + c);
            //(3)再把 b塔的所有盘，移动到c ,借助a
            move(num - 1, b, a, c);
        }
    }
}
//******************************************************************************************//
//*****************************************228*********************************************//
//******************************************************************************************//
public class OverLoad01 {
    public static void main(String[] args) {
         体现了------>方法的重载
         System.out.println(100);
         System.out.println("hello,world");
         System.out.println('h');
         System.out.println(1.1);
         System.out.println(true);

        MyCalculator mc = new MyCalculator();
        System.out.println(mc.calculate(1, 2));
        System.out.println(mc.calculate(1.1, 2));
        System.out.println(mc.calculate(1, 2.1));
    }
}
//**********************229************
        class MyCalculator  {

            下面的四个 calculate方法构成了重载

            两个整数的和
            public int calculate(int n1, int n2)  {
                System.out.println("calculate(int n1, int n2) 被调用");
                return n1 + n2;
            }
            // 跟返回类型无关！！仍然是，重复定义！！
            public void calculate(int n1, int n2)  {
                System.out.println("calculate(int n1, int n2) 被调用");
                return ;
            }

            没有构成方法重载, 仍然是错误的，因为是方法的"重复定义"
             public void calculate(int n1, int n2)  {
             	System.out.println("calculate(int n1, int n2) 被调用");
             	int res =  n1 + n2;
             }

            看看下面是否构成重载, 没有构成，而是方法的"重复定义",就错了
             public int calculate(int a1, int a2)  {
          // public void calculate(int n1, int n2)
             	System.out.println("calculate(int n1, int n2) 被调用");
             	return a1 + a2;
             }

            一个整数，一个double的和
            public double calculate(int n1, double n2) {
                return n1 + n2;
            }

            一个double ,一个Int和
            public double calculate(double n1, int n2) {
                System.out.println("calculate(double n1, int n2) 被调用..");
                return n1 + n2;
            }

            三个int的和
            public int calculate(int n1, int n2,int n3) {
                return n1 + n2 + n2;
            }

        }
//******************************************************************************************//
//**********************************************232******************************************//
//******************************************************************************************//
        编写程序，类Methods中定义三个重载方法并调用。方法名为m。
        三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别执行平方运算并输出结果，
        相乘并输出结果，输出字符串信息。在主类的main ()方法中分别用参数区别调用三个方法

    public class OverLoadExercise {
    public static void main(String[] args) {

        在主类的main ()方法中分别用参数区别调用三个方法
        Methods method = new Methods();
        method.m(10);//100
        method.m(10, 20);//200
        method.m("韩顺平教育 hello");//字符串信息
    }
}
        //分析
        //1 方法名 m
        //2 形参 (int)
        //3.void
        public void m(int n) {
            System.out.println("平方=" + (n * n));
        }

        //1 方法名 m
        //2 形参 (int, int)
        //3.void
        public void m(int n1, int n2) {
            System.out.println("相乘=" + (n1 * n2));
        }

        //1 方法名 m
        //2 形参 (String)
        //3.void
        public void m(String str) {
            System.out.println("传入的str=" + str);
        }
    }

//******************************************************************************************//
//**********************************************233******************************************//
//******************************************************************************************//
        定义三个重载方法max()，第一个方法，返回两个int值中的最大值，
        第二个方法，返回两个double值中的最大值，第三个方法，
        返回三个double值中的最大值，并分别调用三个方法

            测试
        System.out.println(method.max(10, 24)); // 24
        System.out.println(method.max(10.0, 21.4)); // 21.4
        System.out.println(method.max(10.0, 1.4, 30.0)); // 30.0
class Methods {

    //分析
    //1 方法名 max
    //2 形参 (int,int)
    //3.int
    public int max(int n1, int n2) {
        return n1 > n2 ? n1 : n2;
    }

    //分析
    //1 方法名 max
    //2 形参 (double,double)
    //3.double
    public double max(double n1, double n2) {
        return n1 > n2 ? n1 : n2;
    }

    //分析
    //1 方法名 max
    //2 形参 (double,double,double)
    //3.double
    public double max(double n1, double n2, double n3) {

        System.out.println("max(double n1, double n2, double n3)");
        //求出n1 和  n2的最大值
        double max1 = n1 > n2 ? n1 : n2;
        return max1 > n3 ? max1 : n3;
    }

    细节： ( 1 , 2 , 3.4 )------>(double n1, double n2, double n3)
    如果有：(int n1, int n2 ,double n3),那就这个。
    如果有，那就直接走那个。没有的话，可以类型转换

    public double max(double n1, double n2, int n3) {

        System.out.println("max(double n1, double n2, int n3)");
        //求出n1 和  n2的最大值
        double max1 = n1 > n2 ? n1 : n2;
        return max1 > n3 ? max1 : n3;
    }

//******************************************************************************************//
//*******************************************234********************************************//
//******************************************************************************************//
public class VarParameter01 {
    public static void main(String[] args) {

        HspMethod m = new HspMethod();
        System.out.println(m.sum(1, 5, 100)); //106
        System.out.println(m.sum(1,19)); //20
    }
}

class HspMethod {
    可以计算 2个数的和，3个数的和 ， 4. 5， 。。
    可以使用方法重载
     public int sum(int n1, int n2) {//2个数的和
     	return n1 + n2;
     }
     public int sum(int n1, int n2, int n3) {//3个数的和
     	return n1 + n2 + n3;
     }
     public int sum(int n1, int n2, int n3, int n4) {//4个数的和
     	return n1 + n2 + n3 + n4;
     }

    .....
    上面的三个方法名称相同，功能相同, 参数个数不同-> 使用可变参数优化
    老韩解读
    1. int... 表示接受的是可变参数，类型是int ,即可以接收多个int(0-多)
    2. 使用可变参数时，可以当做数组来使用 即 nums 可以当做数组
    3. 遍历 nums 求和即可

    public int sum(int... nums) {     //当做数组来使用


        System.out.println("接收的参数个数=" + nums.length);
        int res = 0;
        for(int i = 0; i < nums.length; i++) {
            res += nums[i];
        }
        return res;
    }
}
//******************************************************************************************//
//*******************************************235*******************************************//
//******************************************************************************************//
public class VarParameterDetail {
    public static void main(String[] args) {


        细节: 可变参数的实参可以为数组
        int[] arr = {1, 2, 3};
        T t1 = new T();
        t1.f1(arr);
    }
}

class T {

    public void f1(int... nums) {
        System.out.println("长度=" + nums.length);
    }

    细节: 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
    public void f2(String str, double... nums) {  //对！！

    }

    细节: 一个形参列表中只能出现一个可变参数
     public void f3(int... nums1, double... nums2) {  //错的

     }
}
//******************************************************************************************//
//*******************************************236*******************************************//
//******************************************************************************************//
public class VarParameterExercise {
    public static void main(String[] args) {
        HspMethod hm = new HspMethod();
        System.out.println(hm.showScore("milan" , 90.1, 80.0 ));
        System.out.println(hm.showScore("terry" , 90.1, 80.0,10,30.5,70 ));
    }
}

class HspMethod  {

有三个方法，分别实现返回姓名和两门课成绩(总分)，
返回姓名和三门课成绩(总分)，返回姓名和五门课成绩（总分）。
封装成一个可变参数的方法

    分析1. 方法名 showScore  2. 形参(String ,double... ) 3. 返回String

    public String  showScore(String name ,double... scores ) {

        double totalScore = 0;
        for(int i = 0; i < scores.length; i++) {
            totalScore += scores[i];
        }
        return name + " 有 " +scores.length + "门课的成绩总分为=" + totalScore;
    }
}
//******************************************************************************************//
//******************************************237*******************************************//
//******************************************************************************************//
public class VarScope {
    public static void main(String[] args) {
    }
}
class Cat {
    全局变量：也就是属性，作用域为整个类体 Cat类：cry eat 等方法使用属性
    属性在定义时，可以直接赋值
    int age = 10; //指定的值是 10

    全局变量(属性)可以不赋值，直接使用，因为有默认值，
    double weight;  //默认值是0.0

    public void hi() {
        //局部变量必须赋值后，才能使用，因为没有默认值
        int num ;
        System.out.println("num=" + num);  //报错！

        String address = "北京的猫";
        System.out.println("address=" + address);
        System.out.println("weight=" + weight);//属性
    }
    {
        int num=4;   //这个 num 只能在这里用！！
    }

    public void cry() {
        //1. 局部变量一般是指在成员方法中定义的变量
        //2. n 和  name 就是局部变量
        //3. n 和 name的作用域在 cry方法中
        int n = 10;
        String name = "jack";
        System.out.println("在cry中使用属性 age=" + age);
    }

    public void eat() {
        System.out.println("在eat中使用属性 age=" + age);
        //System.out.println("在eat中使用 cry的变量 name=" + name);//错误
    }
}
//******************************************************************************************//
//*******************************************239*******************************************//
//******************************************************************************************//
public class VarScopeDetail {
    public static void main(String[] args) {
        Person p1 = new Person();

    属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。
    局部变量，生命周期较短，伴随着它的代码块的执行而创建， 伴随着代码块的结束而销毁。

        p1.say();//当执行say方法时，say方法的局部变量比如name,会创建，当say执行完毕后
        name局部变量就销毁,但是属性(全局变量)仍然可以使用

        T t1 = new T();
        t1.test(); //第1种跨类访问对象属性的方式

        t1.test2(p1);//第2种跨类访问对象属性的方式
    }
}

class T {

    全局变量/属性：可以被本类使用，或其他类使用（通过对象调用)
    public void test() {
        Person p1 = new Person();
        System.out.println(p1.name);//jack
    }

    public void test2(Person p) {
        System.out.println(p.name);//jack
    }
}

class Person {

    public int age = 20;     细节: 属性可以加修饰符(public protected private..)
    String name = "jack";
    public void say() {
        细节 属性和局部变量可以重名，访问时遵循就近原则
        public String name = "king";    局部变量不能加修饰符!!错！！
        System.out.println("say() name=" + name);
    }

    public void hi() {
        String address = "北京";
        String address = "上海";//错误,重复定义变量
        String name = "hsp";//可以
    }
}
//******************************************************************************************//
//*****************************************241*********************************************//
//******************************************************************************************//
public class Constructor01 {
    public static void main(String[] args) {
        //当我们new 一个对象时，直接通过构造器指定名字和年龄
        Person p1 = new Person("smith", 80);
        System.out.println("p1的信息如下");
        System.out.println("p1对象name=" + p1.name);//smith
        System.out.println("p1对象age=" + p1.age);//80
    }
}

  在创建人类的对象时，就直接指定这个对象的年龄和姓名
class Person {
    String name;
    int age;
    构造器
    1. 构造器没有返回值, 也不能写void
    2. 构造器的名称和类Person一样
    3. (String pName, int pAge) 是构造器形参列表，规则和成员方法一样

    public  Person(String pName, int pAge) {
        System.out.println("构造器被调用~~ 完成对象的属性初始化");
        name = pName;
        age = pAge;
    }
}
//******************************************************************************************//
//*****************************************243********************************************//
//******************************************************************************************//
public class ConstructorDetail {
    public static void main(String[] args) {
        Person p1 = new Person("king", 40);//第1个构造器
        Person p2 = new Person("tom");//第2个构造器

        Dog dog1 = new Dog();//使用的是默认的无参构造器
    }
}
class Dog {
    如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器)
    //使用javap指令 反编译看看

//    默认构造器
//    Dog() {
//
//    }

    一旦定义了自己的构造器,默认的构造器就“覆盖”了，就“不能再使用默认的无参构造器”
            ----->也就是说，不能 Dog a=new Dog()！！！
    “除非” “显式”的定义一下,即:  Dog(){}  写 (这点很重要)

    public Dog(String dName) {
        //...
    }
    Dog() { //显式的定义一下 无参构造器

    }
}

class Person {               构造器：相当于特殊的方法，不用返回类型
    String name;
    int age;//默认0
    //第1个构造器
    public Person(String pName, int pAge) {
        name = pName;
        age = pAge;
    }
    //第2个构造器, 只指定人名，不需要指定年龄
    public Person(String pName) {
        name = pName;
    }
}
//******************************************************************************************//
//********************************************244*******************************************//
//******************************************************************************************//
public class ConstructorExercise {
    public static void main(String[] args) {
        Person p1 = new Person();//无参构造器
        System.out.println("p1的信息 name=" + p1.name + " age=" + p1.age);  //name = null, age = 18

        Person p2 = new Person("scott", 50);
        System.out.println("p2的信息 name=" + p2.name + " age=" + p2.age);  //name = scott, age = 50

    }
}

  在前面定义的Person类中添加两个构造器:
  第一个无参构造器：利用构造器设置所有人的age属性初始值都为18
  第二个带pName和pAge两个参数的构造器：使得每次创建Person对象的同时初始化对象的age属性值和name属性值。
  分别使用不同的构造器，创建对象.

class Person {
    String name;//默认值 null
    int age;//默认 0
    //第一个无参构造器：利用构造器设置所有人的age属性初始值都为18
    public Person() {
        age = 18;//
    }
    //第二个带pName和pAge两个参数的构造器
    public Person(String pName, int pAge) {
        name = pName;
        age = pAge;
    }
}
//******************************************************************************************//
//************************************245**************************************************//
//******************************************************************************************//
class person {                    person p ：栈里面申明p：p能接受 person 类的地址
    int age=90;                   new person：堆里面创造person 空间，默认值：0 null
    String name;                               显示初始化：90 null
    person (String n,int a){                   构造器初始化： apple 10
        name=n;
        age=a;                     核心：对象的属性初始化！！！
    }
}
person p=new person ("apple",10)

//******************************************************************************************//
//*********************************246 247****************************************************//
//******************************************************************************************//
public class This01 {
    public static void main(String[] args) {

        Dog dog1 = new Dog("大壮", 3);
        System.out.println("dog1的hashcode=" + dog1.hashCode());
        dog1.info();                //dog1.hashCode()==this.hashCode()

        System.out.println("============");
        Dog dog2 = new Dog("大黄", 2);
        System.out.println("dog2的hashcode=" + dog2.hashCode());
        dog2.info();                     //dog2.hashCode()==this.hashCode()
    }
}

class Dog{ //类

    String name;
    int age;

     public Dog(String dName, int  dAge){   //构造器
     	name = dName;
     	age = dAge;
     }

    如果我们构造器的形参，能够直接写成属性名，就更好了
    但是出现了一个问题，根据变量的作用域原则
    构造器的name 是局部变量，而不是属性
    构造器的age  是局部变量，而不是属性
    ==> 引出this关键字来解决

    public Dog(String name, int  age){//构造器

        this.name = name;   //this.name 就是当前对象的属性name
        this.age = age;     //this.age 就是当前对象的属性age
        System.out.println("this.hashCode=" + this.hashCode());
    }

    public void info(){//成员方法,输出属性x信息
        System.out.println("this.hashCode=" + this.hashCode());
        System.out.println(name + "\t" + age + "\t");
    }
}

//******************************************************************************************//
//**********************************************250*****************************************//
//******************************************************************************************//
public class ThisDetail {
    public static void main(String[] args) {

        // T t1 = new T();
        // t1.f2();
        T t2 = new T();
        t2.f3();

    }
}

class T {

    String name = "jack";
    int num = 100;


        细节: 访问构造器语法：this(参数列表);
        注意只能在构造器中使用(即只能在构造器中访问另外一个构造器)

        注意： 访问构造器语法：this(参数列表); 必须放置第一条语句

    public T() {
        //这里去访问 T(String name, int age) 构造器
        this("jack", 100);
        System.out.println("T() 构造器");

    }

    public T(String name, int age) {

        System.out.println("T(String name, int age) 构造器");
    }

    //this关键字可以用        来访问本类的属性
    public void f3() {
        String name = "smith";
        //传统方式
        System.out.println("name=" + name + " num=" + num);//smith  100
        //也可以使用this访问属性
        System.out.println("name=" + this.name + " num=" + this.num);//jack 100
    }
    //细节: 访问成员方法的语法：this.方法名(参数列表);
    public void f1() {

        System.out.println("f1() 方法..");
    }

    public void f2() {
        System.out.println("f2() 方法..");
        //调用本类的 f1
        //第一种方式
        f1();
        //第二种方式
        this.f1();
    }

}
//******************************************************************************************//
//***************************************251************************************************//
//******************************************************************************************//
public class TestPerson {

    //编写一个main方法
    public static void main(String[] args) {

        Person p1 = new Person("mary", 20);
        Person p2 = new Person("mary", 20);

        System.out.println("p1和p2比较的结果=" + p1.compareTo(p2));
    }
}      核心：p1.compareTo(p2)  用了p1的对象，那么this.name 就是p1的。 name 是p2传进来的
          p1.compareTo(p2) == p2.compareTo(p1)------> 这里就用的p2的属性，都是等价的！
    定义Person类，里面有name、age属性，并提供compareTo比较方法，
    用于判断是否和另一个人相等，提供测试类TestPerson用于测试,
    名字和年龄完全一样，就返回true, 否则返回false

class Person {
    String name;
    int age;
    //构造器
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //compareTo比较方法
    public boolean compareTo(Person p) {


        //名字和年龄完全一样
        // if(this.name.equals(p.name) && this.age == p.age) {
        // 	return true;
        // } else {
        // 	return false;
        // }
        简化成如下：
        return this.name.equals(p.name) && this.age == p.age;
    }
}
//******************************************************************************************//
//**************************************252*************************************************//
//******************************************************************************************//
    public class Homework01 {
        public static void main(String[] args) {
            A01 a01 = new A01();

            double[] arr = {1, 1.4, -1.3, 89.8, 123.8 , 66}; //;{};
            double[] arr = {};
            double[] arr = null ;
                                      Double =double + null
            Double res = a01.max(arr);
            if(res != null) {
                System.out.println("arr的最大值=" + res);
            } else {
                System.out.println("arr的输入有误, 数组不能为null, 或者{}");
            }
        }
    }

    编写类A01，定义方法max，实现求某个double数组的最大值，并返回

    1. 类名 A01
    2. 方法名 max
    3. 形参 (double[])
    4. 返回值 double

    先完成正常业务，然后再考虑代码健壮性

    class A01 {                            Double =double + null
        public Double max(double[] arr) {

            老韩先判断arr是否为null,然后再判断 length 是否>0   顺序很重要！！！
            arr.length > 0 && arr!= null  ------> null.length 错误！！！

            if( arr!= null && arr.length > 0 ) {    //保证arr至少有一个元素


                double max = arr[0];//假定第一个元素就是最大值
                for(int i = 1; i < arr.length; i++) {
                    if(max < arr[i]) {
                        max = arr[i];
                    }
                }
                return max;  //double
            } else {
                return null;
            }
        }
    }
//******************************************************************************************//
//*****************************************253*********************************************//
//******************************************************************************************//
        public class Homework02 {
            public static void main(String[] args) {

                String[] strs = {"jack", "tom", "mary","milan"};
                A02 a02 = new A02();
                int index = a02.find("milan", strs);   //a02 的 find 方法
                System.out.println("查找的index=" + index);
            }
        }

        编写类A02，定义方法find，实现查找某字符串是否在字符串数组中，并返回索引，如果找不到，返回-1
        1. 类名 A02
        2. 方法名 find
        3. 返回值 int
        4. 形参 (String , String[])
        自己补充代码健壮性

        class A02 {

            public int find(String findStr, String[] strs) { //直接遍历字符串数组，如果找到，则返回索引
                for(int i = 0; i < strs.length; i++) {
                    if(findStr.equals(strs[i])) {     //引用类型，用equals
                        return i;      //索引
                    }
                }
                return -1;   //如果没有，就返回-1
            }
        }
//******************************************************************************************//
//*********************************************254****************************************//
//******************************************************************************************//
        public class Homework03 {
            public static void main(String[] args) {

                Book book = new Book("笑傲江湖", 300);
                book.info();
                book.updatePrice();//更新价格
                book.info();
            }
        }

        编写类Book,  定义方法updatePrice，实现更改某本书的价格，
        具体：如果价格>150,则更改为150，如果价格>100,更改为100，否则不变

        分析
        1. 类名 Book
        2. 属性 price, name
        3. 方法名 updatePrice
        4. 形参 ()
        5. 返回值 void
        6. 提供一个构造器


        class Book {
            String name;
            double price;
            public Book(String name, double price) {
                this.name = name;
                this.price = price;
            }
            public void updatePrice() {
                //如果方法中，没有 price 局部变量, this.price 等价 price
                if(price > 150) {                      this.price > 150  也行！！
                    price = 150;
                } else if(price > 100 ) {
                    price = 100;
                }
            }

            //显示书籍情况
            public void info() {
                System.out.println("书名=" + this.name + " 价格=" + this.price);
            }
        }
//******************************************************************************************//
//***********************************************255**************************************//
//******************************************************************************************//
        public class Homework04 {
            public static void main(String[] args) {

                int[] oldArr = {10, 30, 50};
                int[] newArr = oldArr ;------>引用！！！不是复制！！

                A03 a03 = new A03();
                int[] newArr = a03.copyArr(oldArr);   // ---->  A03 a03 =newArr;
                         newArr 是复制，独立的！！

                System.out.println("==返回的newArr元素情况==");  //遍历newArr,验证
                for(int i = 0; i < newArr.length; i++) {
                    System.out.print(newArr[i] + "\t");
                }
            }
        }

        /*
        编写类A03, 实现数组的复制功能copyArr，输入旧数组，返回一个新数组，元素和旧数组一样
         */
        class A03 {
            public int[] copyArr(int[] oldArr) {

                int[] newArr = new int[oldArr.length];  //在堆中，创建一个长度为 oldArr.length 数组
                for(int i = 0; i < oldArr.length; i++) {   //遍历 oldArr,将元素拷贝到 newArr
                    newArr[i] = oldArr[i];
                }
                return newArr;

            }
        }
//******************************************************************************************//
//****************************************256***********************************************//
//******************************************************************************************//
        public class Homework05 {

            public static void main(String[] args) {
                Circle circle = new Circle(3);    //初始化：radious=3的类
                System.out.println("面积=" + circle.area());
                System.out.println("周长=" + circle.len());
            }
        }

        定义一个圆类Circle, 定义属性：半径，提供显示圆周长功能的方法， 提供显示圆面积的方法

        class Circle {
            double radius;

            public Circle(double radius) {    //构造器
                this.radius = radius;
            }

            public double area() { //面积                 Math.PI
                return Math.PI * radius * radius;
            }

            public double len() { //周长
                return 2 * Math.PI * radius;
            }
        }
//******************************************************************************************//
//********************************************257******************************************//
//******************************************************************************************//
        public class Homework06 {
            public static void main(String[] args) {


                Cale cale = new Cale(2, 10);
                System.out.println("和=" + cale.sum());
                System.out.println("差=" + cale.minus());
                System.out.println("乘=" + cale.mul());
               // Double = double + null
                Double divRes = cale.div();
                if(divRes != null) {
                    System.out.println("除=" + divRes);
                }
            }
        }

         编程创建一个Cale计算类，在其中定义2个变量表示两个操作数，
         定义四个方法实现求和、差、乘、商(要求除数为0的话，要提示) 并创建两个对象，分别测试

        class Cale {
            double num1;
            double num2;
            public Cale(double num1, double num2) {
                this.num1 = num1;
                this.num2 = num2;
            }

            public double sum() {
                return num1 + num2;
            }     //和

            public double minus() {
                return num1 - num2;
            }   //差

            public double mul() {
                return num1 * num2;
            }     //乘积

            //除法 考虑分母！！！       Double = double + null
            public Double div() {
                                 错误的时候，不想返回。但是，要求有返回值得时候，用Double！！
                if(num2 == 0) {   //判断：分母不能等于0！！
                    System.out.println("num2 不能为0");
                    return null;
                } else {
                    return num1 / num2;
                }
            }
        }
//******************************************************************************************//
//******************************************258**********************************************//
//******************************************************************************************//

        public class Test {   //公有类
            int count = 9; //属性
            public void count1() { //Test类的成员方法
                count=10;//这个count就是属性  改成 10
                System.out.println("count1=" + count); //10
            }
            public void count2() {  //Test类的成员方法
                System.out.println("count1=" + count++);
            }

            //这是Test类的main方法, 任何一个类，都可有main
            public static void main(String args[]) {

                1.  new Test()	是匿名对象， 匿名对象只用一次，一次使用后就销毁！！因为没人指向他
                2.  new Test().count1() 创建好匿名对象后, 就调用count1()
                new Test().count1();

                Test t1= new Test();
                t1.count2();
                t1.count2();
            }
        }

//******************************************************************************************//
//******************************************259*********************************************//
//******************************************************************************************//
        public class Homework10 {
            public static void main(String[] args) {
            }
        }

        class Demo{
            int i=100;
            public void m(){
                int j=i++;
                System.out.println("i="+i);
                System.out.println("j="+j);
            }
        }
        class Test{
            public static void main(String[] args){//运行它
                Demo d1=new Demo();
                Demo d2 = d1;
                d2.m();    //j=100  i=101   细节：调用的方法：栈！！！
                System.out.println(d1.i);  // i=101
                System.out.println(d2.i);  // i=101
            }
        }

//******************************************************************************************//
//***************************************260*************************************************//
//******************************************************************************************//

        public class Homework12 {

            //编写一个main方法
            public static void main(String[] args) {
            }
        }
        /*
        创建一个Employee类，
        属性有(名字，性别，年龄，职位，薪水)， 提供3个构造方法，可以初始化
        (1) (名字，性别，年龄，职位，薪水),
        (2) (名字，性别，年龄) (3) (职位，薪水), 要求充分复用构造器
         */
        class Employee {
            //名字，性别，年龄，职位，薪水
            String name;
            char gender;
            int age;
            String job;
            double sal;
            //因为要求可以复用构造器，因此老韩先写属性少的构造器
            //职位，薪水
            public Employee(String job, double sal) {
                this.job = job;
                this.sal = sal;
            }
            //名字，性别，年龄
            public Employee(String name, char gender, int age) {
                this.name = name;
                this.gender = gender;
                this.age = age;
            }
            //名字，性别，年龄，职位，薪水
            构造器的“复用” ！！！
            public Employee(String job, double sal, String name, char gender, int age) {
                this(name, gender, age);//使用到 前面的 构造器
                this(job, sal);  //不行！！构造器里面，调用this，this必须在第一行！！---->只能用一个this！！！
                this.job = job;
                this.sal = sal;
            }


        }
//******************************************************************************************//
//************************************************261**************************************//
//******************************************************************************************//
        public class Homework13 {
            public static void main(String[] args) {

                Circle c = new Circle();
                PassObject po = new PassObject();
                po.printAreas(c, 5);
            }
        }

        题目要求：
        (1) 定义一个Circle类，包含一个double型的radius属性代表圆的半径，findArea()方法返回圆的面积。
        (2) 定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义如下：
             public void printAreas(Circle c, int times) 	//方法签名/声明
        (3) 在printAreas方法中打印输出1到times之间的每个整数半径值，以及对应的面积。例如，times为5，则输出半径1，2，3，4，5，以及对应的圆面积。
        (4) 在main方法中调用printAreas()方法，调用完毕后输出当前半径值。程序运行结果如图所示


        class Circle { //类
            double radius;//半径

            public Circle() { //无参构造器
            }

            //public Circle(double radius) {
                this.radius = radius;
            }
            public double findArea() {//返回面积
                return Math.PI * radius * radius;
            }
            //添加方法setRadius, 修改对象的半径值
            public void setRadius(double radius) {
                this.radius = radius;
            }
        }
        class PassObject {
            public void printAreas(Circle c, int times) {
                System.out.println("radius\tarea");
                for(int i = 1; i <= times; i++) {//输出1到times之间的每个整数半径值
                    c.setRadius(i) ; //修改c 对象的半径值------> 通过方法改变属性（间接改变）（封装）

                    也可以： c.radius=i;  //每次改变一次属性-----> 直接改变属性！！

                    也可以：Circle circle = new Circle(i);  //每次创建一个circle，直接访问circle。 c=new Circle(i)也行
                                                    // 这样的话，只需要传一个 times就行！！
                    System.out.println((double)i + "\t" + circle.findArea());

                    System.out.println((double)i + "\t" + c.findArea());
                }
            }
        }

//******************************************************************************************//
//***********************************************262***************************************//
//******************************************************************************************//
import java.util.Random;
import java.util.Scanner;

    /*
    请编写一个猜拳的游戏
    有个人 Tom，设计他的成员变量. 成员方法, 可以电脑猜拳. 电脑每次都会随机生成 0, 1, 2
    0 表示 石头 1 表示剪刀 2 表示 布
    并要可以显示 Tom的输赢次数（清单）, 假定 玩三次.
     */
    // 测试类,主类
    public class MoraGame {

        // 测试
        public static void main(String[] args) {
            // 创建一个玩家对象
            Tom t = new Tom();
            // 用来记录最后输赢的次数
            int isWinCount = 0;

            // 创建一个二维数组，用来接收局数，Tom出拳情况以及电脑出拳情况
            int[][] arr1 = new int[3][3];
            int j = 0;

            // 创建一个一维数组，用来接收输赢情况
            String[] arr2 = new String[3];

            Scanner scanner = new Scanner(System.in);
            for (int i = 0; i < 3; i++) {   //比赛3次
                // 获取玩家出的拳
                System.out.println("请输入你要出的拳（0-拳头，1-剪刀，2-布）：");
                int num = scanner.nextInt();
                t.setTomGuessNum(num);
                int tomGuess = t.getTomGuessNum();
                arr1[i][j + 1] = tomGuess;

                // 获取电脑出的拳
                int comGuess = t.computerNum();
                arr1[i][j + 2] = comGuess;

                // 将玩家猜的拳与电脑做比较
                String isWin = t.vsComputer();
                arr2[i] = isWin;
                arr1[i][j] = t.count;

                // 对每一局的情况进行输出
                System.out.println("=========================================");
                System.out.println("局数\t玩家的出拳\t电脑的出拳\t输赢情况");
                System.out.println(t.count + "\t" + tomGuess + "\t\t" + comGuess + "\t\t" + t.vsComputer());
                System.out.println("=========================================");
                System.out.println("\n\n");
                isWinCount = t.winCount(isWin);
            }

            // 对游戏的最终结果进行输出
            System.out.println("局数\t玩家的出拳\t电脑的出拳\t\t输赢情况");
            for (int a = 0; a < arr1.length; a++) {
                for (int b = 0; b < arr1[a].length; b++) {
                    System.out.print(arr1[a][b] + "\t\t\t");
                }

                System.out.print(arr2[a]);
                System.out.println();
            }
            System.out.println("你赢了" + isWinCount + "次");
        }

    }

    // Tom类
    class Tom {     // 核心代码
        // 玩家出拳的类型
        int tomGuessNum; //0,1,2
        // 电脑出拳的类型
        int comGuessNum; //0,1,2
        // 玩家赢的次数
        int winCountNum;
        // 比赛的次数
        int count = 1;   //一共比赛3次


        public void showInfo() {
            //....
        }

        /**
         * 电脑随机生成猜拳的数字的方法
         * @return
         */
        public int computerNum() {
            Random r = new Random();
            comGuessNum = r.nextInt(3);      // 方法 返回 0-2的随机数
            // System.out.println(comGuessNum);
            return comGuessNum;
        }

        /**
         * 设置玩家猜拳的数字的方法
         * @param tomGuessNum
         */
        public void setTomGuessNum(int tomGuessNum) {
            if (tomGuessNum > 2 || tomGuessNum < 0) {
                //抛出一个异常, 李同学会写，没有处理
                throw new IllegalArgumentException("数字输入错误");
            }
            this.tomGuessNum = tomGuessNum;
        }

        public int getTomGuessNum() {
            return tomGuessNum;
        }

        /**
         * 比较猜拳的结果
         * @return 玩家赢返回true，否则返回false
         */
        public String vsComputer() {
            //比较巧
            if (tomGuessNum == 0 && comGuessNum == 1) {
                return "你赢了";
            } else if (tomGuessNum == 1 && comGuessNum == 2) {
                return "你赢了";
            } else if (tomGuessNum == 2 && comGuessNum == 0) {
                return "你赢了";
            } else if (tomGuessNum == comGuessNum){
                return "平手";
            } else {
                return "你输了";
            }
        }

        /**
         * 记录玩家赢的次数
         * @return
         */
        public int winCount(String s) {
            count++;    //控制玩的次数
            if (s.equals("你赢了")) {     //统计赢的次数
                winCountNum++;
            }
            return winCountNum;
        }

    }