devbox
空白诗007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

B站韩顺平学Java课程——个人笔记（第7章）：方法，类，对象，递归。递归思维解决——斐波那契数，猴子吃桃，迷宫，汉诺塔等_b站java课程

作者：空白诗007 | 2024-08-16 06:21:06

赞

踩

b站java课程

1.简介

        俺就一小白，半途想记录一下，有错就改，这当自己的小笔记，知识点细小了一点，欢迎大家补充，同时愿自己坚持下来。很多知识点都在代码里面备注，为了方便自己就不一一拿出来了。主要内容：Java方法，类，对象，递归。递归思维解决——斐波那契数，猴子吃桃，迷宫，汉诺塔等。目录齐全。

来源：韩顺平 零基础30天学会Java

2.类和对象

类和对象：
    类是创建一个数据类型；
    对象就是一个具体的事物。
  1. public class Object_Base01 {
  2.     /*
  3.     类和对象：
  4.         类是创建一个数据类型；int,char.double
  5.         对象就是一个具体的事物。
  6.      */
  7.  
  8.     public static void main(String[] args) {
  9.         /*
  10.         张老太养了两只猫猫:一只名家叫小白,今年3岁,白色。
  11.         还有一只叫小花,今年100岁,花色。请编写一个程序，
  12.         当用户输入小猫的名字时就显示该猫的名字，年龄，颜色。
  13.         如果用户输入的小猫名错误,则显示 张老太没有这只猫猫。
  14.          */
  15. //        //1.单独变量==》1）不利于数据的管理； 2）效率低下
  16. //        String dog1Name = "小白";
  17. //        String dog2Name = "花花";
  18. //
  19. //        int dog1Age = 18;
  20. //        int dog2Age = 38;
  21. //
  22. //        //2.数组==》1）数据类型无法体现 2）只能通过下标表现出来
  23. //        String dog1[] = {"小白", "18", "白色"};
  24. //        String dog2[] = {"小花", "38", "花色"};
  25.  
  26.         //3.数组
  27.         //实例化一个对象
  28.         Cat cat1 = new Cat();   //创建一只猫，并赋值给 cat1
  29.         cat1.name = "小白";
  30.         cat1.age = 18;
  31.         cat1.color = "白色";
  32.         cat1.weight = 23.34;
  33.  
  34.         //cat2 是对象名（对象引用）
  35.         //new Cat() 创建的对象空间才是真正的对象
  36.         Cat cat2 = new Cat();
  37.         cat2.name = "小花";
  38.         cat2.age = 38;
  39.         cat2.color = "花色";
  40.         cat2.weight = 9.32;
  41.  
  42.         //怎么访问
  43.         System.out.println("第一只猫" + cat1.name + "\t" + cat1.age
  44.          + "\t" + cat1.color + "\t" + cat1.weight);
  45.         System.out.println("第二只猫" + cat2.name + "\t" + cat2.age
  46.          + "\t" + cat2.color + "\t" + cat2.weight);
  47.  
  48.     }
  49. }
  50. class Cat{
  51.     // 属性/成员变量/字段
  52.     String name;
  53.     int age;
  54.     String color;
  55.     double weight;
  56.     // 属性既可以是基本数据类型，也可以是引用类型（数组，对象）
  57.  
  58.  
  59.         //创建空间的方法：
  60.         // 1）直接创建；Cat cat = new Cat()
  61.         // 2）先声明再创建: Cat cat;       caty = new Cat()
  62.  
  63.         //访问属性：
  64.         // 对象名.属性名
  65.  
  66.  
  67.         //类与对象
  68.         /*
  69.         Java 内存的结构分析
  70.         1.栈：一般存放基本数据类型
  71.         2.堆：存放对象（Cat cat,数组等）
  72.         3.方法区L:常量区（常量，比如字符串），类加载信息
  73.         4.示意图[Cat(name,age,prince]
  74.          */
  75. //        Person p = new Person();
  76. //        p.name = "jack";
  77. //        p.age = 10;
  78.         /*
  79.         创建对象流程简单分析:
  80.         1.先加载Person类信息
  81.         2.在堆中分配空间，进行默认初始化
  82.         3.把地址给p,p指向的对象
  83.         4.进行指定初始化  p.name = "jack";  p.age = 10;
  84.          */
  85.  
  86. }

3.方法

方法调用：
// 1.方法写好后，不去调用，不会输出
// 2.先创建一个对象，再去调用
方法调用小结：
//1.当程序执行到方法时，就会开辟一个独立的空间（栈空间）
//2.当方法执行完毕，或者执行到return语句时，就会返回
//3.返回到调用的地方
//4.返回后继续执行方法后的语句
  1. public class Method_02 {
  2.     public static void main(String[] args) {
  3.         //方法调用：
  4.         // 1.方法写好后，不去调用，不会输出
  5.         // 2.先创建一个对象，再去调用
  6.         Person p1 = new Person();
  7.         p1.name = "皓泽";
  8.         p1.speak();
  9.         p1.cal01();
  10.         p1.cal02(5);
  11.         int returnRes = p1.getSum(2,34);    //调用getSum,同时进行赋值
  12.         System.out.println("getSum返回值：" + returnRes);
  13.         System.out.println(p1.name);
  14.     }
  15. }
  16.  
  17. class Person{
  18.     String name;
  19.     int age;
  20.  
  21.     // 1. public 表示方法是公开的
  22.     // 2. void： 表示方法没有返回值
  23.     // 3.speak（） speak是方法名， （）形参列表
  24.     // 4. {}方法体， 可以写物品，要执行的代码
  25.     public void speak(){
  26.         System.out.println("我是帅比");
  27.     }
  28.  
  29.     //添加cal01 成员方法，计算1-1000的和
  30.     public void cal01(){
  31.         int res = 0;
  32.         for (int i = 0; i <= 1000; i++) {
  33.             res += i;
  34.         }
  35.         System.out.println("计算结果为：" + res);
  36.     }
  37.  
  38.     //添加cal02 成员方法，计算1-n的和
  39.     //解读：
  40.     //1.（int n) 形式列表， 表示当前有一个形参 n，可以从用户输入
  41.     public void cal02(int n){
  42.         int res1 = 0;
  43.         for (int i = 0; i <= n; i++) {
  44.             res1 += i;
  45.         }
  46.         System.out.println("计算结果：" + res1);
  47.     }
  48.  
  49.     //添加getSum成员的方法，可以计算两个数的和
  50.     //解读：
  51.     // 1.public 表示方法是公开的
  52.     // 2.int ：表示方法执行后，返回一个 int 值
  53.     // 3.getSum 方法名
  54.     // 4.（int num1， int num2） 形参列表，2个形参，可以接受用户传入的两个数
  55.     public int getSum(int num1,int num2) {
  56.         int res = num1 + num2;
  57.         return res;     //return语句
  58.  
  59.  
  60.         //方法调用小结：
  61.         //1.当程序执行到方法时，就会开辟一个独立的空间（栈空间）
  62.         //2.当方法执行完毕，或者执行到return语句时，就会返回
  63.         //3.返回到调用的地方
  64.         //4.返回后继续执行方法后的语句
  65.  
  66.     }
  67. }

4.为什么需要成员方法

1.成员方法的好处:
//    提高代码的复用性
//    可以将实现的细节封装起来然后供其他用户来调用即可。
  1. public class Method_03 {
  2.     //为什么需要成员方法
  3.  
  4.     public static void main(String[] args) {
  5.         int map[][] = {{1,2,4},{3,5,9},{6,4,2}};
  6.         Mytool tool = new Mytool();
  7.         tool.printArr(map);
  8.         tool.printArr(map);
  9.         tool.printArr(map);
  10.     }
  11. }
  12.  
  13. class Mytool{   //类
  14.     //定义一个输出数组方法
  15.  
  16.     public void printArr(int map[][]){
  17.         for(int i = 0;i < map.length;i++){
  18.             for (int j = 0; j < map[i].length; j++) {
  19.                 System.out.print(map[i][j] + "\t");
  20.             }
  21.             System.out.println();
  22.             System.out.println("==========");
  23.         }
  24.     }
  25. }
  1. public class MethodDetail_04 {
  2.  
  3.     //1.一个方法最多有一个返回值    【思考：如何返回多个值：可以使用数组】
  4.     public static void main(String[] args) {
  5.         AA a = new AA();
  6.         int res[] = a.getSumAndSub(6,4);
  7.         System.out.println("和 = " + res[0]);
  8.         System.out.println("差 = " + res[1]);
  9.     }
  10. }
  11. class AA{
  12.     //和 与 差
  13.     public int[] getSumAndSub(int n1,int n2){
  14.  
  15.         int resArr[] = new int[2];  //创建一个数组
  16.         resArr[0] = n1 + n2;
  17.         resArr[1] = n1 - n2;
  18.         return resArr;
  19.     }
  20.  
  21.     //2..返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
  22.     //  看上述代码getSumAndSnb
  23.  
  24.     // 3.如果方法要求有返回数据类型，则方法体中最后的执行语句必须为return 值;而且要求返回值类型必须和return的值类型一致或兼容
  25.     public double f1(){     //要求
  26.  
  27.         double d1 = 1.1 * 3;
  28.         int a = 100;
  29.         return a;     //返回  //int->double   兼容
  30.     }
  31.  
  32.     // 4.如果方法是void，则方法体中可以没有return语句，或者 只写 return;
  33.  
  34.     // 5.方法名遵循驼峰命名法，最好见名知义，表达出该功能的意思即可,比如 得到两个数的和 getsum，开发中按照规范
  35.  
  36.  
  37.     /*
  38.     二.形参列表
  39.     1.一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开,比如 getSum(int n1,int n2)
  40.     2.参数类型可以为任意类型，包含基本类型或引用类型，比如 printArr(int[][] map)
  41.     3.调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型 的参数!【getSum)
  42.     4.方法定义时的参数称为形式参数，简称形参;方法调用时的传入参数称为实际参数，简称实参
  43.       实参和形参的类型要一致或兼容、个数、顺序必须一致![演示]
  45.     方法体
  46.         里面写完成功能的具体的语句，可以为输入、输出、变量、运算、分支、循环、方法调用，
  47.         但里面不能再定义方法!即:方法不能嵌套定义。[演示]
  48.      */
  49.  
  50.     /*
  51.     三.方法调用细节说明
  52.     1.同一类中可以直接调用
  53.     2.跨类的方法调用，需要通过对象名调用------类似于 main 调用 class 类
  54.     3.*跨类的方法调用和方法的访问修饰符相关（后面细讲）
  55.      */
  56.  
  57.  
  58.  
  59.  
  60. }

练习题

  1. public class MethodExercise_05 {
  2.     public static void main(String[] args) {
  3.         BA b = new BA();
  4.         boolean c = b.num(1);
  5.         System.out.println(c);  //接受return的返回值
  6.  
  7.         //BA d = new BA();
  8.         b.print(4,32,'#');
  9.     }
  10. }
  11. //编写一个类 AA，判断一个数是奇数还是偶数，返回boolean
  12. class BA{
  13.     public boolean num(int a) {
  14. //        if(a % 2 == 1){
  15. //            return true;
  16. //        }else{
  17. //            return false;
  18. //        }
  19.         return (a % 2 == 1) ? true : false;
  20.     }
  21.  
  22.  
  23.     //按要求，输出对应的行和列的字符
  24.     public void print(int row,int col,char c){
  25.         for (int i = 0; i < row; i++) {
  26.             for (int j = 0; j < col; j++) {
  27.                 System.out.print(c);
  28.             }
  29.             System.out.println();
  30.         }
  31.     }
  32. }
  1. import java.util.Scanner;
  2.  
  3. public class MethodParameter_06 {
  4.     //成员方法传参机制
  5.     // 1.形参的任何变化都不会影响实参；
  6.     // 2.引用类型传递的是地址，可以通过形参来影响实参；
  7.     //      形参和实参指向同一个存储地址空间，因此，形参改变空间的内容，会对地址空间内容发生永久性变化
  8.     //3.
  9.     public static void main(String[] args) {
  10.         Scanner myScanner = new Scanner(System.in);
  11.         System.out.print("输入第一个数 = ");
  12.         int a = myScanner.nextInt();
  13.         System.out.print("输入第二个数 = ");
  14.         int b = myScanner.nextInt();
  15.         AAA c = new AAA();
  16.         c.swap(a,b);
  17.  
  18.     }
  19. }
  20.  
  21. class AAA{
  22.     public void swap(int a,int b){
  23.         System.out.println("交换前\n a = " + a + "\t" +  "b = " + b);
  24.         a = a + b;
  25.         b = a - b;
  26.         a = a - b;
  27.         System.out.println("交换后\n a = " + a + "\t" + "b = " + b);
  28.     }
  29. }
  30.

克隆方法

  1. public class MethodExercise_07 {
  2.     //克隆对象：要求新对象与旧对象是两个独立的对象,且属性相同
  3.     public static void main(String[] args) {
  4.  
  5.         Persons p = new Persons();
  6.         p.name = "minhao";
  7.         p.age = 19;
  8.  
  9.         MyTools tools = new MyTools();  //创建一个tools对象
  10.         Persons p2 = tools.copyPersons(p);
  11.  
  12.         //到此 p 和 p2是person对象，但是是两个独立的对象，属性相同
  13.  
  14.         System.out.println("age1 = " + p.age + "\t" +  "name1:" + p.name);
  15.         System.out.println("age2 = " + p2.age + "\t" +  "name2:" + p2.name);
  16.         System.out.println("p == p2");
  17.     }
  18. }
  19. class Persons{
  20.     String name;
  21.     int age;
  22. }
  23.  
  24. class MyTools{
  25.     public Persons copyPersons(Persons p){
  26.         //创建一个新对象
  27.         Persons p2 = new Persons(); //方法之间的调用
  28.         p2.name = p.name;//把原来对象的名字赋给p2.name
  29.         p2.age = p.age;//把原来对象的年龄赋给p2.age
  30.  
  31.         return p2;
  32.     }
  33. }

5.递归

1）递归的重要规则

递归的重要规则：
1.执行一个方法时，就创建一个新的受保护的独立空间(栈空间)
2.方法的局部变量是独立的，不会相互影响，比如n变量
3.如果方法中使用的是引用类型变量(比如数组)，就会共享该引用类型的数据.
4.递归必须向退出递归的条件逼近，否则就是无限递归,出现StackOverflowError，死龟了:)
5.当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，
    同时当方法执行完毕或者返回时，该方法也就执行完毕。
  1. import java.util.Scanner;
  2.  
  3. public class Recursion_08 {
  4.  
  5.  
  6.     //递归:自己调用自己
  7.     public static void main(String[] args) {
  8.         T t1 = new T();     //定义一个对象t1
  9.         t1.test(9);
  10.         //Scanner myScanner = new Scanner(System.in);
  11.         //int i = myScanner.nextInt();
  12.         int res = t1.factorial(5);
  13.         System.out.println("res=" + res);
  14.     }
  15. }
  16.  
  17. class T{
  18.     public void test(int n){
  19.         if (n > 2){
  20.             test (n - 1);
  21.         }
  22.             System.out.println("n = " + n);
  23.     }
  24.     public int factorial(int n){    //阶乘
  25.         if (n==1){
  26.             return 1;
  27.         }else{
  28.             return factorial(n - 1) * n;
  29.         }
  30.     }
  31. }

2）斐波那契数（必备）

3）猴子吃桃（蓝桥杯）

  1. import java.util.Scanner;
  2.  
  3. public class RecursionExercise_09 {
  4.     public static void main(String[] args) {
  5.         Scanner myScanner = new Scanner(System.in);
  6.         System.out.println("你想知道第几个数的斐波那契数：");
  7.         int n = myScanner.nextInt();
  8.  
  9.         M m1 = new M();
  10.  
  11.         //斐波那契数
  12.         if(m1.fibonacci(n) != -1) {
  13.             System.out.println("当n = " + n + "时对应的斐波那契数 = " + m1.fibonacci(n));
  14.         }else{
  15.             System.out.println("滚");
  16.         }
  17.  
  18.         //猴子吃桃
  19.         System.out.println("你想知道第几天的桃子数量：");
  20.         int day = myScanner.nextInt();
  21.         int peachNum = m1.peach(day);
  22.         if(peachNum != -1){
  23.             System.out.println("第"+ day + "天的桃子数量为" + m1.peach(day));
  24.         }else{
  25.             System.out.println("滚");
  26.         }
  27.  
  28.  
  29.     }
  30. }
  31.  
  32. class M {
  33.     /*递归写出斐波那契数：1，1，2，3，5，8，13......给你一个整数，求出他的值是多少
  34.     思路：
  35.     1.n = 1;斐波那契数 = 1
  36.     2.n = 2;斐波那契数 = 1
  37.     3.n = 3;斐波那契数 = 2
  38.     4.n = 4;斐波那契数 = 3
  39.      */
  40.     public int fibonacci(int n) {
  41.         if (n >= 1) {
  42.             if (n == 1 || n == 2) {
  43.                 return 1;
  44.             } else {
  45.                 return fibonacci(n - 1) + fibonacci(n - 2);
  46.             }
  47.         } else {
  48.             System.out.println("你的输入有误");
  49.             return -1;
  50.         }
  51.     }
  52.     /*
  53.     猴子吃桃子问题:有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个!
  54.     以后每天猴子都吃其中的一半，然后再多吃一个。当到第10天时,想再吃时(即还没吃)，
  55.     发现只有1个桃子了。问题:最初共多少个桃子?
  56.     思路：
  57.     1. 第10天，1个桃子
  58.     2. 第9天，（day10 + 1) * 2 = 4个桃子
  59.     3. 第8天，(day9 + 1) * 2 = 10个桃子
  60.      */
  61.     public int peach(int day){
  62.         if(day == 10){
  63.             return 1;
  64.         }else if(day >= 1&&day <= 9){
  65.             return (peach(day + 1) + 1) * 2;
  66.         }else{
  67.             System.out.println("day的范围不在规定内");
  68.             return -1;
  69.         }
  70.     }
  71. }

4）迷宫

  1. public class MiGong_10 {
  2.     public static void main(String[] args) {
  3.         //思路：
  4.         //1.创建八行其列的迷宫，用二维数组表示
  5.         //2.先规定 map 数组的元素值： 0 表示可以走， 1 表示不能走
  6.         int map[][] = new int[8][7];
  7.  
  8.         //3.将第一行和最后一行设置为 1
  9.         for (int i = 0; i < 7; i++) {
  10.             map[0][i] = 1;
  11.             map[7][i] = 1;
  12.         }
  13.  
  14.         //4.将最左边和最右边的设置为 1
  15.         for (int i = 0; i < 8; i++) {
  16.             map[i][0] = 1;
  17.             map[i][6] = 1;
  18.         }
  19.  
  20.         //5.剩余障碍物
  21.         map[3][1] = 1;
  22.         map[3][2] = 1;
  23.         //输出当前地图
  24.         for (int i = 0; i < map.length; i++) {
  25.             for (int j = 0; j < map[i].length; j++) {
  26.                 System.out.print(map[i][j] + " ");
  27.             }
  28.             System.out.println();
  29.         }
  30.  
  31.         //使用findway给老鼠找路
  32.         G g1 = new G();
  33.         g1.findway(map,1,1);//引用传递
  34.  
  35.         System.out.println("\n===========找路的情况==========");
  36.  
  37.         for (int i = 0; i < map.length; i++) {
  38.             for (int j = 0; j < map[i].length; j++) {
  39.                 System.out.print(map[i][j] + " ");
  40.             }
  41.             System.out.println();
  42.         }
  43.  
  44.     }
  45. }
  46.  
  47. class G{
  48.  
  49.     //递归回溯思想解决问题
  50.     //      回溯现象：
  51.     //      扩展：求出最短路径       a.穷举法 b.图
  52.  
  53.     // 1.findway方法就是用来找出迷宫路径
  54.     // 2.找到返回true 否则返回false
  55.     // 3.map 就是二维数组，即表示迷宫
  56.     // 4.i，j就是老鼠的位置，初始化位置【1.1】
  57.     // 5.因为是递归找路，先规定要求
  58.     //      0 表示可以走， 1 表示障碍物，2 表示可以走， 3 表示走过，但不能走通
  59.     // 6.当map[6][5] = 2 时，就表明找到通路了，否则继续找
  60.     // 7.选择合适的策略下-->右-->上-->左
  61.     public boolean findway(int map[][], int i,int j){
  62.  
  63.         if(map[6][5] == 2){//说明已经找到路了
  64.             return true;
  65.         }else{
  66.             if(map[i][j] == 0){//当前点为0，表示可以走，但还没走
  67.                 //假设能够走通
  68.                 map[i][j] = 2;
  69.                 //使用找路的策略，来确定该位置是否真的可以走通
  70.                 //下-->右-->上-->左
  71. //                if(findway(map,i + 1,j)){//下
  72. //                    return true;
  73. //                }else if(findway(map,i,j + 1)){//右
  74. //                    return true;
  75. //                }else if(findway(map,i - 1,j)){//上
  76. //                    return true;
  77. //                }else if(findway(map,i,j - 1)){//左
  78. //                    return true;
  79. //                }else{
  80. //                    map[i][j] = 3;
  81. //                    return false;
  82. //                }
  83.                 //上-->右-->下-->左
  84.                 if(findway(map,i - 1,j)){//上
  85.                     return true;
  86.                 }else if(findway(map,i,j + 1)){//右
  87.                     return true;
  88.                 }else if(findway(map,i + 1,j)){//下
  89.                     return true;
  90.                 }else if(findway(map,i,j - 1)){//左
  91.                     return true;
  92.                 }else{
  93.                     map[i][j] = 3;
  94.                     return false;
  95.                 }
  96.             }else{//map[i][j] = 1,2,3
  97.                 return false;
  98.             }
  99.         }
  100.     }
  101. }

5）汉诺塔

  1. public class HanoiTower_11 {
  2.     public static void main(String[] args) {
  3.  
  4.         Tower tower = new Tower();
  5.         tower.move(2,'A','B','C');
  6.  
  7.     }
  8. }
  9.  
  10. class Tower{
  11.  
  12.     //方法
  13.     //num 表示要移动的个数，a,b,c 分别表示A,B,C塔
  14.     public void move(int num,char a,char b,char c){
  15.         //如果 num = 1
  16.         if (num == 1){
  17.             System.out.println(a + "->" + c);
  18.         }else{
  19.             //如果有多个盘，可以看成两个， 最下面的和上面所有的盘
  20.             //1）先移动上面所有的盘到 b，借助 c
  21.             move(num - 1, a, c, b);
  22.             //2)把最下面的这个盘移动到 c
  23.             System.out.println(a + "->" + c);
  24.             //3)再将 b塔上的所有盘，移动到 c，借助a
  25.             move(num - 1,b, a, c);
  26.         }
  27.  
  28.     }
  29. }

6.方法重载

  1. public class OverLoad_12 {
  2.     public static void main(String[] args) {
  3.         /*
  4.         方法重载：
  5.         1. 方法名相同
  6.         2. 形参列表：必须不同（个数不同，类型不同，顺序不同，参数名无要求）
  7.         3. 返回值，无要求
  8.          */
  9.  
  10.         /*1.编写程序，类Methods中定义三个重载方法。方法名为m。三个方法分别接受一个int参数，两个int参数
  11.             一个字符串参数。分别执行平方运算并输出结果，相乘并输出结果，输出字符串信息。在主类main（）方法中分别
  12.             用参数区别调用三个方法。
  13.         */
  14.         Methods methods = new Methods();
  15.         methods.m(8);
  16.         methods.m(6,9);
  17.         methods.m("旧人已故");
  18.  
  19.         /*2.在Methods类，定义三个重载方法max()，第一个方法，返回两个int值中的最
  20.         大值，第二个方法，返回两个double值中的最大值，第三个方法，返回三个
  21.         double值中的最大值，并分别调用三个方法。
  22.          */
  23.         methods.max(6,9);
  24.         methods.max(10.01,9.6);
  25.         methods.max(10.1,9.6,2.5);
  26.  
  27.     }
  28. }
  29.  
  30. class Methods{
  31.     public void m(int n){
  32.         System.out.println("平方结果 = " + (n * n));
  33.     }
  34.  
  35.     public void m(int n,int a){
  36.         System.out.println("相乘结果 = " + (n * a));
  37.     }
  38.  
  39.     public void m(String b){
  40.         System.out.println("传入的String = " + b);
  41.     }
  42.  
  43.     public void max(int a,int b){
  44.         int max = a > b ? a : b;
  45.         System.out.println("两者中的最大值 = " + max);
  46.     }
  47.  
  48.     public void max(double a,double b){
  49.         double max = a > b ? a : b;
  50.         System.out.println("两者中的最大值 = " + max);
  51.     }
  52.  
  53.     public void max(double a,double b,double c){
  54.         double max = a > (b > c ? b : c) ? a : (b > c ? b : c);
  55.         System.out.println("两者中的最大值 = " + max);
  56.     }
  57.  
  58. }

7.可变参数

  1. public class VarParamenter_13 {
  2.     public static void main(String[] args) {
  3.         /*可变参数
  4.         基本概念:
  5.             java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法就可以通过可变参数实现
  6.         基本语法:
  7.              访问修饰符 返回类型 方法名(数据类型.. 形参名){
  8.              }
  9.          */
  10.         HspMethod m = new HspMethod();
  11.         System.out.println(m.sum(100,50,10));
  12.         System.out.println(m.sum(12,56,766));
  13.     }
  14. }
  15.  
  16. class HspMethod{
  17.     // 1.int...表示接受的是可变参数，类型是int
  18.     // 2.使用可变参数时，可以当作是数组
  19.     public int sum(int... nums){
  20.         System.out.println("接受的参数个数：" + nums.length);
  21.         int res = 0;
  22.         int sum = 0;
  23.         for (int i = 0; i < nums.length; i++) {
  24.             res += nums[i];
  25.         }
  26.         return res;
  27.     }
  28. }

细节

  1. public class VarParamenterDetail_14 {
  2.     public static void main(String[] args) {
  3.         /*
  4.         注意事项：
  5.         1. 可变参数的实参可以为0个或任意多个
  6.         2. 可变参数的实参可以为数组
  7.         3. 可变参数的本质是数组
  8.         4. 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
  9.         5， 一个参数列表中只能出现一个可变参数
  10.          */
  11.  
  12.         //细节： 可变参数的实参可以为数组
  13.         int arr[] = {1,2,3};
  14.         TT t = new TT();
  15.         t.f1(arr);
  16.     }
  17. }
  18. class TT{
  19.     public void f1(int... nums){
  20.         System.out.println(nums.length);
  21.     }
  22.  
  23.     //细节： 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
  24.     public void f2(double str,double... nums){
  25.         System.out.println();
  26.     }
  27. }

8.作用域

  1. public class VarScope_16 {
  2.     public static void main(String[] args) {
  3.         /*
  4.         P237.
  5.         （变量）作用域基本使用：
  6.         1. 全局变量：也就是属性，作用域为整个类体
  7.         2. 属性在定义时，可以直接赋值
  8.         3. 局部变量：一般是指变量方法中定义的变量，作用域为定义他的代码块
  9.         4. 全局变量（属性）可以不赋值，直接使用，因为有默认值，局部变量必须赋值后
  10.             才可以使用，因为没有默认值。
  11.          */
  12.  
  13.  
  14.  
  15.         /*
  16.         P238-P239
  17.         作用域使用细节 Detail
  18.         1. 属性和局部变量可以重名，访问时遵循就近原则
  19.         2. 在同一个作用域中，比如在同一个成员方法中，两个局部变量，不能重名。
  20.         3. 属性生命周期较长，伴随对象的创建而创建，伴随着对象的销毁而销毁。
  21.             局部变量，生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁。
  22.             即在一次方法调用过程中
  23.         4. 作用域的范围不同：
  24.             全局变量/属性：可以被本类或其他类使用（通过对象调用)
  25.             局部变量：只能在本类中使用
  26.         5. 修饰符不同
  27.             全局变量/属性 可以加修饰符
  28.             局部变量 不可以加修饰符
  29.          */
  30.  
  31.     }
  32. }

9.构造器/构造方法

构造器的细节

//构造器的细节：
//1. 一个类可以定义多个构造器，即构造器重载
Personn p1 = new Personn("minhao");
System.out.println("p1 name = " + p1.name);
// 2.构造器名要和类名一致
// 3.构造器没有返回值

// 4.构造器是完成对象的初始化，并不是创建对象
// 5.在创建对象时，系统自动的调用该类的构造方法
//eg：p1.name = ...      （错误）只能由系统调用
  1. public class Construuctor_17 {
  2.     public static void main(String[] args) {
  3.         /*
  4.         P240
  5.         构造方法/构造器
  6.         ●看一个需求
  7.         我们来看一个需求:前面我们在创建人类的对象时，是先把一个对象创建好后，
  8.         再给他的年龄和姓名属性赋值，如果现在我要求，在创建人类的对象时，
  9.         就直接指定这个对象的年龄和姓名，该怎么做?这时就可以使用构造器
  10.         ● 基本语法
  11.             ·[修饰符]方法名(形参列表){
  12.                 方法体;
  13.             }
  14.         老韩说明:
  15.         1)构造器的修饰符可以默认，也可以是public,protected,private
  16.         2)构造器没有返回值
  17.         3)方法名 和类名字必须一样
  18.         4)参数列表 和 成员方法-样的规则
  19.         5)构造器的调用，由系统完成
  21.         基本介绍：
  22.         构造方法又叫构造器，是类的一种特殊的方法，他的作用主要是
  23.         完成对新对象的初始化。特点如下：
  24.         1.方法名和类名相同
  25.         2.没有返回值
  26.         3.在创建对象是，系统会自动的调用和该类的构造器完成对对象的初始化
  27.          */
  28.  
  29.  
  30.         //P241构造器的快速入门
  31.         //在构造人类对象时，直接定义这个对象的年龄和姓名
  32.         Personn p = new Personn("haoze",18);
  33.         System.out.println("p的信息如下");
  34.         System.out.println(p.name);
  35.         System.out.println(p.age);
  36.  
  37.  
  38.  
  39.         //P242-P243
  40.         // 构造器的细节：
  41.         //1. 一个类可以定义多个构造器，即构造器重载
  42.         Personn p1 = new Personn("minhao");
  43.         System.out.println("p1 name = " + p1.name);
  44.         // 2.构造器名要和类名一致
  45.         // 3.构造器没有返回值
  46.  
  47.         // 4.构造器是完成对象的初始化，并不是创建对象
  48.         // 5.在创建对象时，系统自动的调用该类的构造方法
  49.         //eg：p1.name = ...      （错误）只能由系统调用
  50.  
  51.         // 6.如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器
  52.         Dog dog = new Dog();
  53.         // 7.一旦定义了自己的构造器，默认无参构造器就会被覆盖，不能使用，除非显式的定义一下
  54.         //即： Dog(){}
  55.         Dog dog1 = new Dog("zhaomin");
  56.     }
  57. }
  58.  
  59. class Dog{
  60.     //如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器
  61.     //javac 反编译
  62.     /*
  63.     默认构造器
  64.     Dog(){
  66.     }
  67.      */
  68.     //一旦定义了自己的构造器，默认无参构造器就会被覆盖，不能使用，除非显式的定义一下
  69.     public Dog(String dName){
  70.         //...
  71.     }
  72.  
  73.     Dog(){      //显式的定义一下
  74.  
  75.     }
  76. }
  77.  
  78. class Personn{//此处用Personn是因为在同一文件夹下，我的Person已经定义过类了
  79.     String name;
  80.     int age;
  81.     // 1.没有返回值，故没有void
  82.     // 2.构造器的名称与类的名称一样，都为Personn
  83.     // 3.(String pName,int pAge) 时构造器形参列表，规则与成员方法一样
  84.     public Personn(String pName,int pAge){
  85.         System.out.println("构造器被调用~~完成对象属性的初始化");
  86.         name = pName;
  87.         age = pAge;
  88.     }
  89.     public Personn(String pName){
  90.         name = pName;
  91.     }
  92.  
  93. }

10.对象创建流程分析（面试题）

String 是引用类型 所以在常量区调用地址

Java 内存的结构分析
        1.栈：一般存放基本数据类型
        2.堆：存放对象（Cat cat,数组等）
        3.方法区L:常量区（常量，比如字符串），类加载信息

11.this

thisDetail

  1. public class ThisDetail_19 {
  2.     public static void main(String[] args) {
  3.         /*
  4.         ThisDetail.java
  5.         1.this关键字可以用来访问本类的属性、方法、构造器
  6.         2.this用于区分当前类的属性和局部变量
  7.         3.访问成员方法的语法:this.方法名(参数列表);
  8.         4.访问构造器语法:this(参数列表);注意只能在构造器中使用（只能构造器中访问另一个构造器
  9.         5.this不能在类定义的外部使用，只能在类定义的方法中使用。
  10.         */
  11.  
  12.         Tf t2 = new Tf();
  13.  
  14.         //3.访问成员方法的语法:this.方法名(参数列表);
  15.         t2.f2();
  16.         t2.f3();
  17.  
  18.     }
  19. }
  20.  
  21. class Tf{
  22.     String name = "tom";
  23.     int num = 100;
  24.     // 访问构造器语法：this（参数列表）
  25.     // 4.访问构造器语法:this(参数列表);注意只能在构造器中使用（只能构造器中访问另一个构造器，必须放在第一条语句）
  26.  
  27.     //注意：访问构造器语法:this(参数列表)；必须放在第一条语句（与继承有关）
  28.  
  29.     public Tf(){
  30.         this("tom",12);//必须放在第一条语句
  31.         System.out.println("Tf() 构造器");
  32.  
  33.     }
  34.     public Tf(String name,int age){
  35.         System.out.println("Tf(String name,int age) 构造器");
  36.  
  37.     }
  38.  
  39.  
  40.     public void f3(){
  41.         String name = "jack";
  42.         int num = 99;
  43.         //传统方法          就近原则
  44.         System.out.println("name=" + name + "\t" + "num = " + num);
  45.         //this调用        属性
  46.         System.out.println("name=" + this.name + "\t" + "num = " + this.num);
  47.     }
  48.     //3.访问成员方法的语法:this.方法名(参数列表);
  49.     public void f1(){
  50.         System.out.println("f1()方法..");
  51.     }
  52.     public void f2(){
  53.         System.out.println("f2()方法..");
  54.         //调用f1
  55.         //方法1：
  56.         f1();
  57.         //方法2：
  58.         this.f1();//继承细讲
  59.     }
  60.  
  61. }

Exercise

  1. public class ThisExercise_20 {
  2.     public static void main(String[] args) {
  3.         /*
  4.         定义Person类，里面有name、age属性，并提供compareTo比较方法，用于判断是否和另一个人相等，
  5.         提供测试类TestPerson用于测试,名字和年龄完全-:一样，就返回true,否则返回false
  6.          */
  7.         Monkey m1 = new Monkey("monkey",20);
  8.         Monkey m2 = new Monkey("monkey",18);
  9.         System.out.println("m1和m2的比较结果 = " + m1.compareTo(m2));
  10.     }
  11. }
  12. class Monkey{
  13.     String name;
  14.     int age;
  15.     //构造器
  16.     public Monkey(String name,int age){
  17.         this.name = name;
  18.         this.age = age;
  19.     }
  20.     //compareTo比较方法
  21.     public boolean compareTo(Monkey p){
  22.         return this.name.equals(p.name) && this.age == p.age;
  23.     }
  24. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/空白诗007/article/detail/986958
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号