java学习笔记12 面向对象的特征之二：继承性 why?一、继承性的好处：减少了代码的冗余，提高了代码的复用性便于功能的扩展为之后多态性的使用，提供了前提二、继承性的格式：class A extends B{}A:子类、派生类、subclassB:父类、超类、基类、superclass2.1体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只有因为封装性的影响，使得子类不能直接调用父类的结构而已。2.2 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。子类和父类的关系，不同于子集和集合的关系。extends：延展、扩展三、Java中关于继承性的规定：一个类可以被多个子类继承。Java中类的单继承性：一个类只能有一个父类子父类是相对的概念。子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法四、 Object类如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类所有的java类（除java.lang.Object类之外）都直接或间接的继承于java.lang.Object类意味着，所有的java类具有java.lang.Object类声明的功能。Creature.javapackage com.atguigu.java; /** * @program: project13 * @description: Creature类 * @author: kkx * @create: 2022-03-10 16:31 **/ public class Creature { public void breath(){ System.out.println("呼吸"); } }Person.javapackage com.atguigu.java; /** * @program: project13 * @description: Person类 * @author: kkx * @create: 2022-03-10 15:50 **/ public class Person extends Creature{ String name; private int age; public Person(){ } public Person(String name, int age){ this.name = name; this.age = age; } public void eat(){ System.out.println("吃饭"); } public void sleep(){ System.out.println("睡觉"); } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }Student.javapackage com.atguigu.java; /** * @program: project13 * @description: Student类，继承 * @author: kkx * @create: 2022-01-05 10:22 **/ public class Student extends Person{ // String name; // int age; String major; public Student(){ } public Student(String name, int age, String major) { this.name = name; // this.age = age; setAge(age); this.major = major; } // public void sleep(){ // System.out.println("睡觉"); // } public void study(){ System.out.println("studying"); } public void show(){ System.out.println("name:" + name + ", age:" + getAge()); } }ExtendsTest.javapackage com.atguigu.java; /** * @program: project13 * @description: 继承测试 * @author: kkx * @create: 2022-01-05 10:24 **/ public class ExtendsTest { public static void main(String[] args) { Person p1 = new Person(); // p1.age = 1; p1.eat(); System.out.println(); Student s1 = new Student(); s1.eat(); s1.sleep(); s1.name = "Tom"; s1.setAge(10); s1.show(); s1.breath(); Creature c = new Creature(); System.out.println(c.toString()); } }

java学习笔记10 1. 理解“万事万物皆对象”1.在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构Scanner,String等 文件：File 网络资源：URL2. 涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。2、内存解析的说明引用类型的变量，只可能存储两类值：null 或 地址值（含变量的类型）3. 匿名对象的使用理解：我们创建的对象，没有显式的赋给一个变量名。即为匿名对象特征：匿名对象只能调用一次。java代码package com.atguigu.java; /** * @description: 匿名对象 * @author: kkx * @create: 2021-12-12 12:59 **/ public class InstanceTest { public static void main(String[] args) { Phone p = new Phone(); p.playGame(); new Phone().playGame(); new Phone().price = 1999; new Phone().showPrice(); //0.0 //常用 PhoneMall mall = new PhoneMall(); //匿名对象的使用 mall.show(new Phone()); } } class PhoneMall{ public void show(Phone phone){ phone.sendEmail(); phone.playGame(); } } class Phone{ double price; public void sendEmail(){ System.out.println("发送邮件"); } public void playGame(){ System.out.println("玩游戏"); } public void showPrice(){ System.out.println("价格为" + price); } }4. 自定义工具类的封装package com.atguigu.java; /** * @description: 工具类的封装 * @author: kkx * @create: 2021-12-12 13:38 **/ public class ArrayUtil { // 求数组的最大值 public int getMax(int[] arr){ int maxValue = arr[0]; for (int i = 1; i < arr.length; i++) { if (maxValue < arr[i]) { maxValue = arr[i]; } } return maxValue; } // 求数组的最小值 public int getMin(int[] arr){ int minValue = arr[0]; for (int i = 1; i < arr.length; i++) { if (minValue > arr[i]) { minValue = arr[i]; } } return minValue; } // 求数组的总和 public int getSum(int[] arr){ int sum = 0; for (int i = 0; i < arr.length; i++) { sum += arr[i]; } return sum; } // 求数组的平均值 public int getAvg(int[] arr){ return getSum(arr) / arr.length; } //如下的两个同名方法构成了重载 // 反转数组 public void reverse(int[] arr){ for (int i = 0; i < arr.length / 2; i++) { int temp = arr[i]; arr[i] = arr[arr.length - i - 1]; arr[arr.length - i - 1] = temp; } } public void reverse(String[] arr){ } // 复制数组 public int[] copy(int[] arr) { int[] arr1 = new int[arr.length]; for (int i = 0; i < arr1.length; i++) { arr1[i] = arr[i]; } return arr1; } // 数组排序 public void sort(int[] arr){ // 冒泡排序 for (int i = 0; i < arr.length - 1; i++) { for (int j = 0; j < arr.length - 1 - i; j++) { if (arr[j] > arr[j + 1]) { int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } } // 遍历数组 public void print(int[] arr) { for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + "\t"); } System.out.println(); } // 查找指定元素 public int getIndex(int[] arr, int dest){ // 线性查找： for (int i = 0; i < arr.length; i++) { if (dest == arr[i]) { return i; } } return -1;//返回一个负数，表示没有找到 } }package com.atguigu.java; /** * @description: 使用自定义工具类 * @author: kkx * @create: 2021-12-12 13:44 **/ public class ArrayUtilTest { public static void main(String[] args) { ArrayUtil util = new ArrayUtil(); int[] arr = new int[]{32,34,32,5,3,54,654,-98,0,-53,5}; System.out.println("最大值为" + util.getMax(arr)); System.out.println("排序前："); util.print(arr); util.sort(arr); System.out.println("排序后："); util.print(arr); System.out.println("查找："); int index = util.getIndex(arr, -5); if(index >= 0){ System.out.println("找到了，索引地址为：" + index); }else{ System.out.println("未找到"); } util.reverse(arr); } }5. 方法的重载1. 定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。 "两同一不同":同一个类、相同方法名 参数列表不同：参数个数不同，参数类型不同2. 举例：Arrays类中重载的sort() / binarySearch()3. 判断是否是重载：跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！4. 在通过对象调用方法时，通过方法名和参数列表确定方法5. java代码package com.atguigu.java1; /** * @description: 方法的重载 * @author: kkx * @create: 2021-12-12 13:56 **/ public class OverLoadTest { public static void main(String[] args) { OverLoadTest test = new OverLoadTest(); test.getSum(1, 2); //1 test.getSum(1.0, 2.0); //2 } //如果没有这个方法，则提升为double的方法 public void getSum(int i, int j){ System.out.println(1); } public void getSum(double d1, double d2){ System.out.println(2); } //传参数有顺序要求，顺序不一样也重载 public void getSum(String s ,int i){ System.out.println(3); } public void getSum(int i,String s){ System.out.println(4); } /* 如下的3个方法不能与上述4个方法构成重载 跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系 public int getSum(int i,int j){ return 0; } public void getSum(int m,int n){ } private void getSum(int i,int j){ } */ }6. 可变个数形参的方法可变个数形参的格式：数据类型 ... 变量名当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。可变个数形参在方法的形参中，必须声明在末尾可变个数形参在方法的形参中,最多只能声明一个可变形参。package com.atguigu.java1; import java.util.Arrays; /** * @program: project10 * @description: 可变个数形参的方法 * @author: kkx * @create: 2021-12-13 20:51 **/ public class MethodArgsTest { public static void main(String[] args) { MethodArgsTest test = new MethodArgsTest(); test.show("hello world"); test.show(new String[]{"AA", "BB"}); } public void show(String s){ System.out.println("String s"); } public void show(String ... strings){ System.out.println("String ... strings"); System.out.println(Arrays.toString(strings)); } //不能与上一个方法同时存在 // public void show(String[] strs){ // // } }7. 关于变量的赋值基本数据类型，此时赋值的是变量所保存的数据值。引用数据类型，此时赋值的是变量所保存的数据的地址值。package com.atguigu.java1; /** * @program: project10 * @description: 关于变量的赋值 * @author: kkx * @create: 2021-12-13 22:41 **/ public class ValueTransferTest { public static void main(String[] args) { int m = 10; int n = m; System.out.println(m + "\t"+ n); n = 20; System.out.println(m + "\t"+ n); Order o1 = new Order(); o1.orderId = 1001; Order o2 = o1;//赋值以后，o1和o2的地址值相同 System.out.println(o1.orderId + "\t" + o2.orderId); o2.orderId = 1002; System.out.println(o1.orderId + "\t" + o2.orderId); } } class Order{ int orderId; }package com.atguigu.java1; /** * @program: project10 * @description: 方法的形参的传递机制：值传递 * @author: kkx * @create: 2021-12-13 23:12 **/ public class ValueTransferTest1 { public static void main(String[] args) { int m = 10; int n = 20; System.out.println(m + "\t" + n); //10 20 ValueTransferTest1 test = new ValueTransferTest1(); test.swap(m, n); System.out.println(m + "\t" + n); //10 20 } public void swap(int m, int n){ int temp = m; m = n; n = temp; } }package com.atguigu.java1; /** * @program: project10 * @description: 实现交换 * @author: kkx * @create: 2021-12-13 23:40 **/ public class ValueTransferTest2 { public static void main(String[] args) { Data data = new Data(); data.m = 10; data.n = 20; System.out.println(data.m + "\t" + data.n); //10 20 ValueTransferTest2 test = new ValueTransferTest2(); test.swap(data); System.out.println(data.m + "\t" + data.n); //20 10 } public void swap(Data data){ int temp = data.m; data.m = data.n; data.n = temp; } } class Data{ int m; int n; }8. 面试题/** * @program: project10 * @description: 面试坑1 * @author: kkx * @create: 2021-12-14 23:34 **/ public class test { public static void main(String[] args) { int a = 10; int b = 10; method(a, b); //仅输出a = 100,b = 200 System.out.println("a=" + a); System.out.println("b=" + b); } public static void method(int a, int b){ //自己编写 a = a * 10; b = b * 20; System.out.println(a); System.out.println(b); System.exit(0); } }/** * @program: project10 * @description: 面试坑2 * @author: kkx * @create: 2021-12-14 23:39 **/ public class test1 { public static void main(String[] args) { int[] arr = new int[]{1, 2, 3}; System.out.println(arr); //地址值 char[] arr1 = new char[]{'a', 'b', 'c'}; System.out.println(arr1); //abc } }9. 递归递归方法：一个方法体内调用它自身。方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。package com.atguigu.java1; /** * @program: project10 * @description: 递归 * @author: kkx * @create: 2021-12-17 00:35 **/ public class RecursionTest { public static void main(String[] args) { // 例1：计算1-100之间所有自然数的和 // 方式一： int sum = 0; for (int i = 1; i <= 100; i++) { sum += i; } System.out.println(sum); // 方式二： RecursionTest test = new RecursionTest(); System.out.println(test.getSum1(100)); System.out.println(test.f(10)); System.out.println(test.fibonacci(10)); } // 例1：计算1-n之间所有自然数的和 public int getSum(int n){ if (n == 1){ return 1; }else { return n + getSum(n - 1); } } // 例2：计算1-n之间所有自然数的乘积:n! public int getSum1(int n){ if (n == 1){ return 1; }else { return n * getSum(n - 1); } } //例3：已知有一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n), public int f(int n){ if (n == 0){ return 1; }else if(n == 1){ return 4; }else { return 2 * f(n - 1) + f(n - 2); } } //例4：斐波那契数列 public int fibonacci(int n){ if (n == 0){ return 0; }else if(n == 1){ return 1; }else { return fibonacci(n - 1) + fibonacci(n - 2); } } //例5：汉诺塔问题 //例6：快排 }

java学习笔记7 {music id="1861224068" color="#1989fa" autoplay="autoplay"/}1. 数组1. 概念数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理2. 组成数组名元素索引数组的长度：元素的个数3. 特点数组是有序排列的数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型创建数组对象会在内存中开辟一整块连续的空间数组的长度一旦确定，就不能修改。4. 数组分类按照维数：一维数组、二维数组、。。。按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组2. 一维数组1. 一维数组的使用一维数组的声明和初始化如何调用数组的指定位置的元素如何获取数组的长度如何遍历数组数组元素的默认初始化值 ：见ArrayTest1.java数组元素是整型：0 数组元素是浮点型：0.0 数组元素是char型：0或'\u0000'，而非'0' 数组元素是boolean型：false 数组元素是引用数据类型：null数组的内存解析 ：见ArrayTest1.javapackage com.atguigu.java; public class ArrayTest { public static void main(String[] args) { //1. 一维数组的声明和初始化 int [] ids;//声明 //1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行 ids = new int[]{01, 02, 03, 04, 05}; //1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行 String [] names = new String[5]; int[] arr1 = new int[] {1,2,3,4,5}; int[] arr4 = {1,2,3,4,5};//类型推断 //2.如何调用数组的指定位置的元素:通过角标的方式调用。 names[0] = "00"; names[1] = "11"; names[2] = "22"; names[3] = "33"; names[4] = "44"; //3.如何获取数组的长度。(length) System.out.println(names.length); //4.如何遍历数组 for (int i = 0; i < names.length; i++) { System.out.println(names[i]); } } }package com.atguigu.java; public class ArrayTest1 { public static void main(String[] args) { //5.数组元素的默认初始化值 int [] arr = new int[4]; for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } short [] arr1 = new short[4]; System.out.println(arr1[0]); float[] arr2 = new float[4]; System.out.println(arr2[0]); char[] arr3 = new char[4]; System.out.println(arr3[0]); //0 if(arr3[0] == 0){ System.out.println("你好！"); //进来这里 } boolean[] arr4 = new boolean[4]; System.out.println(arr4[0]); String [] arr5 = new String[4]; System.out.println(arr5[0]); //null if(arr5[0] == null){ System.out.println("北京天气不错！"); //进来这里 } } }2. 一维数组例题/* 从键盘读入学生成绩，找出最高分，并输出学生成绩等级。 成绩>=最高分-10 等级为’A’ 成绩>=最高分-20 等级为’B’ 成绩>=最高分-30 等级为’C’ 其余 等级为’D’ */ package com.atguigu.exer; import java.util.Scanner; public class ArrayDemo1 { public static void main(String[] args) { //1.使用Scanner，读取学生个数 Scanner scanner = new Scanner(System.in); System.out.println("学生人数"); int number = scanner.nextInt(); //2.创建数组，存储学生成绩：动态初始化 int[] scores = new int[number]; //3.给数组中的元素赋值 System.out.println("请输入" + number + "个学生成绩："); int maxScore = 0; for (int i = 0; i < scores.length; i++) { scores[i] = scanner.nextInt(); //4.获取数组中的元素的最大值:最高分 if (maxScore < scores[i]){ maxScore = scores[i]; } } //5.根据每个学生成绩与最高分的差值，得到每个学生的等级，并输出等级和成绩 char level; for (int i = 0; i < scores.length; i++) { if (maxScore - scores[i] <= 10){ level = 'A'; }else if(maxScore - scores[i] <= 20){ level = 'B'; }else if(maxScore - scores[i] <= 30){ level = 'C'; }else{ level = 'D'; } System.out.println("student" + i + "成绩为" + scores[i] + "等级为" + level); } } }3. 二维数组1. 二维数组的概念对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。 其实，从数组底层的运行机制来看，其实没有多维数组2. 二维数组的使用:二维数组的声明和初始化如何调用数组的指定位置的元素如何获取数组的长度如何遍历数组数组元素的默认初始化值 :见 ArrayTest3.java针对于初始化方式一：比如：int[][] arr = new int4; 外层元素的初始化值为：地址值 内层元素的初始化值为：与一维数组初始化情况相同 针对于初始化方式二：比如：int[][] arr = new int[4][]; 外层元素的初始化值为：null 内层元素的初始化值为：不能调用，否则报错。数组的内存解析 :见 ArrayTest3.javapackage com.atguigu.java; public class ArrayTest2 { public static void main(String[] args) { //1.二维数组的声明和初始化 int [][] arr1 = new int [][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; String [][] arr2 = new String[3][2]; String [][] arr3 = new String[3][]; int arr4 [][] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}}; int[] arr5[] = {{1,2,3},{4,5},{6,7,8}}; //2.如何调用数组的指定位置的元素 System.out.println(arr1[0][1]); //2 System.out.println(arr2[1][1]); //null arr3[1] = new String[4]; // System.out.println(arr3[1][0]); //3.获取数组的长度 System.out.println(arr4.length); //3 System.out.println(arr4[0].length); //3 //4.如何遍历二维数组 for (int i = 0; i < arr4.length; i++) { for (int j = 0; j < arr4[i].length; j++) { System.out.print(arr4[i][j] + "\t"); } System.out.println(); } } }package com.atguigu.java; public class ArrayTest3 { public static void main(String[] args) { int [][] arr = new int[4][3]; System.out.println(arr); // 内存地址 System.out.println(arr[0]); // 内存地址 System.out.println(arr[0][0]); // 0 float [][] arr1 = new float[4][3]; System.out.println(arr1[0]); // 内存地址 System.out.println(arr1[0][0]); // 0.0 String[][] arr2 = new String[4][3]; System.out.println(arr2[0]); //地址值 System.out.println(arr2[0][0]); //null double[][] arr3 = new double[4][]; System.out.println(arr3[0]); //null //System.out.println(arr3[0][0]); //报错，空指针 } }

java project 家庭收支记账软件 {music id="1818128141" color="#1989fa" autoplay="autoplay"/}家庭收支记账软件1. 自己编写的java文件FamilyAccount.java//FamilyAccount.java public class FamilyAccount { public static void main(String[] args) { boolean isFlag = true; String details = "收支\t账户金额\t收支金额\t说 明\n"; int balance = 10000; while (isFlag){ System.out.println("-----------------家庭收支记账软件-----------------\n"); System.out.println(" 1 收支明细"); System.out.println(" 2 登记收入"); System.out.println(" 3 登记支出"); System.out.println(" 4 退 出\n"); System.out.print(" 请选择(1-4)："); //获取输入 char selection = Utility.readMenuSelection(); switch (selection){ case '1': //1.收支明细 System.out.println("-----------------当前收支明细记录-----------------"); System.out.println(details); System.out.println("--------------------------------------------------"); break; case '2': //2.登记收入 System.out.print("本次收入金额："); int addMoney = Utility.readNumber(); System.out.print("本次收入说明："); String addInfo = Utility.readString(); balance += addMoney; details += ("收入\t" + balance + "\t\t" + addMoney + "\t\t" + addInfo + "\n"); System.out.println("---------------------登记完成---------------------\n"); break; case '3': //3.登记支出 System.out.print("本次支出金额："); int minusMoney = Utility.readNumber(); System.out.print("本次支出说明："); String minusInfo = Utility.readString(); if (balance >= minusMoney){ balance -= minusMoney; details += ("支出\t" + balance + "\t\t" + minusMoney + "\t\t" + minusInfo + "\n"); }else { System.out.println("钱不够，付不了~~~"); } System.out.println("---------------------登记完成---------------------\n"); break; case '4': //4.退 出 System.out.print("确认是否退出(Y/N)："); char isExit = Utility.readConfirmSelection(); if (isExit == 'Y'){ isFlag = false; } break; } } } }2. 别人写好的工具类Utility.java//Utility.java import java.util.Scanner; /** Utility工具类： 将不同的功能封装为方法，就是可以直接通过调用方法使用它的功能，而无需考虑具体的功能实现细节。 */ public class Utility { private static Scanner scanner = new Scanner(System.in); /** 用于界面菜单的选择。该方法读取键盘，如果用户键入’1’-’4’中的任意字符，则方法返回。返回值为用户键入字符。 */ public static char readMenuSelection() { char c; for (; ; ) { String str = readKeyBoard(1); c = str.charAt(0); if (c != '1' && c != '2' && c != '3' && c != '4') { System.out.print("选择错误，请重新输入："); } else break; } return c; } /** 用于收入和支出金额的输入。该方法从键盘读取一个不超过4位长度的整数，并将其作为方法的返回值。 */ public static int readNumber() { int n; for (; ; ) { String str = readKeyBoard(4); try { n = Integer.parseInt(str); break; } catch (NumberFormatException e) { System.out.print("数字输入错误，请重新输入："); } } return n; } /** 用于收入和支出说明的输入。该方法从键盘读取一个不超过8位长度的字符串，并将其作为方法的返回值。 */ public static String readString() { String str = readKeyBoard(8); return str; } /** 用于确认选择的输入。该方法从键盘读取‘Y’或’N’，并将其作为方法的返回值。 */ public static char readConfirmSelection() { char c; for (; ; ) { String str = readKeyBoard(1).toUpperCase(); c = str.charAt(0); if (c == 'Y' || c == 'N') { break; } else { System.out.print("选择错误，请重新输入："); } } return c; } private static String readKeyBoard(int limit) { String line = ""; while (scanner.hasNext()) { line = scanner.nextLine(); if (line.length() < 1 || line.length() > limit) { System.out.print("输入长度（不大于" + limit + "）错误，请重新输入："); continue; } break; } return line; } }

java学习笔记6 {music id="1861194866" color="#1989fa" autoplay="autoplay"/}1. 嵌套循环的使用1. 定义将一个循环结构A声明在另一个循环结构B的循环体中,就构成了嵌套循环2. java代码public class ForForTest { public static void main(String[] args) { for (int i = 0; i < 5; i++) { System.out.print("*"); } System.out.println('\n'); for (int j = 0; j < 4; j++) { for (int i = 0; i < 5; i++) { System.out.print("*"); } System.out.println(); } /* i(行号) j(*的个数) * 1 1 ** 2 2 *** 3 3 **** 4 4 ***** 5 5 */ for (int i = 0; i < 5; i++) { for (int j = 0; j <= i; j++) { System.out.print("*"); } System.out.println(); } /* i(行号) j(*的个数) 规律：i + j = 5 换句话说：j = 5 - i; **** 1 4 *** 2 3 ** 3 2 * 4 1 */ for (int i = 0; i < 4; i++) { for (int j = 0; j < 4 - i; j++) { System.out.print("*"); } System.out.println(); } } }3. Tip内层遍历一遍，相当于外层循环一次假设外层循环执行m次，内层循环执行n次。 此时内层循环的循环体一共执行了m * n次4. 九九乘法表public class NineNineTable { public static void main(String[] args) { for (int i = 1; i <= 9; i++) { for (int j = 1; j <= i; j++) { System.out.print(i + "*" + j + "=" + (i * j) + "\t"); } System.out.println(); } } }2. break,continue,label的基本使用1. break,continue的基本使用break和continue使用范围循环中使用的作用(不同点)相同点break:switch-case 循环结构中结束当前循环关键字后面不能声明执行语句continue:循环结构中结束当次循环关键字后面不能声明执行语句2. java代码public class BreakContinueTest { public static void main(String[] args) { for(int i = 1;i <= 10;i++){ if(i % 4 == 0){ break;//123 //continue;//123567910 //System.out.println("今晚迪丽热巴要约我！！！"); } System.out.print(i); } System.out.println(); for (int i = 1; i <= 4; i++) { for (int j = 1; j <= 10; j++) { if(j % 4 == 0){ break; } System.out.print(j); } System.out.println(); } label:for(int i = 1;i <= 4;i++){ for(int j = 1;j <= 10;j++){ if(j % 4 == 0){ //break label;//结束指定标识的一层循环结构 continue label;//结束指定标识的一层循环结构当次循环 } System.out.print(j); } System.out.println(); } } }2. 求100000以内的所有质数的输出（逐渐优化）1. 方法1public class PrimeNumberTest { public static void main(String[] args) { boolean isFlag = true; for (int i = 2; i <= 100; i++) { //遍历100以内的自然数 for (int j = 2; j < i; j++) { //j:被i去除 if (i % j == 0){ //i被j除尽 isFlag = false; break; } } if(isFlag == true){ System.out.println(i); } isFlag = true; //重置isFlag } } }2.方法2public class PrimeNumberTest1 { public static void main(String[] args) { boolean isFlag = true; int count = 0;//记录质数的个数 long start = System.currentTimeMillis();//时间戳 for (int i = 2; i <= 100000; i++) { //遍历100以内的自然数 for (int j = 2; j < Math.sqrt(i); j++) { //j:被i去除 if (i % j == 0){ //i被j除尽 isFlag = false; break; } } if(isFlag == true){ //System.out.println(i); count++; } isFlag = true; //重置isFlag } long end = System.currentTimeMillis();//时间戳 System.out.println("质数的个数为：" + count); System.out.println("所花费的时间为：" + (end - start));//17110 - 优化一：break:1546 - 优化二：13 } }3. 方法3public class PrimeNumberTest2 { public static void main(String[] args) { int count = 0;//记录质数的个数 long start = System.currentTimeMillis();//时间戳 label:for (int i = 2; i <= 100000; i++) { //遍历100以内的自然数 for (int j = 2; j < Math.sqrt(i); j++) { //j:被i去除 if (i % j == 0){ //i被j除尽 continue label; } } //能执行到此步骤的，都是质数 count++; } long end = System.currentTimeMillis();//时间戳 System.out.println("质数的个数为：" + count); System.out.println("所花费的时间为：" + (end - start));//17110 - 优化一：break:1546 - 优化二：13 } }