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 project 客户管理信息软件 客户管理信息软件{music id="1886456269" color="#1989fa" autoplay="autoplay"/}参考视频（p248-p259）{bilibili bvid="1Kb411W75N" page="248"/}CustomerView 主模块，菜单显示package com.atguigu.p2.ui; import com.atguigu.p2.bean.Customer; import com.atguigu.p2.service.CustomerList; import com.atguigu.p2.util.CMUtility; /** * @program: project12 * @description: 主模块，菜单显示，处理用户操作 * @author: kkx * @create: 2021-12-28 17:12 **/ public class CustomerView { private CustomerList customerList = new CustomerList(10); public CustomerView(){ //默认有一个 Customer customer = new Customer("王涛", '男', 23, "13212341234", "wt@gmail.com"); customerList.addCustomer(customer); } /** * @Description: 显示《客户信息管理软件》界面的方法 * @Author: kkx * @Date: 2022/1/4 * @Param: [] * @return: void */ public void enterMainMenu(){ boolean isFlag = true; while (isFlag){ System.out.println("\n-----------------客户信息管理软件-----------------\n"); System.out.println(" 1 添 加 客 户"); System.out.println(" 2 修 改 客 户"); System.out.println(" 3 删 除 客 户"); System.out.println(" 4 客 户 列 表"); System.out.println(" 5 退 出\n"); System.out.print(" 请选择(1-5)："); char menu = CMUtility.readMenuSelection(); switch (menu){ case '1': addNewCustomer(); break; case '2': modifyCustomer(); break; case '3': deleteCustomer(); break; case '4': listAllCustomers(); break; case '5': System.out.print ("确认是否退出(Y/N)："); char isExit = CMUtility.readConfirmSelection(); if (isExit == 'Y') { isFlag = false; } break; } } } /** * @Description: 添加客户的操作 * @Author: kkx * @Date: 2022/1/4 * @Param: [] * @return: void */ private void addNewCustomer(){ System.out.println("---------------------添加客户---------------------"); System.out.print("姓名："); String name = CMUtility.readString(10); System.out.print("性别："); char gender = CMUtility.readChar(); System.out.print("年龄："); int age = CMUtility.readInt(); System.out.print("电话："); String phone = CMUtility.readString(13); System.out.print("邮箱："); String email = CMUtility.readString(30); //包装 Customer customer = new Customer(name, gender, age, phone, email); boolean isSuccess = customerList.addCustomer(customer); if (isSuccess){ System.out.println("---------------------添加完成---------------------"); }else { System.out.println("-------------------客户目录已满，添加失败---------------"); } } /** * @Description: 修改客户的操作 * @Author: kkx * @Date: 2022/1/5 * @Param: [] * @return: void */ private void modifyCustomer(){ System.out.println("---------------------修改客户---------------------"); //这两个放外面是因为后面在循环外要调用 int number; Customer cust; for (;;){ System.out.print("请选择待修改客户编号(-1退出)："); number = CMUtility.readInt(); if (number == -1){ return; } cust = customerList.getCustomer(number - 1); if (cust == null){ System.out.println("无法找到指定客户！"); }else { break; } } //修改客户信息 System.out.print("姓名(" + cust.getName() + "):"); String name = CMUtility.readString(10, cust.getName()); System.out.print("性别(" + cust.getGender() + "):"); char gender = CMUtility.readChar(cust.getGender()); System.out.print("年龄(" + cust.getAge() + "):"); int age = CMUtility.readInt(cust.getAge()); System.out.print("电话(" + cust.getPhone() + "):"); String phone = CMUtility.readString(13, cust.getPhone()); System.out.print("邮箱(" + cust.getEmail() + "):"); String email = CMUtility.readString(30, cust.getEmail()); Customer newCust = new Customer(name, gender, age, phone, email); boolean isReplaced = customerList.replaceCustomer(number - 1, newCust); if (isReplaced){ System.out.println("---------------------修改完成---------------------"); }else { //没有机会执行 System.out.println("---------------------修改失败---------------------"); } } /** * @Description: 删除客户的操作 * @Author: kkx * @Date: 2022/1/5 * @Param: [] * @return: void */ private void deleteCustomer(){ System.out.println("---------------------删除客户---------------------"); int number; for (;;){ System.out.print("请选择待删除客户编号(-1退出)："); number = CMUtility.readInt(); if (number == -1){ return; } Customer customer = customerList.getCustomer(number -1); if (customer == null){ System.out.println("无法找到指定客户！"); }else { break; } } //找到了指定的客户，开始修改 System.out.print("确认是否删除(Y/N)："); char isDelete = CMUtility.readConfirmSelection(); if (isDelete == 'Y'){ boolean deleteSuccess = customerList.deleteCustomer(number - 1); if (deleteSuccess){ System.out.println("---------------------删除完成---------------------"); }else { //没有机会执行 System.out.println("---------------------删除失败---------------------"); } }else { return; } } /** * @Description: 显示客户列表的操作 * @Author: kkx * @Date: 2022/1/4 * @Param: [] * @return: void */ private void listAllCustomers(){ System.out.println("---------------------------客户列表---------------------------\n"); int total = customerList.getTotal(); if (total == 0){ System.out.println("没有客户记录！"); }else { System.out.println("编号\t姓名\t性别\t年龄\t电话\t\t邮箱"); Customer[] custs = customerList.getAllCustomers(); for (int i = 0; i < custs.length; i++) { Customer cust = custs[i]; System.out.println((i + 1) + "\t" + "\t" + cust.getName() + "\t" + cust.getGender() + "\t" + "\t" + cust.getAge() + "\t" + "\t" + cust.getPhone() + "\t" + cust.getEmail()); } } System.out.println("-------------------------客户列表完成-------------------------"); } public static void main(String[] args){ CustomerView view = new CustomerView(); view.enterMainMenu(); } }Customer管理package com.atguigu.p2.service; import com.atguigu.p2.bean.Customer; /** * @program: project12 * @description: Customer管理 * @author: kkx * @create: 2021-12-28 17:11 **/ public class CustomerList { private Customer[] customers; private int total; //记录存储的客户的个数 /** * @Description: 构造器，用来初始化customers数组 * @Author: kkx * @Date: 2021/12/28 * @Param: [totalCustomer] 指定customers数组的最大空间 * @return: */ public CustomerList(int totalCustomer){ customers = new Customer[totalCustomer]; } /** * @Description: 添加指定的客户到数组中 * @Author: kkx * @Date: 2021/12/28 * @Param: [customer] * @return: boolean 是否添加成功 */ public boolean addCustomer(Customer customer){ //小于最大则可以添加 if (total < customers.length){ customers[total] = customer; total++; return true; } return false; } /** * @Description: 修改指定索引位置上的客户信息 * @Author: kkx * @Date: 2021/12/28 * @Param: [index, cust] * @return: boolean 是否修改成功 */ public boolean replaceCustomer(int index, Customer cust){ if (index < 0 || index >= total){ return false; } customers[index] = cust; return true; } /** * @Description: 删除指定索引位置上的客户信息 * @Author: kkx * @Date: 2022/1/4 * @Param: [index] * @return: boolean 是否删除成功 */ public boolean deleteCustomer(int index){ if (index < 0 || index >= total){ return false; } for (int i = index; i < total - 1; i++) { customers[i] = customers[i + 1]; } //这里先把最后那个指向null，total再-- customers[--total] = null; return true; } /** * @Description: 获取所有客户的客户信息 * @Author: kkx * @Date: 2022/1/4 * @Param: [] * @return: com.atguigu.p2.bean.Customer[] */ public Customer[] getAllCustomers(){ Customer[] custs = new Customer[total]; for (int i = 0; i < total; i++) { custs[i] = customers[i]; } return custs; } /** * @Description: 返回指定索引位置上的Customer * @Author: kkx * @Date: 2022/1/4 * @Param: [index] * @return: 如果找到元素，则返回，如果没有找到，返回null */ public Customer getCustomer(int index){ if (index < 0 || index >= total){ return null; } return customers[index]; } /** * @Description: 获取存储的客户的数量 * @Author: kkx * @Date: 2022/1/4 * @Param: [] * @return: int */ public int getTotal(){ return total; } }Customer类package com.atguigu.p2.bean; /** * @program: project12 * @description: Customer类 * @author: kkx * @create: 2021-12-28 17:08 **/ public class Customer { private String name; // 姓名 private char gender; // 性别 private int age; // 年龄 private String phone; // 电话 private String email; // 邮箱 public Customer() { } public Customer(String name, char gender, int age, String phone, String email) { this.name = name; this.gender = gender; this.age = age; this.phone = phone; this.email = email; } public String getName() { return name; } public void setName(String name) { this.name = name; } public char getGender() { return gender; } public void setGender(char gender) { this.gender = gender; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getPhone() { return phone; } public void setPhone(String phone) { this.phone = phone; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } }CMUtility工具类package com.atguigu.p2.util; /** * @program: project12 * @description: CMUtility工具类 * @author: kkx * @create: 2021-12-28 17:14 **/ import java.util.*; /** CMUtility工具类： 将不同的功能封装为方法，就是可以直接通过调用方法使用它的功能，而无需考虑具体的功能实现细节。 */ public class CMUtility { private static Scanner scanner = new Scanner(System.in); /** 用于界面菜单的选择。该方法读取键盘，如果用户键入’1’-’5’中的任意字符，则方法返回。返回值为用户键入字符。 */ public static char readMenuSelection() { char c; for (; ; ) { String str = readKeyBoard(1, false); c = str.charAt(0); if (c != '1' && c != '2' && c != '3' && c != '4' && c != '5') { System.out.print("选择错误，请重新输入："); } else break; } return c; } /** 从键盘读取一个字符，并将其作为方法的返回值。 */ public static char readChar() { String str = readKeyBoard(1, false); return str.charAt(0); } /** 从键盘读取一个字符，并将其作为方法的返回值。 如果用户不输入字符而直接回车，方法将以defaultValue 作为返回值。 */ public static char readChar(char defaultValue) { String str = readKeyBoard(1, true); return (str.length() == 0) ? defaultValue : str.charAt(0); } /** 从键盘读取一个长度不超过2位的整数，并将其作为方法的返回值。 */ public static int readInt() { int n; for (; ; ) { String str = readKeyBoard(2, false); try { n = Integer.parseInt(str); break; } catch (NumberFormatException e) { System.out.print("数字输入错误，请重新输入："); } } return n; } /** 从键盘读取一个长度不超过2位的整数，并将其作为方法的返回值。 如果用户不输入字符而直接回车，方法将以defaultValue 作为返回值。 */ public static int readInt(int defaultValue) { int n; for (; ; ) { String str = readKeyBoard(2, true); if (str.equals("")) { return defaultValue; } try { n = Integer.parseInt(str); break; } catch (NumberFormatException e) { System.out.print("数字输入错误，请重新输入："); } } return n; } /** 从键盘读取一个长度不超过limit的字符串，并将其作为方法的返回值。 */ public static String readString(int limit) { return readKeyBoard(limit, false); } /** 从键盘读取一个长度不超过limit的字符串，并将其作为方法的返回值。 如果用户不输入字符而直接回车，方法将以defaultValue 作为返回值。 */ public static String readString(int limit, String defaultValue) { String str = readKeyBoard(limit, true); return str.equals("")? defaultValue : str; } /** 用于确认选择的输入。该方法从键盘读取‘Y’或’N’，并将其作为方法的返回值。 */ public static char readConfirmSelection() { char c; for (; ; ) { String str = readKeyBoard(1, false).toUpperCase(); c = str.charAt(0); if (c == 'Y' || c == 'N') { break; } else { System.out.print("选择错误，请重新输入："); } } return c; } private static String readKeyBoard(int limit, boolean blankReturn) { String line = ""; while (scanner.hasNextLine()) { line = scanner.nextLine(); if (line.length() == 0) { if (blankReturn) return line; else continue; } if (line.length() < 1 || line.length() > limit) { System.out.print("输入长度（不大于" + limit + "）错误，请重新输入："); continue; } break; } return line; } }

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学习笔记9 {music id="1381676207" color="#1989fa" /}1. java面向对象学习的三条主线Java类及类的成员：属性、方法、构造器；代码块、内部类面向对象的三大特征：封装性、继承性、多态性、(抽象性)其它关键字：this、super、static、final、abstract、interface、package、import等2. 面向对象和面向过程的区别面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。① 把冰箱门打开 ② 抬起大象，塞进冰箱 ② 把冰箱门关闭面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。人{ 打开(冰箱){ 冰箱.开开(); } 抬起(大象){ 大象.进入(冰箱); } 关闭(冰箱){ 冰箱.闭合(); } } 冰箱{ 开开(){} 闭合(){} } 大象{ 进入(冰箱){ } } 3. 面向对象的两个要素：类：对一类事物的描述，是抽象的、概念上的定义 对象：是实际存在的该类事物的每个个体，因而也称为实例(instance) 面向对象程序设计的重点是类的设计。设计类，就是设计类的成员。4. 类和对象的使用创建类，设计类的成员属性 = 成员变量 = field = 域、字段方法 = 成员方法 = 函数 = method创建类的对象 = 类的实例化 = 实例化类创建类的对象通过“对象.属性”或“对象.方法”调用对象的结构如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。java代码package com.atguigu.java; public class PersonTest { public static void main(String[] args) { //2. 创建Person类的对象 Person p1 = new Person(); //调用对象的结构：属性、方法 //调用属性：“对象.属性” p1.name = "Tom"; p1.isMale = true; System.out.println(p1.name); //调用方法：“对象.方法” p1.eat(); p1.talk("中文"); Person p2 = new Person(); System.out.println(p2.name); //null System.out.println(p2.isMale); //false //将p1变量保存的对象地址值赋给p3,导致p1和p3指向了堆空间中的同一个对象实体。 Person p3 = p1; System.out.println(p3.name); //Tom p3.age = 10; System.out.println(p1.age); //10 } } //1.创建类，设计类的成员 class Person{ String name; int age = 1; boolean isMale; public void eat() { System.out.println("eat"); } public void sleep() { System.out.println("sleep"); } public void talk(String language) { System.out.println("说的是" + language); } }5. 类中属性的使用属性（成员变量） vs 局部变量相同点：定义变量的格式：数据类型 变量名 = 变量值先声明，后使用变量都有其对应的作用域不同点：在类中声明的位置的不同属性：直接定义在类的一对{}内 局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量关于权限修饰符的不同属性：可以在声明属性时，指明其权限，使用权限修饰符。 常用的权限修饰符：private、public、缺省(default)、protected --->封装性。缺省常用。 局部变量：不可以使用权限修饰符。默认初始化值的情况：属性：类的属性，根据其类型，都有默认初始化值。整型（byte、short、int、long）：0浮点型（float、double）：0.0字符型（char）：0 （或'\u0000'）布尔型（boolean）：false引用数据类型（类、数组、接口）：null局部变量：没有默认初始化值。意味着，我们在调用局部变量之前，一定要显式赋值。特别地：形参在调用时，我们赋值即可。在内存中加载的位置：属性：加载到堆空间中 （非static）局部变量：加载到栈空间6. 类中方法的声明和使用1. 方法：描述类应该具有的功能。比如：Math类：sqrt()\random() ... Scanner类：nextXxx() ... Arrays类：sort() \ binarySearch() \ toString() \ equals() \ ... 下面是自己写的类： public void eat(){} public void sleep(int hour){} public String getName(){} public String getNation(String nation){}2. 方法的声明：权限修饰符 返回值类型 方法名(形参列表){ 方法体 }注意：static、final、abstract 来修饰的方法3. Tip关于权限修饰符：默认方法的权限修饰符先都使用public。 Java规定的4种权限修饰符：private、public、缺省、protected返回值类型： 有返回值 vs 没有返回值如果方法有返回值，则必须在方法声明时，指定返回值的类型。并用return关键字来返回指定类型的变量或常量：“return 数据”。 如果方法没有返回值，用void来表示。通常，没有返回值则不需要使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。我们定义方法该不该有返回值？题目要求凭经验方法名：属于标识符，遵循标识符的规则和规范，“见名知意”形参列表： 方法可以声明0个，1个，或多个形参。格式：数据类型1 形参1,数据类型2 形参2,...我们定义方法时，该不该定义形参？题目要求凭经验方法体：方法功能的体现。return关键字的使用：使用范围：使用在方法体中作用：结束方法针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据。注意点：return关键字后面不可以声明执行语句。方法的使用中，可以调用当前类的属性或方法 特殊的：方法A中又调用了方法A:递归方法。 方法中，不可以定义方法。可以直接在同一个包下面定义自己的类，名字尾缀为java，最开始不需要importpackage com.atguigu.exer; public class Person { String name; int age; /** * sex:1 表明是男性 * sex:0 表明是女性 */ int sex; public void study(){ System.out.println("studying"); } public void showAge(){ System.out.println("age:" + age); } public int addAge(int i){ age += i; return age; } }package com.atguigu.exer; /* * 要求： * (1)创建Person类的对象，设置该对象的name、age和sex属性，调用study方法， * 输出字符串“studying”，调用showAge()方法显示age值， * 调用addAge()方法给对象的age属性值增加2岁。 * (2)创建第二个对象，执行上述操作，体会同一个类的不同对象之间的关系。 */ public class PersonTest { public static void main(String[] args) { Person p1 = new Person(); p1.name = "Tom"; p1.age = 18; p1.sex = 1; p1.study(); p1.showAge(); int newAge = p1.addAge(2); System.out.println(p1.name + "的新年龄为：" + newAge); System.out.println(p1.age); //20 Person p2 = new Person(); p2.showAge(); //0 p2.addAge(10); p2.showAge(); //10 } } 4. java代码package com.atguigu.java; public class CustomerTest { public static void main(String[] args) { Customer cust1 = new Customer(); //cust1.eat(); 报错 cust1.sleep(8); } } class Customer{ String name; int age; boolean isMale; private void eat(){ System.out.println("客户吃饭"); } public void sleep(int hour){ System.out.println("休息了" + hour + "个小时"); eat(); } public String getName(){ if (age > 18){ return name; }else { return "Tom"; } } public String getNation(String nation){ String info = "国籍为" + nation; return info; } }package com.atguigu.java; public class UserTest { public static void main(String[] args) { User u1 = new User(); System.out.println(u1.name); System.out.println(u1.age); System.out.println(u1.isMale); u1.talk("汉语"); u1.eat(); } } class User{ //属性（或成员变量） String name; public int age; boolean isMale; public void talk(String language){ //局部变量 System.out.println("我们用" + language); } public void eat(){ String food = "饼"; //局部变量 System.out.println("一个" + food); } }package com.atguigu.exer; public class StudentTest1 { public static void main(String[] args) { Student1[] s1 = new Student1[20]; for (int i = 0; i < s1.length; i++) { s1[i] = new Student1(); s1[i].number = (i + 1); //年级：[1,6] s1[i].state = (int)(Math.random() * (6 - 1 + 1) + 1); //成绩：[0,100] s1[i].score = (int) (Math.random() * (100 - 0 + 1)); } StudentTest1 test = new StudentTest1(); test.print(s1); System.out.println(); test.seacchState(s1, 3); System.out.println(); test.sort(s1); test.print(s1); } /** * 遍历学生数组 * @param s1 */ public void print(Student1[] s1){ for (int i = 0; i < s1.length; i++) { System.out.println(s1[i].info()); } } /** *问题一：打印出指定年级的学生信息。 * @param s1 要查找的数组 * @param state 要查找的年级 */ public void seacchState(Student1[] s1, int state){ for (int i = 0; i < s1.length; i++) { if (s1[i].state == state){ System.out.println(s1[i].info()); } } } /** * 使用冒泡排序按学生成绩排序 * @param s1 */ public void sort(Student1[] s1){ for (int i = 0; i < s1.length - 1; i++) { for (int j = 0; j < s1.length - 1 - i; j++) { if (s1[j].score > s1[j + 1].score){ //注意这里交换的是对象 Student1 temp = s1[j]; s1[j] = s1[j + 1]; s1[j + 1] = temp; } } } } } class Student1{ int number;; //学号 int state; //年级 int score; //成绩 //显示学生信息 public String info(){ return "学号：" + number + ",年级：" + state + ",成绩：" + score; } }