Debug模式

Debug模式是供程序员使用的程序调试工具，它可以用于查看程序的执行流程，也可以用于追踪程序执行过程来调试程序。

Debug模式操作流程

1、如何加断点
选择要设置断点的代码行，在行号的区域后面单击鼠标左键即可
2、如何运行加了断点的程序
在代码区域右键Debug执行
3、看哪里
看Debugger窗口
看Console窗口
4、点哪里
点Step Into (F7)这个箭头，也可以直接按F7
5、如何删除断点
选择要删除的断点，单击鼠标左键即可

实际练习

减肥计划if版

输入星期数，显示今天的减肥活动
周一：跑步
周二：游泳
周三：慢走
周四：动感单车
周五：拳击
周六：爬山
周日：好好吃一顿

  1. package com.itheima;
  3. import java.util.Scanner;
  5. /*
  6.     需求：输入星期数，显示今天的减肥活动
  7.             周一：跑步
  8.             周二：游泳
  9.             周三：慢走
  10.             周四：动感单车
  11.             周五：拳击
  12.             周六：爬山
  13.             周日：好好吃一顿
  15.     思路：
  16.         1:键盘录入一个星期数，用一个变量接收
  17.         2:对星期数进行判断，这里用 if 语句实现
  18.         3:在对应的语句控制中输出对应的减肥活动
  19.  */
  20. public class Test01 {
  21.     public static void main(String[] args) {
  22.         //键盘录入一个星期数，用一个变量接收
  23.         Scanner sc = new Scanner(System.in);
  25.         System.out.println("请输入一个星期数：");
  26.         int week = sc.nextInt();
  28.         //对星期数进行判断，这里用 if 语句实现
  29.         if (week < 1 || week > 7) {
  30.             System.out.println("你输入的星期数有误");
  31.         } else if (week == 1) {
  32.             System.out.println("跑步");
  33.         } else if (week == 2) {
  34.             System.out.println("游泳");
  35.         } else if (week == 3) {
  36.             System.out.println("慢走");
  37.         } else if (week == 4) {
  38.             System.out.println("动感单车");
  39.         } else if (week == 5) {
  40.             System.out.println("拳击");
  41.         } else if (week == 6) {
  42.             System.out.println("爬山");
  43.         } else {
  44.             System.out.println("好好吃一顿");
  45.         }
  46.     }
  47. }

减肥计划switch版

输入星期数，显示今天的减肥活动
周一：跑步
周二：游泳
周三：慢走
周四：动感单车
周五：拳击
周六：爬山
周日：好好吃一顿

  1. package com.itheima;
  4. import java.util.Scanner;
  6. /*
  7.     需求：输入星期数，显示今天的减肥活动
  8.             周一：跑步
  9.             周二：游泳
  10.             周三：慢走
  11.             周四：动感单车
  12.             周五：拳击
  13.             周六：爬山
  14.             周日：好好吃一顿
  16.     思路：
  17.         1:键盘录入一个星期数，用一个变量接收
  18.         2:对星期数进行判断，这里用 switch 语句实现
  19.         3:在对应的语句控制中输出对应的减肥活动
  21.     导包：
  22.         1:手动导包  import java.util.Scanner;
  23.         2:快捷键导包 Alt+Enter
  24.         3:自动导包
  25.  */
  26. public class Test02 {
  27.     public static void main(String[] args) {
  28.         //键盘录入一个星期数，用一个变量接收
  29.         Scanner sc = new Scanner(System.in);
  31.         System.out.println("请输入一个星期数：");
  32.         int week = sc.nextInt();
  34.         //对星期数进行判断，这里用 switch 语句实现
  35.         switch (week) {
  36.             case 1:
  37.                 System.out.println("跑步");
  38.                 break;
  39.             case 2:
  40.                 System.out.println("游泳");
  41.                 break;
  42.             case 3:
  43.                 System.out.println("慢走");
  44.                 break;
  45.             case 4:
  46.                 System.out.println("动感单车");
  47.                 break;
  48.             case 5:
  49.                 System.out.println("拳击");
  50.                 break;
  51.             case 6:
  52.                 System.out.println("爬山");
  53.                 break;
  54.             case 7:
  55.                 System.out.println("好好吃一顿");
  56.                 break;
  57.             default:
  58.                 System.out.println("你输入的星期数有误");
  59.         }
  61.     }
  62. }

逢7跳过

朋友聚会的时候可能会玩一个游戏：逢七过。 规则是：从任意一个数字开始报数，当你要报的数字包含7或者是7的倍数时都要说：过。 为了帮助大家更好的玩这个游戏，这里我们直接在控制台打印出1-100之间的满足逢七必过规则的数据。 这样，大家将来在玩游戏的时候，就知道哪些数据要说：过。

  1. package com.itheima;
  2. /*
  3.     需求：
  4.         朋友聚会的时候可能会玩一个游戏：逢七过。
  5.         规则是：从任意一个数字开始报数，当你要报的数字包含7或者是7的倍数时都要说：过。
  6.         为了帮助大家更好的玩这个游戏，这里我们直接在控制台打印出1-100之间的满足逢七必过规则的数据。
  7.         这样，大家将来在玩游戏的时候，就知道哪些数据要说：过。
  9.     思路：
  10.         1:数据在1-100之间，用for循环实现数据的获取
  11.         2:根据规则，用if语句实现数据的判断：要么个位是7，要么十位是7，要么能够被7整除
  12.         3:在控制台输出满足规则的数据
  13.  */
  14. public class Test03 {
  15.     public static void main(String[] args) {
  16.         //数据在1-100之间，用for循环实现数据的获取
  17.         for(int x=1; x<=100; x++) {
  18.             //根据规则，用if语句实现数据的判断：要么个位是7，要么十位是7，要么能够被7整除
  19.             if(x%10==7 || x/10%10==7 || x%7==0) {
  20.                 //在控制台输出满足规则的数据
  21.                 System.out.println(x);
  22.             }
  23.         }
  24.     }
  25. }

不死的兔子

有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子， 假如兔子都不死，问第二十个月的兔子对数为多少？

  1. package com.itheima;
  3. /*
  4.     需求：
  5.         有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，
  6.         假如兔子都不死，问第二十个月的兔子对数为多少？
  8.     思路：
  9.         1:为了存储多个月的兔子对数，定义一个数组，用动态初始化完成数组元素的初始化，长度为20
  10.         2:因为第1个月，第2个月兔子的对数是已知的，都是1，所以数组的第1个元素，第2个元素值也都是1
  11.         3:用循环实现计算每个月的兔子对数
  12.         4:输出数组中最后一个元素的值，就是第20个月的兔子对数
  13.  */
  14. public class Test04 {
  15.     public static void main(String[] args) {
  16.         //为了存储多个月的兔子对数，定义一个数组，用动态初始化完成数组元素的初始化，长度为20
  17.         int[] arr = new int[20];
  19.         //因为第1个月，第2个月兔子的对数是已知的，都是1，所以数组的第1个元素，第2个元素值也都是1
  20.         arr[0] = 1;
  21.         arr[1] = 1;
  23. //        arr[2] = arr[0] + arr[1];
  24. //        arr[3] = arr[1] + arr[2];
  25. //        arr[4] = arr[2] + arr[3];
  28.         //用循环实现计算每个月的兔子对数
  29.         for(int x=2; x<arr.length; x++) {
  30.             arr[x] = arr[x-2] + arr[x-1];
  31.             /*
  32.                 arr[2] = arr[0] + arr[1];
  33.                 arr[3] = arr[1] + arr[2];
  34.                 arr[4] = arr[2] + arr[3];
  35.                 ...
  36.              */
  37.         }
  39.         //输出数组中最后一个元素的值，就是第20个月的兔子对数
  40.         System.out.println("第二十个月兔子的对数是：" + arr[19]);
  41.     }
  42. }

百钱白鸡

我国古代数学家张丘建在《算经》一书中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。 百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？

  1. package com.itheima;
  3. /*
  4.     需求：
  5.         我国古代数学家张丘建在《算经》一书中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。
  6.         百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？
  8.     思路：
  9.         1:第1层循环，用于表示鸡翁的范围，初始化表达式的变量定义为 x=0，判断条件是x<=20
  10.         2:第2层循环，用于表示鸡母的范围，初始化表达式的变量定义为 y=0，判断条件是y<=33
  11.         3:这个时候，用于表示鸡雏的变量 z = 100 – x – y
  12.         4:判断表达式 z%3==0 和表达式 5*x + 3*y + z/3 = 100 是否同时成立，如果成立，输出对应的 x，y，z 的值，
  13.           就是对应的鸡翁，鸡母，鸡雏的值
  14.  */
  15. public class Test05 {
  16.     public static void main(String[] args) {
  17.         //第1层循环，用于表示鸡翁的范围，初始化表达式的变量定义为 x=0，判断条件是x<=20
  18.         for(int x=0; x<=20; x++) {
  19.             //第2层循环，用于表示鸡母的范围，初始化表达式的变量定义为 y=0，判断条件是y<=33
  20.             for(int y=0; y<=33; y++) {
  21.                 //这个时候，用于表示鸡雏的变量 z = 100 – x – y
  22.                 int z = 100 - x - y;
  24.                 //判断表达式 z%3==0 和表达式 5*x + 3*y + z/3 = 100 是否同时成立
  25.                 if(z%3==0 && 5*x+3*y+z/3==100) {
  26.                     System.out.println(x+","+y+","+z);
  27.                 }
  28.             }
  29.         }
  30.     }
  31. }

数组元素求和

有这样的一个数组，元素是{68,27,95,88,171,996,51,210}。求出该数组中满足要求的元素和， 要求是：求和的元素个位和十位都不能是7，并且只能是偶数。

  1. package com.itheima;
  3. /*
  4.     需求：
  5.         有这样的一个数组，元素是{68,27,95,88,171,996,51,210}。求出该数组中满足要求的元素和，
  6.         要求是：求和的元素个位和十位都不能是7，并且只能是偶数
  8.     思路：
  9.         1:定义一个数组，用静态初始化完成数组元素的初始化
  10.         2:定义一个求和变量，初始值是0
  11.         3:遍历数组，获取到数组中的每一个元素
  12.         4:判断该元素是否满足条件，如果满足条件就累加
  13.         5:输出求和变量的值
  14.  */
  15. public class Test06 {
  16.     public static void main(String[] args) {
  17.         //定义一个数组，用静态初始化完成数组元素的初始化
  18.         int[] arr = {68, 27, 95, 88, 171, 996, 51, 210};
  20.         //定义一个求和变量，初始值是0
  21.         int sum = 0;
  23.         //遍历数组，获取到数组中的每一个元素
  24.         for(int x=0; x<arr.length; x++) {
  25.             //判断该元素是否满足条件，如果满足条件就累加
  26.             if(arr[x]%10!=7 && arr[x]/10%10!=7 && arr[x]%2==0) {
  27.                 sum += arr[x];
  28.             }
  29.         }
  31.         //输出求和变量的值
  32.         System.out.println("sum:" + sum);
  33.     }
  34. }

判断两个数组是否相同

定义一个方法，用于比较两个数组的内容是否相同

  1. package com.itheima;
  3. /*
  4.     需求：
  5.         设计一个方法，用于比较两个数组的内容是否相同
  7.     思路：
  8.         1:定义两个数组，分别使用静态初始化完成数组元素的初始化
  9.         2:定义一个方法，用于比较两个数组的内容是否相同
  10.         3:比较两个数组的内容是否相同，按照下面的步骤实现就可以了
  11.             首先比较数组长度，如果长度不相同，数组内容肯定不相同，返回false
  12.             其次遍历，比较两个数组中的每一个元素，只要有元素不相同，返回false
  13.             最后循环遍历结束后，返回true
  14.         4:调用方法，用变量接收
  15.         5:输出结果
  16.  */
  17. public class Test07 {
  18.     public static void main(String[] args) {
  19.         //定义两个数组，分别使用静态初始化完成数组元素的初始化
  20.         int[] arr = {11, 22, 33, 44, 55};
  21.         //int[] arr2 = {11, 22, 33, 44, 55};
  22.         int[] arr2 = {11, 22, 33, 44, 5};
  25.         //调用方法，用变量接收
  26.         boolean flag = compare(arr,arr2);
  27.         //输出结果
  28.         System.out.println(flag);
  29.     }
  31.     //定义一个方法，用于比较两个数组的内容是否相同
  32.     /*
  33.         两个明确：
  34.             返回值类型：boolean
  35.             参数：int[] arr, int[] arr2
  36.      */
  37.     public static boolean compare(int[] arr, int[] arr2) {
  38.         //首先比较数组长度，如果长度不相同，数组内容肯定不相同，返回false
  39.         if(arr.length != arr2.length) {
  40.             return false;
  41.         }
  43.         //其次遍历，比较两个数组中的每一个元素，只要有元素不相同，返回false
  44.         for(int x=0; x<arr.length; x++) {
  45.             if(arr[x] != arr2[x]) {
  46.                 return false;
  47.             }
  48.         }
  50.         //最后循环遍历结束后，返回true
  51.         return true;
  52.     }
  53. }

查找元素在数组中出现的索引位置

已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索引。并在控制台输出找到的索引值。如果没有查找到，则输出-1

  1. package com.itheima;
  3. import java.util.Scanner;
  5. /*
  6.     需求：
  7.         已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索引，并在控制台输出找到的索引值。
  9.     思路：
  10.         1:定义一个数组，用静态初始化完成数组元素的初始化
  11.         2:键盘录入要查找的数据，用一个变量接收
  12.         3:定义一个索引变量，初始值为-1
  13.         4:遍历数组，获取到数组中的每一个元素
  14.         5:拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量,并结束循环
  15.         6:输出索引变量
  16.  */
  17. public class Test08 {
  18.     public static void main(String[] args) {
  19.         //定义一个数组，用静态初始化完成数组元素的初始化
  20.         int[] arr = {19, 28, 37, 46, 50};
  22.         //键盘录入要查找的数据，用一个变量接收
  23.         Scanner sc = new Scanner(System.in);
  25.         System.out.println("请输入要查找的数据：");
  26.         int number = sc.nextInt();
  28.         /*
  29.         //定义一个索引变量，初始值为-1
  30.         int index = -1;
  32.         //遍历数组，获取到数组中的每一个元素
  33.         for(int x=0; x<arr.length; x++) {
  34.             //拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量,并结束循环
  35.             if(arr[x] == number) {
  36.                 index = x;
  37.                 break;
  38.             }
  39.         }
  40.         */
  42.         //调用方法
  43.         int index = getIndex(arr, number);
  45.         //输出索引变量
  46.         System.out.println("index: " + index);
  49.     }
  51.     //查找指定的数据在数组中的索引
  52.     /*
  53.         两个明确：
  54.             返回值类型：int
  55.             参数：int[] arr, int number
  56.      */
  57.     public static int getIndex(int[] arr, int number) {
  58.         //定义一个索引变量，初始值为-1
  59.         int index = -1;
  61.         //遍历数组，获取到数组中的每一个元素
  62.         for(int x=0; x<arr.length; x++) {
  63.             //拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量,并结束循环
  64.             if(arr[x] == number) {
  65.                 index = x;
  66.                 break;
  67.             }
  68.         }
  70.         //返回索引
  71.         return index;
  72.     }
  73. }

数组元素反转

已知一个数组 arr = {19, 28, 37, 46, 50}; 用程序实现把数组中的元素值交换， 交换后的数组 arr = {50, 46, 37, 28,19}; 并在控制台输出交换后的数组元素。

  1. package com.itheima;
  3. /*
  4.     需求：
  5.         已知一个数组 arr = {19, 28, 37, 46, 50}; 用程序实现把数组中的元素值交换，
  6.         交换后的数组 arr = {50, 46, 37, 28, 19}; 并在控制台输出交换后的数组元素。
  8.     思路：
  9.         1:定义一个数组，用静态初始化完成数组元素的初始化
  10.         2:循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引小于等于结束索引
  11.         3:变量交换
  12.         4:遍历数组
  13.  */
  14. public class Test09 {
  15.     public static void main(String[] args) {
  16.         //定义一个数组，用静态初始化完成数组元素的初始化
  17.         int[] arr = {19, 28, 37, 46, 50};
  19.         /*
  20.         //循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引小于等于结束索引
  21.         for (int start = 0, end = arr.length - 1; start <= end; start++, end--) {
  22.             //变量交换
  23.             int temp = arr[start];
  24.             arr[start] = arr[end];
  25.             arr[end] = temp;
  26.         }
  27.         */
  29.         //调用反转的方法
  30.         reverse(arr);
  32.         //遍历数组
  33.         printArray(arr);
  34.     }
  37.     /*
  38.         两个明确：
  39.             返回值类型：void
  40.             参数：int[] arr
  41.      */
  42.     public static void reverse(int[] arr) {
  43.         //循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引小于等于结束索引
  44.         for (int start = 0, end = arr.length - 1; start <= end; start++, end--) {
  45.             //变量交换
  46.             int temp = arr[start];
  47.             arr[start] = arr[end];
  48.             arr[end] = temp;
  49.         }
  50.     }
  53.     /*
  54.         两个明确：
  55.             返回值类型：void
  56.             参数：int[] arr
  57.      */
  58.     public static void printArray(int[] arr) {
  59.         System.out.print("[");
  61.         for (int x = 0; x < arr.length; x++) {
  62.             if (x == arr.length - 1) {
  63.                 System.out.print(arr[x]);
  64.             } else {
  65.                 System.out.print(arr[x] + ", ");
  66.             }
  67.         }
  69.         System.out.println("]");
  70.     }
  71. }

评委打分

在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。 选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。

  1. package com.itheima;
  3. import java.util.Scanner;
  5. /*
  6.     需求：
  7.         在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
  8.         选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。
  10.     思路：
  11.         1:定义一个数组，用动态初始化完成数组元素的初始化，长度为6
  12.         2:键盘录入评委分数
  13.         3:由于是6个评委打分，所以，接收评委分数的操作，用循环改进
  14.         4:定义方法实现获取数组中的最高分(数组最大值)，调用方法
  15.         5:定义方法实现获取数组中的最低分(数组最小值) ，调用方法
  16.         6:定义方法实现获取数组中的所有元素的和(数组元素求和) ，调用方法
  17.         7:按照计算规则进行计算得到平均分
  18.         8:输出平均分
  19.  */
  20. public class Test10 {
  21.     public static void main(String[] args) {
  22.         //定义一个数组，用动态初始化完成数组元素的初始化，长度为6
  23.         int[] arr = new int[6];
  25.         //键盘录入评委分数
  26.         Scanner sc = new Scanner(System.in);
  28. //        System.out.println("请输入第1个评委的打分：");
  29. //        arr[0] = sc.nextInt();
  30. //
  31. //        System.out.println("请输入第2个评委的打分：");
  32. //        arr[1] = sc.nextInt();
  34.         //由于是6个评委打分，所以，接收评委分数的操作，用循环改进
  35.         for(int x=0; x<arr.length; x++) {
  36.             System.out.println("请输入第" + (x + 1) + "个评委的打分：");
  37.             arr[x] = sc.nextInt();
  38.         }
  40.         //printArray(arr);
  42.         //定义方法实现获取数组中的最高分(数组最大值)，调用方法
  43.         int max = getMax(arr);
  45.         //定义方法实现获取数组中的最低分(数组最小值) ，调用方法
  46.         int min = getMin(arr);
  48.         //定义方法实现获取数组中的所有元素的和(数组元素求和) ，调用方法
  49.         int sum = getSum(arr);
  51.         //按照计算规则进行计算得到平均分
  52.         int avg = (sum - max - min) / (arr.length - 2);
  54.         //输出平均分
  55.         System.out.println("选手的最终得分是：" + avg);
  57.     }
  59.     /*
  60.         两个明确：
  61.             返回值类型：int
  62.             参数：int[] arr
  63.      */
  64.     public static int getSum(int[] arr) {
  65.         int sum = 0;
  67.         for(int x=0; x<arr.length; x++) {
  68.             sum += arr[x];
  69.         }
  71.         return sum;
  72.     }
  74.     /*
  75.         两个明确：
  76.             返回值类型：int
  77.             参数：int[] arr
  78.      */
  79.     public static int getMin(int[] arr) {
  80.         int min = arr[0];
  82.         for(int x=1; x<arr.length; x++) {
  83.             if(arr[x] < min) {
  84.                 min = arr[x];
  85.             }
  86.         }
  88.         return min;
  89.     }
  91.     /*
  92.         两个明确：
  93.             返回值类型：int
  94.             参数：int[] arr
  95.      */
  96.     public static int getMax(int[] arr) {
  97.         int max = arr[0];
  99.         for(int x=1; x<arr.length; x++) {
  100.             if(arr[x] > max) {
  101.                 max = arr[x];
  102.             }
  103.         }
  105.         return max;
  106.     }
  108.     //遍历数组
  109.     public static void printArray(int[] arr) {
  110.         System.out.print("[");
  112.         for (int x = 0; x < arr.length; x++) {
  113.             if (x == arr.length - 1) {
  114.                 System.out.print(arr[x]);
  115.             } else {
  116.                 System.out.print(arr[x] + ", ");
  117.             }
  118.         }
  120.         System.out.println("]");
  121.     }
  122. }

类和对象

客观存在的事物皆为对象 ，所以我们也常常说万物皆对象。
类
类的理解
类是对现实生活中一类具有共同属性和行为的事物的抽象
类是对象的数据类型，类是具有相同属性和行为的一组对象的集合
简单理解：类就是对现实事物的一种描述
类的组成
属性：指事物的特征，例如：手机事物（品牌，价格，尺寸）
行为：指事物能执行的操作，例如：手机事物（打电话，发短信）
类和对象的关系
类：类是对现实生活中一类具有共同属性和行为的事物的抽象
对象：是能够看得到摸的着的真实存在的实体
简单理解：类是对事物的一种描述，对象则为具体存在的事物

类的定义

类的组成是由属性和行为两部分组成
属性：在类中通过成员变量来体现（类中方法外的变量）
行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）
类的定义步骤：
①定义类
②编写类的成员变量
③编写类的成员方法

  1. public class 类名 {
  2.     // 成员变量
  3.     变量1的数据类型 变量1；
  4.     变量2的数据类型 变量2;
  5.     …
  6.     // 成员方法
  7.     方法1;
  8.     方法2;
  9. }

示例：

  1. package com.itheima_01;
  2. /*
  3.     类的定义
  5.     类的定义步骤：
  6.         定义类
  7.         编写类的成员变量
  8.         编写类的成员方法
  10.     手机类：
  11.         类名：
  12.         手机(Phone)
  14.         成员变量：
  15.         品牌(brand)
  16.         价格(price)
  18.         成员方法：
  19.         打电话(call)
  20.         发短信(sendMessage)
  21.  */
  22. public class Phone {
  23.     //成员变量
  24.     String brand;
  25.     int price;
  27.     //成员方法
  28.     public void call() {
  29.         System.out.println("打电话");
  30.     }
  32.     public void sendMessage() {
  33.         System.out.println("发短信");
  34.     }
  35. }

对象的使用

创建对象的格式：
类名 对象名 = new 类名();
调用成员的格式：
对象名.成员变量
对象名.成员方法();
示例代码：

  1. package com.itheima_01;
  2. /*
  3.     创建对象
  4.         格式：类名 对象名 = new 类名();
  5.         范例：Phone p = new Phone();
  7.     使用对象
  8.         1：使用成员变量
  9.             格式：对象名.变量名
  10.             范例：p.brand
  11.         2：使用成员方法
  12.             格式：对象名.方法名()
  13.             范例：p.call()
  14.  */
  15. public class PhoneDemo {
  16.     public static void main(String[] args) {
  17.         //创建对象
  18.         Phone p = new Phone();
  20.         //使用成员变量
  21.         System.out.println(p.brand);
  22.         System.out.println(p.price);
  24.         p.brand = "小米";
  25.         p.price = 2999;
  27.         System.out.println(p.brand);
  28.         System.out.println(p.price);
  30.         //使用成员方法
  31.         p.call();
  32.         p.sendMessage();
  33.     }
  34. }

对象-练习

需求：首先定义一个学生类，然后定义一个学生测试类，在学生测试类中通过对象完成成员变量和成员方法的使用
分析：
成员变量：姓名，年龄…
成员方法：学习，做作业…
示例代码：

  1. package com.itheima_02;
  2. /*
  3.     学生类
  4.  */
  5. public class Student {
  6.     //成员变量
  7.     String name;
  8.     int age;
  10.     //成员方法
  11.     public void study() {
  12.         System.out.println("好好学习，天天向上");
  13.     }
  15.     public void doHomework() {
  16.         System.out.println("键盘敲烂，月薪过万");
  17.     }
  18. }
  21. ----------------------------------------------------
  24. package com.itheima_02;
  25. /*
  26.     学生测试类
  27.  */
  28. public class StudentDemo {
  29.     public static void main(String[] args) {
  30.         //创建对象
  31.         Student s = new Student();
  33.         //使用对象
  34.         System.out.println(s.name + "," + s.age);
  36.         s.name = "林青霞";
  37.         s.age = 30;
  39.         System.out.println(s.name + "," + s.age);
  41.         s.study();
  42.         s.doHomework();
  43.     }
  44. }

当多个对象的引用指向同一个内存空间（变量所记录的地址值是一样的）
只要有任何一个对象修改了内存中的数据，随后，无论使用哪一个对象进行数据获取，都是修改后的数据。
**

成员变量和局部变量

成员变量和局部变量的区别

类中位置不同：成员变量（类中方法外）局部变量（方法内部或方法声明上）
内存中位置不同：成员变量（堆内存）局部变量（栈内存）
生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）局部变量（随着方法的调用而存在，醉着方法的调用完毕而消失）
初始化值不同：成员变量（有默认初始化值）局部变量（没有默认初始化值，必须先定义，赋值才能使用）

封装

private关键字

private是一个修饰符，可以用来修饰成员（成员变量，成员方法）
被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰
示例代码：

  1. package com.itheima_04;
  3. /*
  4.     学生类
  5.  */
  6. public class Student {
  7.     //成员变量
  8.     String name;
  9. //    int age;
  10.     private int age;
  12.     //提供get/set方法
  13.     public void setAge(int a) {
  14. //        age = a;
  16.         if(a<0 || a>120) {
  17.             System.out.println("你给的年龄有误");
  18.         } else {
  19.             age = a;
  20.         }
  21.     }
  23.     public int getAge() {
  24.         return age;
  25.     }
  27.     //成员方法
  28.     public void show() {
  29.         System.out.println(name + "," + age);
  30.     }
  31. }
  34. package com.itheima_04;
  36. /*
  37.     学生测试类
  38.  */
  39. public class StudentDemo {
  40.     public static void main(String[] args) {
  41.         //创建对象
  42.         Student s = new Student();
  44.         //给成员变量赋值
  45.         s.name = "林青霞";
  46. //        s.age = 30;
  47. //        s.age = -30;
  48.         s.setAge(30);
  49. //        s.setAge(-30);
  51.         //调用show方法
  52.         s.show();
  53.     }
  54. }

private的使用

需求：定义标准的学生类，要求name和age使用private修饰，并提供set和get方法以及便于显示数据的show方法，测试类中创建对象并使用，最终控制台输出 林青霞，30
示例代码：

  1. package com.itheima_04;
  3. /*
  4.     学生类
  5.  */
  6. public class Student {
  7.     //成员变量
  8.     String name;
  9. //    int age;
  10.     private int age;
  12.     //提供get/set方法
  13.     public void setAge(int a) {
  14. //        age = a;
  16.         if(a<0 || a>120) {
  17.             System.out.println("你给的年龄有误");
  18.         } else {
  19.             age = a;
  20.         }
  21.     }
  23.     public int getAge() {
  24.         return age;
  25.     }
  27.     //成员方法
  28.     public void show() {
  29.         System.out.println(name + "," + age);
  30.     }
  31. }
  34. package com.itheima_05;
  36. /*
  37.     学生测试类
  38.  */
  39. public class StudentDemo {
  40.     public static void main(String[] args) {
  41.         //创建对象
  42.         Student s = new Student();
  44.         //使用set方法给成员变量赋值
  45.         s.setName("林青霞");
  46.         s.setAge(30);
  48.         s.show();
  50.         //使用get方法获取成员变量的值
  51.         System.out.println(s.getName() + "---" + s.getAge());
  52.         System.out.println(s.getName() + "," + s.getAge());
  54.     }
  55. }

this关键字

this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）
方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量
示例代码：

  1. package com.itheima_06;
  3. /*
  4.     学生类
  5.  */
  6. public class Student {
  7.     private String name;
  8.     private int age;
  10. //    public void setName(String n) {
  11. //        name = n;
  12. //    }
  14.     public void setName(String name) {
  15. //        name = name;
  16.         this.name = name;
  17.     }
  19.     public String getName() {
  20.         return name;
  21.     }
  23. //    public void setAge(int a) {
  24. //        age = a;
  25. //    }
  27.     public void setAge(int age) {
  28.         this.age = age;
  29.     }
  31.     public int getAge() {
  32.         return age;
  33.     }
  35.     public void show() {
  36.         System.out.println(name + "," + age);
  37.     }
  38. }

this内存原理

this代表当前调用方法的引用，哪个对象调用的方法，this就代表哪一个对象
示例代码：

  1. public class StudentDemo {
  2.     public static void main(String[] args) {
  3.         Student s1 = new Student();
  4.         s1.setName("林青霞");
  5.         Student s2 = new Student();
  6.         s2.setName("张曼玉");
  7.     }
  8. }

封装思想

1、封装概述
是面向对象三大特征之一（封装，继承，多态） 是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的
2.、封装原则
将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问 成员变量private，提供对应的getXxx()/setXxx()方法
3.、封装好处
通过方法来控制成员变量的操作，提高了代码的安全性 把代码用方法进行封装，提高了代码的复用性

构造方法

构造方法概述

构造方法是一种特殊的方法
作用：创建对象 Student stu = new Student();
格式：
public class 类名{
修饰符 类名( 参数 ) {
}
}
功能：主要是完成对象数据的初始化
示例代码：

  1. package com.itheima_07;
  3. /*
  4.     学生类
  6.     构造方法：
  7.         作用：创建对象
  8.         功能：完成对象数据的初始化
  10.     格式：
  11.         修饰符 类名(参数) {
  13.         }
  15.         修饰符一般用：public
  16.  */
  17. public class Student {
  18.     private String name;
  19.     private int age;
  21.     //构造方法
  22.     public Student() {
  23.         System.out.println("无参构造方法");
  24.     }
  26.     public void show() {
  27.         System.out.println(name + "," + age);
  28.     }
  29. }
  32. package com.itheima_07;
  33. /*
  34.     测试类
  35.  */
  36. public class StudentDemo {
  37.     public static void main(String[] args) {
  38.         //创建对象
  39.         Student s = new Student();
  40.         s.show();
  41.     }
  42. }

构造方法的注意事项

构造方法的创建
如果没有定义构造方法，系统将给出一个默认的无参数构造方法 如果定义了构造方法，系统将不再提供默认的构造方法
构造方法的重载
如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法
推荐的使用方式
无论是否使用，都手工书写无参数构造方法
重要功能！
可以使用带参构造，为成员变量进行初始化
示例代码：

  1. package com.itheima_08;
  2. /*
  3.     学生类
  4.  */
  5. public class Student {
  6.     private String name;
  7.     private int age;
  9. //    public Student() {
  10. //        System.out.println("无参构造方法");
  11. //    }
  13.     public Student() {}
  15.     public Student(String name) {
  16.         this.name = name;
  17.     }
  19.     public Student(int age) {
  20.         this.age = age;
  21.     }
  23.     public Student(String name,int age) {
  24.         this.name = name;
  25.         this.age = age;
  26.     }
  28.     public void show() {
  29.         System.out.println(name + "," + age);
  30.     }
  31. }
  35. package com.itheima_08;
  37. /*
  38.     测试类
  39.  */
  40. public class StudentDemo {
  41.     public static void main(String[] args) {
  42.         //创建对象
  43.         Student s1 = new Student();
  44.         s1.show();
  46.         //public Student(String name)
  47.         Student s2 = new Student("林青霞");
  48.         s2.show();
  50.         //public Student(int age)
  51.         Student s3 = new Student(30);
  52.         s3.show();
  54.         //public Student(String name,int age)
  55.         Student s4 = new Student("林青霞",30);
  56.         s4.show();
  57.     }
  58. }

标准类制作

需求：定义标准学生类，要求分别使用空参和有参构造方法创建对象，空参创建的对象通过setXxx赋值，有参创建的对象直接赋值，并通过show方法展示数据。
示例代码：

  1. package com.itheima_09;
  3. /*
  4.     成员变量
  5.         使用private修饰
  7.     构造方法
  8.         提供一个无参构造方法
  9.         提供一个带多个参数的构造方法
  11.     成员方法
  12.         提供每一个成员变量对应的setXxx()/getXxx()
  13.         提供一个显示对象信息的show()
  14.  */
  15. public class Student {
  16.     //成员变量
  17.     private String name;
  18.     private int age;
  20.     //构造方法
  21.     public Student() {
  22.     }
  24.     public Student(String name, int age) {
  25.         this.name = name;
  26.         this.age = age;
  27.     }
  29.     //成员方法
  30.     public void setName(String name) {
  31.         this.name = name;
  32.     }
  34.     public String getName() {
  35.         return name;
  36.     }
  38.     public void setAge(int age) {
  39.         this.age = age;
  40.     }
  42.     public int getAge() {
  43.         return age;
  44.     }
  46.     public void show() {
  47.         System.out.println(name + "," + age);
  48.     }
  49. }
  52. package com.itheima_09;
  54. /*
  55.     创建对象并为其成员变量赋值的两种方式
  56.         1:无参构造方法创建对象后使用setXxx()赋值
  57.         2:使用带参构造方法直接创建带有属性值的对象
  58. */
  59. public class StudentDemo {
  60.     public static void main(String[] args) {
  61.         //无参构造方法创建对象后使用setXxx()赋值
  62.         Student s1 = new Student();
  63.         s1.setName("林青霞");
  64.         s1.setAge(30);
  65.         s1.show();
  67.         //使用带参构造方法直接创建带有属性值的对象
  68.         Student s2 = new Student("林青霞",30);
  69.         s2.show();
  70.     }
  71. }