Java笔记011-类与对象、成员方法、方法递归调用、方法重载、可变参数、作用域、构造方法\构造器、this关键字

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

        //1. new cat()创建一只(猫对象)
        //2. Cat cat1 = new Cat();把创建的猫赋给cat1
        //3. cat1就是一个对象
        Cat cat1 = new Cat();
        cat1.name = "小白";
        cat1.age = 3;
        cat1.color = "白色";
        //创建了第二只猫
        //cat2也是一个对象(猫对象)
        Cat cat2 = new Cat();
        cat2.name = "小黑";
        cat2.age = 6;
        cat2.color = "黑色";

        //访问对象的属性
        System.out.println("第1只猫 " + cat1.name + " " + cat1.age + " " + cat1.color);
        System.out.println("第2只猫 " + cat2.name + " " + cat2.age + " " + cat2.color);

    }
}

//使用面型对象的方式解决养猫问题
//定义一个猫类 Cat -> 自定义的数据类型
class Cat {
    //属性
    String name;//名字
    int age;//年龄
    String color;//颜色
    //行为
}

运行结果

类和对象的区别和联系

通过上面的案例可以看出

1、类是抽象的，概念的，代表一类事物，比如人类,猫类..即它是数据类型

2、对象是具体的,实际的，代表一个具体事物，即是实例.

3、类是对象的模板，对象是类的一个个体，对应一个实例

对象在内存中存在形式

        Cat cat1 = new Cat();
        cat1.name = "小白";
        cat1.age = 12;
        cat1.color = "白色";

属性/成员变量

基本介绍

1、从概念或叫法上看:成员变量=属性=field (即成员艾重定用米衣小禺性的，授课中，统一叫属性)
案例演示: Car(name,price,color)

class Car{
    String name;
    double price;
    String color;
    String[] master;
}

2、属性是类的一个组成部分，一般是基本数据类型，也可是引用类型(对象,数组)。
比如我们前面定义猫类的int age就是属性

注意事项和细节说明

1、属性的定义语法同变量，示例：访问修饰符属性类型属性名;

2、属性的定义类型可以为任意类型，包含基本类型或引用类型

3、属性如果不赋值，有默认值，规则和数组一致。

int0，short 0，byte 0，long 0，float 0.0，double 0.0，char \u0000，boolean false，String null
案例演示：[Person类]

如何创建对象

1、先声明再创建

Cat cat;//声明对象cat
cat = new Cat();//创建

2、直接创建

Cat cat = new Cat();

如何访问属性

基本语法

对象名.属性名;

cat.name;
cat.age;
cat.color;

类和对象的内存分配机制

思考题

定义一个人类(Person)(包括名字，年龄)

Person p1 = new Person();
p1.age = 10;
p1.name = "小明";
Person p2=p1;//把p1赋给了p2，让p2指向p1
p1.age = 80;
System.out.println(p2.age);

Java内存的结构分析

1、栈：一般存放基本数据类型(局部变量)

2、堆：存放对象(Cat cat，数组等)

3、方法区：常量池(常量，比如字符串)，类加载信息

4、示意图[Cat (name, age, price)]

Java创建对象的流程简单分析

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

1、先加载Person类信息(属性和方法信息，只会加载一次)

2、在堆中分配空间，进行默认初始化(看规则)

3、把地址赋给p，p就指向对象

4、进行指定初始化，比如p.name = "jack"; p.age = 10;

练习题，分析画出内存布局图，进行分析

Person a = new Person();
a.age = 10;
a.name = "小明";
Person b;
b = a;
System.out.println(b.name);//小明
b.age = 200;
b = null;
System.out.println(a.age);//200
System.out.println(b.age);//出现异常

成员方法

基本介绍

在某些情况下，我们要需要定义成员方法(简称方法)。

比如人类：除了有一些属性外(年龄，姓名..)，我们人类还有一些行为比如：可以说话、跑步..通过学习，还可以做算术题。这时就要用成员方法才能完成。现在要求对Person类完善。

成员方法快速入门

1、添加speak成员方法，输出我是一只好人

2、添加cal01成员方法，可以计算从1+....+1000的结果

3、添加cal02成员方法，该方法可以接收一个数n，计算从1+..+n 的结果

4、添加getSum成员方法，可以计算两个数的和

public class Method {
    //编写一个main方法
    public static void main(String[] args) {
        //方法使用
        //1.方法写好后，如果不去调用(使用)，不会输出
        //2.先创建对象，然后调用方法即可
        Person p1 = new Person();
        p1.speak();//调用方法
        p1.cal01();
        p1.cal02(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;

    //方法(成员方法)
    //添加speak成员方法，输出"我是一个好人"
    //解读
    //1.public 表示方法是公开
    //2.void 表示方法没有返回值
    //3.speak() speak是方法名，()形参列表
    //4.{} 方法体，可以写要执行的代码
    //5.System.out.println("我是一个好人");表示我们的方法就是输出一句话
    public void speak() {
        System.out.println("我是一个好人");
    }

    //    添加cal01成员方法，可以计算从1+....+1000的结果
    public void cal01() {
        int result = 0;
        for (int i = 1; i <= 1000; i++) {
            result += i;
        }
        System.out.println("cal01方法 计算结果=" + result);
    }

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

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

运行结果

方法的调用机制原理：(重要！-示意图)
提示：画出程序执行过程[getSum]+说明

方法调用小结

1、当程序执行到方法时，就会开辟一个独立的空间(栈空间)
2、当方法执行完毕，或者执行到return语句时，就会返回
3、返回到调用方法的地方
4、返回后，继续执行方法后面的代码
5、当main方法(栈)执行完毕，整个程序退出

为什么需要成员方法

看一个需求

请遍历一个数组，输出数组的各个元素值

解决思路1：

传统方法，使用单个for循环，将数组输出。

解决思路2：

定义一个类MyTools，然后写一个成员方法，调用方法实现

public class Method {
    //编写一个main方法
    public static void main(String[] args) {
        int[][] map = {{0, 0, 1}, {1, 1, 1}, {1, 1, 3}};
        //使用方法完成输出
        MyTools tool = new MyTools();
        //调用方法
        tool.printArr(map);
        tool.printArr(map);
        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.length; j++) {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
    }
}

运行结果

成员方法的好处

1、提高代码的复用性

2、可以将实现的细节封装起来，然后供其他用户调用即可

成员方法的定义

public 返回数据类型 方法名 (参数列表..){
        语句;
        return 返回值;
}

1、形参列表：表示成员方法输入cal(int n)

2、返回数据类型：表示成员方法输出，void表示没有返回值

3、方法主体：表示为了实现某一功能代码块

4、return语句不是必须的

5、提示：结合前面的题示意图来理解

注意事项和使用细节

访问修饰符(作用是控制方法使用的范围)

如果不写默认访问[public,protected,默认,private]

返回类型

1、一个方法最多有一个返回值

2、返回值类型可以为任意类型，包含基本类型或引用类型(数组，对象)

3、如果方法要求有返回数据类型，则方法体中最后的执行语句必须为return值；而且要求返回值类型必须和return的值类型一致或兼容

4、如果方法是void，则方法体中可以没有return语句，或者只写return;

方法名

遵循驼峰命名法，最好见名知意，表达出该功能的意思即可，比如得到两个数的和getSum，开发中按照规范

形参列表

1、一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开，比如 getSum(int n1,int n2)

2、参数类型可以为任意类型，包含基本类型或引用类型，比如 printArr(int[][] map)

3、调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数!

4、方法定义时的参数称为形式参数，简称形参；方法调用时的参数称为实际参数，简称实参，实参和形参的类型要一致或兼容、个数、顺序必须一致!

方法体

里面写完成功能的具体的语句，可以为输入、输出、变量、运算、分支、循环、方法调用，但里面不能再定义方法！即：方法不能嵌套定义。

方法调用细节说明

1、同一个类中的方法调用：直接调用即可。比如print(参数);

2、跨类中的方法A类调用B类方法：需要通过对象名调用。比如对象名.方法名(参数);

public class MethodDetail {
    //编写一个main方法
    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() {
        //创建B对象，然后在调用方法即可
        System.out.println("m1()方法被调用");
        B b = new B();
        b.hi();

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

class B {
    public void hi() {
        System.out.println("B类中的hi()被执行");
    }
}

运行结果

3、特别说明：跨类的方法调用和方法的访问修饰符相关

成员方法练习

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

public class MethodExercise {
    //编写一个main方法
    public static void main(String[] args) {
        AA a = new AA();
        if (a.isOdd(138)) {
            System.out.println("是奇数");
        } else {
            System.out.println("是偶数");
        }
    }
}

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

运行结果

2、根据行、列、字符打印对应行数和列数的字符，比如：行：4，列：4，字符#，则打印相应的效果

public class MethodExercise {
    //编写一个main方法
    public static void main(String[] args) {
        AA a = new AA();
        a.print(4, 4, '#');
    }
}

class AA {
    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();
        }
    }
}

运行结果

成员方法传参机制

基本数据类型的传参机制

public class MethodParameter {
    //编写一个main方法
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        //创建AA对象 名字obj
        AA obj = new AA();
        obj.swap(a, b);//调用swap
    }
}

class AA {
    public void swap(int a, int b) {
        System.out.println("a和b交换前的值\na=" + a + "\tb=" + b);
        //完成了a和b的交换
        int tmp = a;
        a = b;
        b = tmp;
        System.out.println("a和b交换后的值\na=" + a + "\tb=" + b);
    }
}

运行结果

结论

基本数据类型，传递的是值(值拷贝)，形参的任何改变不影响实参！

引用数据类型的传参机制

B类中编写一个方法test100，可以接收一个数组，在方法中修改该数组，看看原来的数组是否变化?会变化。
B类中编写一个方法test200，可以接收一个Person(age,sal)对象，在方法中修改该对象属性，看看原来的对象是否变化?会变化。

public class MethodParameter {
    //编写一个main方法
    public static void main(String[] args) {
        B b = new B();
        int[] arr = {1, 2, 3};
        b.test100(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[0] = 200;
        //遍历数组
        System.out.println("test100的arr数组");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
    }
}

运行结果

结论

引用类型传递的是地址(传递也是值，但是值是地址)，可以通过形参影响实参！

看下一个案例，下面的方法会对原来的对象有影响吗？

public class MethodParameter {
    //编写一个main方法
    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; 下面的结果是10
        System.out.println("main的p.age=" + p.age);
    }
}

class Person {
    String name;
    int age;
}

class B {
    public void test200(Person p) {
        p = null;
    }
}

运行结果

成员方法返回类型是引用类型应用实例

1、编写类MyTools类，编写一个方法可以打印二维数组的数据。

public class Method {
    //编写一个main方法
    public static void main(String[] args) {
        int[][] map = {{0, 0, 1}, {1, 1, 1}, {1, 1, 3}};
        //使用方法完成输出
        MyTools tool = new MyTools();
        //调用方法
        tool.printArr(map);
        tool.printArr(map);
        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.length; j++) {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
    }
}

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

public class MethodExercise {
    //编写一个main方法
    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);
    }
}

class Person {
    String name;
    int age;
}

class MyTools {
//        编写一个方法copyPerson，可以复制一个Person对象，返回复制的对象。克隆对象，
//        注意要求得到新对象和原来的对象是两个独立的对象，只是他们的属性相同
    public Person copyPerson(Person p) {
        //创建一个新的对象
        Person p2 = new Person();
        p2.name = p.name;//把原来对象的名字赋给p2.name
        p2.age = p.age;//把原来对象的年龄赋给p2.age
        return p2;
    }
}

运行结果

方法递归调用

基本介绍

递归就是方法自己调用自己，每次调用时传入不同的变量。递归有助于编程者解决复杂问题，同时可以让代码变得简洁。

递归能解决什么问题

1、各种数学问题如:8皇后问题，汉诺塔，阶乘问题，迷宫问题，球和篮子的问题(google编程大赛)

2、各种算法中也会使用到递归，比如快排，归并排序，二分查找，分治算法等

3、将用栈解决的问题-->递归代码比较简洁

递归举例

1、打印问题

public class Recursion {
    //编写一个main方法
    public static void main(String[] args) {
        T t1 = new T();
        t1.test(4);
    }
}

class T {
    public void test(int n) {
        if (n > 2) {
            test(n - 1);
        }
        System.out.println("n=" + n);
    }
}

运行结果

2、阶乘问题

public class Recursion {
    //编写一个main方法
    public static void main(String[] args) {
        T t1 = new T();
        int res = t1.factorial(5);
        System.out.println("res=" + res);
    }
}

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

运行结果

递归重要规则

1、执行一个方法时，就创建一个新的受保护的独立空间(栈空间)

2、方法的局部变量是独立的，不会相互影响，比如n变量

3、如果方法中使用的是引用类型变量(比如数组)，就会共享该引用类型的数据.

4、递归必须向退出递归的条件逼近，否则就是无限递归，出现StackOverflowError，死龟了:)

5、当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。

方法递归调用练习

1、请使用递归的方式求出斐波那契数1，1，2，3，5，8，13...给你一个整数n，求出它的值是多少

public class Recursion {
    //编写一个main方法
    public static void main(String[] args) {
        T t1 = new T();
        int n = 7;
        int res = t1.fibonacci(n);
        System.out.println("当n=7 对应的斐波那契数=" + 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;
        }
    }
}

运行结果

2、猴子吃桃子问题：

有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个!以后每天猴子都吃其中的一半，然后再多吃一个。当到第10天时，想再吃时(即还没吃)，发现只有1个桃子了。

问题：最初共多少个桃子?

public class Recursion {
    //编写一个main方法
    public static void main(String[] args) {
        T t1 = new T();
        int day = 1;
        int peachNum = t1.peach(day);
        if (peachNum != -1) {
            System.out.println("第" + day + "天有" + peachNum + "个桃子");
        }
    }
}

class T {
    public int peach(int day) {
        if (day == 10) {
            return 1;
        } else if (day >= 1 && day <= 9) {
            return (peach(day + 1) + 1) * 2;
        } else {
            System.out.println("day在1-10");
            return -1;
        }
    }
}

运行结果

递归调用应用实例-迷宫问题

1、小球得到的路径，和程序员设置的找路策略有关

即：找路的上下左右的顺序相关

2、再得到小球路径时，可以先使用(下右上左)，
再改成(上右下左)，看看路径是不是有变化

3、测试回溯现象

4、扩展思考：如何求出最短路径?

public class MiGong {
    //编写一个main方法
    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;

        //输出当前的地图
        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("++++++++找路的情况如下++++++++");
        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;
            }
        }
    }
}

运行结果

递归调用应用实例-汉诺塔

汉诺塔传说

汉诺塔：汉诺塔(又称河内塔)问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。

假如每秒钟移动一次，共需多长时间呢？移完这些金片需要5845.54亿年以上，太阳系的预期寿命据说也就是数百亿年。真的过了5845.54亿年，地球上的一切生命，连同梵塔、庙宇等，都早已经灰飞烟灭

public class HanoiTower {
    //编写一个main方法
    public static void main(String[] args) {
        Tower tower = new Tower();
        tower.move(5, '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);
        }
    }
}

运行结果

递归调用应用实例-八皇后问题

八皇后问题说明

八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出:在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即：任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。

八皇后思路分析

1、第一个皇后先放第一行第一列

2、第二个皇后放在第二行第一列、然后判断是否OK，如果不OK，继续放在第二列、第三列、依次把所有列都放完，找到一个合适

3、继续第三个皇后，还是第一列、第二列..…..直到第8个皇后也能放在一个不冲突的位置，算是找到了一个正确解

4、当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，即将第一个皇后，放到第一列的所有正确解，全部得到

5、然后回头继续第一个皇后放第二列，后面继续循环执行1，2，3，4的步骤

说明

理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法，用一个一维数组即可解决问题。 arr[8]= {0,4,7,5,2,6,1,3} //对应arr下标表示第几行，即第几个皇后，arr[i] = val，val表示第i+1个皇后，放在第i+1行的第val+1列

方法重载

基本介绍

java中允许同一个类中，多个同名方法的存在，但要求形参列表不一致！

比如：System.out.println(); out是PrintStream类型

重载好处

1、减轻了起名的麻烦

2、减轻了记名的麻烦

快速入门案例

案例：类：MyCalculator 方法：calculate

calculate(int n1, int n2)//两个整数的和

calculate(int n1, double n2)//一个整数，一个double的和

calculate(double n2, int n1)//一个double，一个int 的和

calculate(int n1, int n2, int n3)//三个int 的和

public class OverLoad {
    //编写一个main方法
    public static void main(String[] args) {
        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.2));
        System.out.println(mc.calculate(1, 2, 3));
    }
}

class MyCalculator {
    //两个整数的和
    public int calculate(int n1, int n2) {
        System.out.println("calculate(int n1, int n2)被调用");
        return n1 + n2;
    }

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

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

    //三个int 的和
    public int calculate(int n1, int n2, int n3) {
        System.out.println("calculate(int n1, int n2, int n3)被调用");
        return n1 + n2 + n3;
    }
}

运行结果

注意事项和使用细节

1、方法名：必须相同

2、形参列表：必须不同(参数类型或个数或顺序，至少有一样不同，参数名无要求)

3、返回类型：无要求

练习题

1、判断题

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

public class OverLoadExercise {
    //编写一个main方法
    public static void main(String[] args) {
        Methods method = new Methods();
        method.m(10);
        method.m(10, 20);
        method.m("hello world~~~");
    }
}

class Methods {
    public void m(int n) {
        System.out.println("平方=" + (n * n));
    }

    public void m(int n1, int n2) {
        System.out.println("相乘=" + (n1 * n2));
    }

    public void m(String str) {
        System.out.println("传入的str=" + str);
    }

}

运行结果

3、在Methods类，定义三个重载方法max()，第一个方法，返回两个int值中的最大值，第二个方法，返回两个double值中的最大值，第三个方法，返回三个double值中的最大值，并分别调用三个方法。

public class OverLoadExercise {
    //编写一个main方法
    public static void main(String[] args) {
        Methods method = new Methods();
        int a = method.max(1, 2);
        double b = method.max(1.3, 2.9);
        double c = method.max(1.3, 2.9, 6.6);
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }
}

class Methods {
    public int max(int n1, int n2) {
        return Math.max(n1, n2);
    }

    public double max(double n1, double n2) {
        return Math.max(n1, n2);
    }

    public double max(double n1, double n2, double n3) {
        double temp = Math.max(n1, n2);
        return Math.max(temp, n3);
    }
}

运行结果

可变参数

基本概念

java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法

基本语法

访问修饰符 返回类型 方法名(数据类型... 形参名){
}

快速入门案例

public class VarParameter {
    //编写一个main方法
    public static void main(String[] args) {
        HspMethod m = new HspMethod();
        System.out.println(m.sum(1, 5, 100));
        System.out.println(m.sum(1, 29));
    }
}

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

运行结果

注意事项和使用细节

1、可变参数的实参可以为0个或任意多个

2、可变参数的实参可以为数组

3、可变参数的本质就是数组

4、可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后

5、一个形参列表中只能出现一个可变参数

public class VarParameter {
    //编写一个main方法
    public static void main(String[] args) {
        HspMethod m = new HspMethod();
        //细节：可变数组的实参可以为数组
        int[] arr = {1, 2, 3};
        m.f1(arr);
    }
}

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

    // 细节：可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
    public void f2(String str, double... nums) {
    }
    //一个形参列表中只能出现一个可变参数
//    public void f3(int... nums1, double... nums2) {//报错
//    }
}

运行结果

可变参数练习

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

类名 HspMethod 方法名 showScore

public class VarParameterExercise {
    //编写一个main方法
    public static void main(String[] args) {
        HspMethod hm = new HspMethod();
        String s1 = hm.showScore("Tom", 90.22, 88.0, 99);
        String s2 = hm.showScore("Jerry", 90.22, 88.0, 99, 100, 89.9);
        System.out.println(s1);
        System.out.println(s2);
    }
}

class HspMethod {
    //分析
    //方法名 showScore
    //形参(String name, double... scores)
    //返回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;
    }
}

运行结果

作用域

基本使用

1、在java编程中，主要的变量就是属性(成员变量)和局部变量

2、局部变量一般是指在成员方法中定义的变量[举例Cat类：cry]

3、java中作用域的分类
全局变量：也就是属性，作用域为整个类体Cat类：cry eat 等方法使用属性
局部变量：也就是除了属性之外的其他变量，作用域为定义它的代码块中！

4、全局变量(属性)可以不赋值，直接使用，因为有默认值，局部变量必须赋值后，才能使用，因为没有默认值

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

class Cat {
    //全局变量：也就是属性，作用域为整个类体Cat类：cry eat 等方法使用属性
    //属性在定义时，可以直接赋值
    int age = 10;//指定的值是10

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

    public void hi() {
        //局部变量必须赋值后，才能使用，因为没有默认值
        int num = 1;
        String address = "北京的猫";
        System.out.println("num=" + num);
        System.out.println("address=" + address);
    }

    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);//报错
    }
}

注意事项和使用细节

1、全局变量/属性和局部变量可以重名，访问时遵循就近原则。

2、在同一个作用域中，比如在同一个成员方法中，两个局部变量，不能重名。[举例]

3、全局变量/属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。
局部变量生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁。
即在一次方法调用过程中。

4、作用域范围不同
全局变量/属性：可以被本类使用，或其他类使用（通过对象调用）
局部变量：只能在本类中对应的方法中使用

5、修饰符不同
全局变量/属性：可以加修饰符
局部变量：不可以加修饰符

public class VarScopeDetail {
    //编写一个main方法
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.say();
        //当执行say方法时，say方法的局部变量比如name会创建
        //当say执行完毕后，name局部变量就销毁，但是属性(局部变量)仍可以使用
    }
}

class Person {
    String name = "jack";

    public void say() {
        //细节：属性和局部变量可以重名，访问时遵循就近原则
//        String name = "king";
        System.out.println("say() name=" + name);
    }

    public void hi() {
        String address = "北京";
//        String address = "上海";//报错，重复定义变量
        String name = "hello";//可以
    }
}

构造方法/构造器

看一个需求

前面我们在创建人类的对象时，是先把一个对象创建好后，再给他的年龄和姓名属性赋值，如果现在我要求，在创建人类的对象时，就直接指定这个对象的年龄和姓名，该怎么做？这时就可以使用构造器。

基本语法

[修饰符] 方法名(形参列表){
        方法体;
}

说明

1、构造器的修饰符可以默认，也可以是public protected private

2、构造器没有返回值

3、方法名和类名字必须一样

4、参数列表和成员方法一样的规则

5、构造器的调用系统完成

基本介绍

构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点：

1、方法名和类名相同

2、没有返回值

3、在创建对象时，系统会自动的调用该类的构造器完成对对象的初始化。

快速入门

现在我们就用构造方法来完成刚才提出的问题：在创建人类的对象时，就直接指定这个对象的年龄和姓名

public class Constructor {
    //编写一个main方法
    public static void main(String[] args) {
        //当new对象时，直接通过构造器指定名字和年龄
        Person p1 = new Person("Tom", 80);
        System.out.println("p1的信息如下");
        System.out.println("p1对象name=" + p1.name);
        System.out.println("p1对象age=" + p1.age);
    }
}

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;
    }
}

运行结果

注意事项和使用细节

1、一个类可以定义多个不同的构造器，即构造器重载
比如：我们可以再给Person类定义一个构造器，用来创建对象的时候,只指定人名，不需要指定年龄

2、构造器名和类名要相同

3、构造器没有返回值

4、构造器是完成对象的初始化，并不是创建对象

5、在创建对象时，系统自动的调用该类的构造方法

6、如果程序员没有定义构造方法，系统会自动给类生成一个默认无参构造方法(也叫默认构造方法)，比如Dog(){},使用javap指令反编译看看

7、一旦定义了自己的构造器，默认的构造器就覆盖了，就不能再使用默认参构造器，除非显式的定义一下，即：Dog(){}

public class ConstructorDetail {
    //编写一个main方法
    public static void main(String[] args) {
        //当new对象时，直接通过构造器指定名字和年龄
        Person p1 = new Person("Tom", 80);//第1个构造器
        Person p2 = new Person("King");//第2个构造器
        System.out.println("p1的信息如下");
        System.out.println("p1对象name=" + p1.name);
        System.out.println("p1对象age=" + p1.age);
        System.out.println("p2的信息如下");
        System.out.println("p2对象name=" + p2.name);
        System.out.println("p2对象age=" + p2.age);
        Dog dog1 = new Dog();//使用的是默认的无参构造器
    }
}

class 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;
    }
}

构造方法练习

在前面定义的Person类中添加两个构造器：
第一个无参构造器：利用构造器设置所有人的age属性初始值都为18

public class ConstructorExercise {
    //编写一个main方法
    public static void main(String[] args) {
        //当new对象时，直接通过构造器指定名字和年龄
        Person p1 = new Person();//无参构造器
        System.out.println("p1的信息如下");
        System.out.println("p1对象name=" + p1.name);
        System.out.println("p1对象age=" + p1.age);
        Person p2 = new Person("tom", 29);
        System.out.println("p2的信息如下");
        System.out.println("p2对象name=" + p2.name);
        System.out.println("p2对象age=" + p2.age);
    }
}


class Person {
    String name;//默认值null
    int age;//默认0

    //第1个无参构造器：利用构造器设置所有人的age属性初始值都为18
    public Person() {
        age = 18;
    }

    //第2个带pName和pAge两个参数的构造器
    public Person(String pName, int pAge) {
        name = pName;
        age = pAge;
    }
}

运行结果

第二个带pName和pAge两个参数的构造器：使得每次创建Person对象的同时初始化对象的age属性值和name属性值。分别使用不同的构造器，创建对象。

对象创建的流程分析

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

        Person p = new Person("小倩", 20);
        System.out.println("p的信息如下");
        System.out.println("p对象name=" + p.name);
        System.out.println("p对象age=" + p.age);
    }
}

class Person {//Person类
    String name;//默认值null
    int age = 90;

    public Person(String pName, int pAge) {//构造器
        name = pName;//给属性赋值
        age = pAge;//给属性赋值
    }
}

流程分析

1、加载Person类信息(Person.class)，只会加载一次

2、在堆中分配空间(地址)

3、完成对象初始化
3.1默认初始化 age = 0; name = null;
3.2显式初始化 age = 90; name = null;
3.3构造器初始化 age = 20; name = 小倩；

4、在对象在堆中的地址，返回给p(p是对象名，也可以理解成是对象的引用)

this关键字

看一段代码，并分析问题

public class This {
    //编写一个main方法
    public static void main(String[] args) {
        Dog dog1 = new Dog("大壮", 3);
        dog1.info();
    }
}

class Dog {
    String name;//默认值null
    int age;

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

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

问题：

构造方法的输入参数名不是非常好，如果能够将dName改成name就好了，但是我们会发现按照变量的作用域原则，name的值就是null，怎么解决->this

什么是this

java虚拟机会给每个对象分配this，代表当前对象。

使用this解决前面变量命名问题

public class This {
    //编写一个main方法
    public static void main(String[] args) {
        Dog dog1 = new Dog("大壮", 3);
        dog1.info();
    }
}

class Dog {
    String name;//默认值null
    int age;

    //如果我们构造器的形参，能够直接写成属性名,就更好了
    //但是出现了一个问题，根据变量的作用域原则
    //构造器的name是局部变量,而不是属性
    //构造器的age是局部变量,而不是属性
    //->引出this关键字来解决
    public Dog(String name, int age) {//构造器
        //this.name就是当前对象的属性name
        this.name = name;
        //this.age就是当前对象的属性age
        this.age = age;
    }

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

深入理解this

小结：简答的说，哪个对象调用，this就代表哪个对象

public class This {
    //编写一个main方法
    public static void main(String[] args) {
        Dog dog1 = new Dog("Tom", 3);
        System.out.println("dog1的hashCode=" + dog1.hashCode());
        dog1.info();
    }
}

class Dog {
    String name;//默认值null
    int age;

    public Dog(String name, int age) {//构造器
        this.name = name;
        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");
    }
}

运行结果

this的注意事项和使用细节

1、this关键字可以用来访问本类的属性、方法、构造器

2、this用于区分当前类的属性和局部变量

3、访问成员方法的语法：this.方法名(参数列表);

4、访问构造器语法：this(参数列表);
注意只能在构造器中使用(即只能在构造器中访问另一个构造器，必须放置第一条语句)

5、this不能在类定义的外部使用，只能在类定义的方法中使用

public class ThisDetail {
    //编写一个main方法
    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 f1() {
        System.out.println("f1()方法..");
    }

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

    //this关键字可以用来访问本类的属性
    public void f3() {
        String name = "smith";
        //传统方式
        System.out.println("name=" + name + " num=" + num);
        //也可以使用this访问属性
        System.out.println("name=" + this.name + " num=" + this.num);
    }
}

运行结果

this练习

定义Person类，里面有name、age属性，并提供compareTo比较方法，用于判断是否和另一个人相等，提供测试类TestPerson用于测试，名字和年龄完全一样，就返回true，否则返回false

public class ThisExercise {
    //编写一个main方法
    public static void main(String[] args) {
        Person p1 = new Person("mary", 20);
        Person p2 = new Person("smith", 30);
        Person p3 = new Person("mary", 20);
        System.out.println("p1和p2比较的结果=" + p1.compareTo(p2));
        System.out.println("p1和p2比较的结果=" + p1.compareTo(p3));
    }
}

//定义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;
    }
}

运行结果