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学习笔记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; } }

java学习笔记8 {music id="1406599484" color="#1989fa" autoplay="autoplay"/}数组常见算法1. 数组元素的赋值(杨辉三角，回文数等)杨辉三角package com.atguigu.exer; /* 使用二维数组打印一个 10 行杨辉三角。 【提示】 1. 第一行有 1 个元素, 第 n 行有 n 个元素 2. 每一行的第一个元素和最后一个元素都是 1 3. 从第三行开始, 对于非第一个元素和最后一个元素的元素。即： yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j]; */ public class YangHuiTest { public static void main(String[] args) { //1.声明并初始化二维数组 int[][] yangHui = new int[10][]; //2.给数组的元素赋值 for (int i = 0; i < yangHui.length; i++) { yangHui[i] = new int[i + 1]; //2.1 给首末元素赋值 yangHui[i][0] = yangHui[i][i] = 1; //2.2 给每行的非首末元素赋值 for (int j = 1; j < yangHui[i].length - 1; j++) { yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j]; } //3.遍历二维数组 for (int j = 0; j < yangHui[i].length; j++) { System.out.print(yangHui[i][j] + "\t"); } System.out.println(); } } }2. 求数值型数组中元素的最大值、最小值、平均数、总和等package com.atguigu.java; public class ArrayTest1 { public static void main(String[] args) { int [] arr = new int[10]; for (int i = 0; i < arr.length; i++) { arr[i] = (int) (Math.random() * (99 -10 + 1) + 10); } //遍历 for(int i = 0;i < arr.length;i++){ System.out.print(arr[i] + "\t"); } System.out.println(); //求数组元素的最大值 int maxValue = arr[0]; for (int i = 1; i < arr.length; i++) { if (maxValue < arr[i]){ maxValue = arr[i]; } } System.out.println("最大值为：" + maxValue); //求数组元素的最小值 int minValue = arr[0]; for (int i = 1; i < arr.length; i++) { if (minValue > arr[i]){ minValue = arr[i]; } } System.out.println("最小值为：" + minValue); //求数组元素的总和 int sum = 0; for (int i = 0; i < arr.length; i++) { sum += arr[i]; } System.out.println("总和为：" + sum); //求数组元素的平均数 int avgValue = sum / arr.length; System.out.println("平均数为：" + avgValue); } }3. 数组的复制、反转、查找(线性查找、二分法查找)package com.atguigu.java; public class ArrayTest2 { public static void main(String[] args) { String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"}; //数组的复制 String[] arr1 = new String[arr.length]; for (int i = 0; i < arr1.length; i++) { arr1[i] = arr[i]; } //数组的反转 for (int i = 0; i < arr.length / 2; i++) { String temp = arr[i]; arr[i] = arr[arr.length - i - 1]; arr[arr.length - i - 1] = temp; } for (int i = 0, j = arr.length - 1; i < j; i++, j--) { String temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } //遍历 for(int i = 0;i < arr.length;i++){ System.out.print(arr[i] + "\t"); } System.out.println(); //查找 //线性查找 String dest = "BB"; dest = "CC"; boolean isFlag = true; for (int i = 0; i < arr.length; i++) { if (dest.equals(arr[i])){ System.out.println("位置为：" + i); isFlag = false; break; } } if (isFlag){ System.out.println("没找到"); } //二分法查找，效率高 //前提：所要查找的数组必须有序。 int [] arr2 =new int[]{-98,-34,2,34,54,66,79,105,210,333}; int dest1 = -34; dest1 = 35; int head_index = 0; //初始的首索引 int end_index = arr2.length - 1; //初始的末索引 boolean isFlag1 = true; while (head_index <= end_index){ int middle_index = (head_index + end_index) / 2; if (dest1 == arr2[middle_index]){ System.out.println("位置为：" + middle_index); isFlag = false; break; }else if(arr2[middle_index] > dest1){ end_index = middle_index- 1 ; }else { head_index = middle_index + 1; } } if (isFlag){ System.out.println("没找到"); } } }4. 排序算法1. 衡量排序算法的优劣：时间复杂度：分析关键字的比较次数和记录的移动次数空间复杂度：分析排序算法中需要多少辅助内存稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种排序算法是稳定的。2. 排序算法分类：内部排序和外部排序。内部排序：整个排序过程不需要借助于外部存储器（如磁盘等），所有排序操作都在内存中完成。外部排序：参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助于外部存储器（如磁盘）。外部排序最常见的是多路归并排序。可以认为外部排序是由多次内部排序组成。3. 十大内部排序算法选择排序直接选择排序堆排序交换排序冒泡排序快速排序插入排序直接插入排序折半插入排序Shell排序归并排序桶式排序基数排序4. 算法的5大特征输入（Input）：有0个或多个输入数据，这些输入必须有清楚的描述和定义输出（Output）：至少有1个或多个输出结果，不可以没有输出结果有穷性（有限性，Finiteness）：算法在有限的步骤之后会自动结束而不会无限循环，并且每一个步骤可以在可接受的时间内完成确定性（明确性，Definiteness）：算法中的每一步都有确定的含义，不会出现二义性可行性（有效性，Effectiveness）：算法的每一步都是清楚且可行的，能让用户用纸笔计算而求出答案5. java代码// 冒泡排序 package com.atguigu.java; public class BubbleSortTest { public static void main(String[] args) { int [] arr = new int[] {43,32,76,-98,0,64,33,-21,32,99}; 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; } } } for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + "\t"); } } }// 快速排序 package com.atguigu.java; public class QuickSort { private static void swap(int[] data, int i, int j) { int temp = data[i]; data[i] = data[j]; data[j] = temp; } private static void subSort(int[] data, int start, int end) { if (start < end) { int base = data[start]; int low = start; int high = end + 1; while (true) { while (low < end && data[++low] - base <= 0) ; while (high > start && data[--high] - base >= 0) ; if (low < high) { swap(data, low, high); } else { break; } } swap(data, start, high); subSort(data, start, high - 1);//递归调用 subSort(data, high + 1, end); } } public static void quickSort(int[] data){ subSort(data,0,data.length-1); } public static void main(String[] args) { int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 }; System.out.println("排序之前：\n" + java.util.Arrays.toString(data)); quickSort(data); System.out.println("排序之后：\n" + java.util.Arrays.toString(data)); } }5. Arrays工具类的使用常用的类作用boolean equals(int[] a,int[] b)判断两个数组是否相等。String toString(int[] a)输出数组信息。void fill(int[] a,int val)将指定值填充到数组之中。void sort(int[] a)对数组进行排序。int binarySearch(int[] a,int key)对排序后的数组进行二分法检索指定的值。java代码package com.atguigu.java; import java.util.Arrays; public class ArraysTest { public static void main(String[] args) { //1.boolean equals(int[] a,int[] b) int [] arr1 = new int[]{1,2,3,4}; int [] arr2 = new int[]{1,3,2,4}; boolean isEquals = Arrays.equals(arr1, arr2); System.out.println(isEquals); //false //2.String toString System.out.println(Arrays.toString(arr1)); //[1, 2, 3, 4] //3.void fill(int[] a,int val) Arrays.fill(arr1, 10); System.out.println(Arrays.toString(arr1)); //[10, 10, 10, 10] //4.void sort(int[] a) Arrays.sort(arr2); System.out.println(Arrays.toString(arr2)); //[1, 2, 3, 4] ////5.int binarySearch(int[] a,int key) 要有序 int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333}; int index = Arrays.binarySearch(arr3, 210); if (index >= 10){ System.out.println(index); }else { System.out.println("没找到"); } } }6. 数组使用中的常见异常数组角标越界的异常：ArrayIndexOutOfBoundsExcetion空指针异常：NullPointerExceptionjava代码package com.atguigu.java; public class ArrayExceptionTest { public static void main(String[] args) { //1. 数组角标越界的异常：ArrayIndexOutOfBoundsExcetion int[] arr = new int[]{1,2,3,4,5}; //System.out.println(arr[5]); //System.out.println(arr[-2]); //2.2. 空指针异常：NullPointerException //情况一 int[] arr1 = new int[]{1, 2, 3}; arr1 = null; //System.out.println(arr1[0]); //情况二 int[][] arr2 = new int[4][]; //System.out.println(arr2[0][0]); 要初始化 //情况三： String[] arr3 = new String[]{"AA", "BB", "CC"}; //arr3[0] = null; System.out.println(arr3[0].toString()); } }

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]); //报错，空指针 } }