递归、封装、构造器和this关键字8

知识点1：递归方法

递归方法的使用 * * 1. 递归方法：一个方法体内调用它自身。 * 2. 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。 * 3. 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。 * 死循环是我们开发中要避免出现的。进而递归方法也必须满足执行的有限性。否则的话，会报StackOverflowError 代码演示 public class RecursionTest { public static void main(String[] args) { RecursionTest test = new RecursionTest(); int sum = test.sum1(100); System.out.println("总和为：" + sum); int result = test.f(10); System.out.println("结果为：" + result); } //计算1-num所有自然数的和 public int sum(int num){ int sum = 0; for (int i = 1; i <= num; i++) { sum += i; } return sum; } //递归实现：1-100所有自然数的和 public int sum1(int num){ if(num == 1){ return 1; }else{ return sum1(num - 1) + num; } } //递归实现1：计算n! public int multiply(int num){ if(num == 1){ return 1; }else{ return multiply(num - 1) * num; } } //递归实现2：已知有一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n), // 其中n是大于0的整数，求f(10)的值。 public int f(int num){ if(num == 0){ return 1; }else if(num == 1){ return 4; }else{ //错误的 // return f(num + 2) - 2 * f(num + 1); //正确的 return 2 * f(num - 1) + f(num - 2); } } //递归实现3：已知一个数列：f(20) = 1,f(21) = 4,f(n+2) = 2*f(n+1)+f(n), //其中n是大于0的整数，求f(10)的值。 public int func(int num){ if(num == 20){ return 1; }else if(num == 21){ return 4; }else{ return func(num + 2) - 2 * func(num + 1); } } //递归实现4：斐波那契数列： 1 1 2 3 5 8 13 21 34 55 //f(1) = 1;f(2) = 1;f(n + 2) = f(n + 1) + f(n) //递归实现5：汉诺塔 //递归实现6：IO流时File类的使用：遍历指定文件目录下的所有文件名 public void printFileName(File file){ if(file.isDirectory()){ File[] files = file.listFiles(); for(int i = 0;i < files.length;i++){ printFileName(files[i]); } }else{ System.out.println(file.getAbsolutePath()); } } //递归实现7：快排 }

知识点2：面向对象的特征一：封装与隐藏

1. 封装性的体现之一：

1. 问题的引入 * 我们在创建一个类的对象之后，可以通过“对象.属性”的方式给属性赋值。默认情况下，赋的值需要满足指定的 * 数据类型和变量的存储值的范围。但是，在实际情况中，此属性的赋值，需要满足实际情况的一些限制条件。（比如： * legs必须是正数、且是偶数）。又由于我们不能直接在属性的声明位置加上此限制语句，则必须通过方法的 * 方法的方式给属性赋值，在方法内设置限制条件。则我们设计一个SetXxx()的方法。将此方法暴露出去（设置为public） * 同时，不允许在类的外部再直接修改此属性。则将此属性隐藏起来（设置为private)即可。 * * 1.1 为了出了类之后，能调用此属性的值，我们还需要提供一个getXxx()的方法。此方法声明为public的即可。 * * 2. 小结：设计类时，可以考虑把类中的属性私有化(private)，同时提供公共(public)的get和set方法，进行获取和设置此属性的操作。 代码演示 public class AnimalTest { public static void main(String[] args) { Animal ani = new Animal(); ani.name = "佩奇"; // ani.age = 1; // ani.legs = -4; ani.setLegs(14); // ani.legs = -14;//非法访问 ani.info(); // System.out.println(ani.legs); System.out.println(ani.getLegs()); } } class Animal { String name; private int age; private int legs;//腿的个数 //获取属性值的方法 public int getLegs(){ return legs; } //设置属性值的方法 //设计一个方法，通过方法给legs属性赋值 public void setLegs(int l){ if(l >= 0 && l % 2 == 0 && l <= 30){ legs = l; }else{ System.out.println("传入的数据非法!"); } } //提供age属性的get和set方法 public int getAge(){ return age; } public void setAge(int a){ age = a; } public void info() { System.out.println("name = " + name + ", age = " + age + ",legs = " + legs); } }

2. 封装性的体现之二：

在类中声明方法时，可以将此方法声明为private。表明此方法只能在类内部使用。 代码演示 public void sort(Student[] stus,String sortMethod){ if("ascend".equals(sortMethod)){ for(int i = 0;i < stus.length - 1;i++){ for(int j = 0;j < stus.length - 1 - i;j++){ if(stus[j].score > stus[j + 1].score){ swap(stus,j,j + 1); } } } }else if("descend".equals(sortMethod)){ for(int i = 0;i < stus.length - 1;i++){ for(int j = 0;j < stus.length - 1 - i;j++){ if(stus[j].score < stus[j + 1].score){ swap(stus,j,j + 1); } } } }else{ System.out.println("排序方式有误！"); } } private void swap(Student[] stus,int i,int j){ Student temp = stus[i]; stus[i] = stus[j]; stus[j] = temp; }

3. 4种权限修饰符

3. 封装与隐藏，体现了设计java类及java类的内部结构时，其可被访问的权限的大小。 * java规定的4种访问权限修饰符：（从小到大的顺序） * private < 缺省 < protected < public 4. 我们可以使用4种权限修饰符修饰类及类的内部结构 * > 可以使用4种权限修饰符修饰：属性、方法、构造器、内部类 * > 可以使用缺省或public修饰符修饰：类。 （不能使用private\protected修饰类）

知识点3：类的成员之三：构造器

类的成员之三：构造器的使用 * * 1. Constructor = 构造器 = 构造方法 = 构造函数 * construct : 构建、构造 * * 2.构造器的作用： * ① 创建类的对象 （或 类的实例化） * ② 可以初始化对象的信息（比如：属性的初始化） * * 3. 说明： * ① 任何一个类，如果没有显式提供构造器的话，系统都会默认提供一个空参的构造器 * ② 自定义构造器的格式： 权限修饰符 类名(形参列表){ } * ③ 类中可以声明多个构造器，彼此构成重载 * ④ 一旦显式的定义了类的构造器，则系统不再提供默认的空参的构造器。 代码演示 public class PersonTest { public static void main(String[] args) { Person p1 = new Person(); p1.name = "吴"; p1.age = 25; p1.eat(); p1.sleep(6); System.out.println("####################"); Person p2 = new Person("石"); System.out.println(p2.name);//石 } } class Person{ //属性 String name; int age; //构造器 public Person(){ System.out.println("hello,Person()"); } public Person(String n){ name = n; } public Person(int a){ if(a >= 0 && a <= 130){ age = a; } } //方法 public void eat(){ System.out.println("人每天需要吃饭"); } public void sleep(int hour){ System.out.println("人每天需要保证" + hour + "小时的睡眠"); } }

知识点4：类中属性赋值的位置及先后顺序

/** * 小结：类中属性赋值的位置及执行先后顺序测试 * * 1. 类中的属性都可以在哪些位置赋值？ * ① 默认初始化 * ② 显式初始化 * ③ 构造器中初始化 * * ④ 在创建了对象之后，使用"对象.方法" 或 "对象.属性"的方式赋值 * * * 2. 赋值的先后顺序： * ① - ② - ③ - ④ * * 3. 上述的 ①、②、③过程，在对象实例化过程中，只能执行一次！ * * @author tzm * @create 2020-07-03 14:40 */ public class UserTest { public static void main(String[] args) { User u1 = new User(); System.out.println(u1.name); User u2 = new User(10); System.out.println(u2.age); } } class User{ String name = "Tom"; int age = 1; public User(){} public User(int a){ age = a; } }

知识点5：this关键字的使用

1. this可以调用属性、方法、构造器

1. this调用属性、方法

2. this调用属性、方法： * this可以理解为：当前对象 或 当前正在创建的对象 * * 2.1 在类的方法内或构造器内执行操作时，如果方法的形参或构造器的形参与类的属性名相同，则 * 必须显式的通过"this."的方式，表明调用的当前类的属性。如果省略了"this."，则认为调用的是形参。 * 2.2 在类的方法内或构造器内执行操作时，如果方法的形参或构造器的形参与类的属性名不相同时， * 则调用类的属性时，前面修饰的"this."可以省略。 * * 2.3 在类的方法中，我们可以通过"this."的方式调用本类中的其他方法。只是大多数情况下，我们都 * 省略了"this."。 代码演示 class Person{ private String name; private int age; public void setName(String name){ this.name = name; } public void setAge(int age){ this.age = age; } public String getName(){ return name; } public int getAge(){ return age; } public void eat(){ System.out.println("人：吃饭"); this.sleep(); } public void sleep(){ System.out.println("人：睡觉"); } }

2. this调用构造器

3. this调用构造器： * ① this调用构造器的格式：this(形参列表) * ② 在类的构造器中，我们可以显示的使用"this(形参列表)"的方式，调用本类中的其他构造器。 * ③ “this(形参列表)”必须声明在类的构造器的首行！ * ④ 在类的一个构造器中，只能最多声明一个“this(形参列表)” * ⑤ 如果一个类中声明了n个构造器，则最多有n - 1 个构造器中使用了“this(形参列表)” 代码演示 class Person{ private String name; private int age; public Person(){ // this("吴"); System.out.println("我是一个人。我刚出生，需要洗澡！"); } public Person(String name){ this(); this.name = name; } public Person(String name,int age){ this(name); this.age = age; // this.eat(); } }

知识点6：其他

1. javaBean

/** * 满足如下条件的类，可以称为是一个javabean： * >类是公共的 * >有一个无参的公共的构造器 * >有属性，且有对应的get、set方法 * * @author tzm * @create 2020-07-03 15:12 */ public class Student { private int number;//学号 private int state;//年级 private int score;//成绩 public int getNumber() { return number; } public void setNumber(int n) { number = n; } public int getState() { return state; } public void setState(int s) { state = s; } public int getScore() { return score; } public void setScore(int s) { score = s; } }

2.UML类图

昨天作业重点题目

数据类：Student类 //数据 class Student{ int number;//学号 int state;//年级 int score;//成绩 public void info(){ System.out.println("number : " + number + ", state : " + state + ", score : " + score); } } 操作数据的工具类：StudentUtil //操作数据的工具类 class StudentUtil{ /** * 根据指定的条件，创建相应的学生数组，并给数组元素赋值 * @param length 指定学生数组的长度 * @param lowState 指定学生对象的年级的下边界 * @param highState 指定学生对象的年级的上边界 * @param lowScore 指定学生对象的成绩的下边界 * @param highScore 指定学生对象的成绩的上边界 * @return 返回满足指定条件的数组 */ public Student[] getStudentArray(int length,int lowState,int highState,int lowScore,int highScore){ Student[] stus = new Student[length];//虚位以待 for (int i = 0; i < stus.length; i++) { stus[i] = new Student(); //给每一个学生的属性赋值 //学号 stus[i].number = i + 1; //年级：1-6 stus[i].state = (int)(Math.random() * (highState - lowState + 1) + lowState); //成绩：0-100 stus[i].score = (int)(Math.random() * (highScore - lowScore + 1) + lowScore); } return stus; } /** * 遍历学生数组，打印出指定年级学生的信息 * @param stus 待遍历的数组 * @param state 指定的学生年级 */ public void printStudentState(Student[] stus,int state){ for (int i = 0; i < stus.length; i++) { if (stus[i].state == state) { stus[i].info(); } } } /** * 排序Student数组:使用冒泡排序 * @param stus * @param sortMethod */ public void sort(Student[] stus,String sortMethod){ if("ascend".equals(sortMethod)){ for(int i = 0;i < stus.length - 1;i++){ for(int j = 0;j < stus.length - 1 - i;j++){ if(stus[j].score > stus[j + 1].score){ swap(stus,j,j + 1); } } } }else if("descend".equals(sortMethod)){ for(int i = 0;i < stus.length - 1;i++){ for(int j = 0;j < stus.length - 1 - i;j++){ if(stus[j].score < stus[j + 1].score){ swap(stus,j,j + 1); } } } }else{ System.out.println("排序方式有误！"); } } private void swap(Student[] stus,int i,int j){ Student temp = stus[i]; stus[i] = stus[j]; stus[j] = temp; } /** * 遍历Student数组 * @param stus */ public void print(Student[] stus){ for (int i = 0; i < stus.length; i++) { stus[i].info(); } } } 测试类 //测试类 public class Exer3 { public static void main(String[] args) { StudentUtil util = new StudentUtil(); // 创建20个学生对象 Student[] stus = util.getStudentArray(20, 1, 6, 0, 100); //问题一：打印出3年级(state值为3）的学生信息。 util.printStudentState(stus,3); //问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息 // util.sort(stus,"descend"); //遍历操作 // util.print(stus); } }