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学习笔记11 {music id="1901756112" color="#1989fa" /}封装性面向对象的特征一：封装与隐藏一.问题的引入：当创建一个类的对象后，我们可以通过"对象.属性"的方式，对对象的属性赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，通常我们需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()）同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private).此时，针对于属性就体现了封装性。二.封装性的体现：我们将类的属性xxx私有化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值拓展：封装性的体现：如上不对外暴露的私有的方法单例模式三.封装性的体现，需要权限修饰符来配合。1.Java规定的4种权限（从小到大排列）：private、缺省、protected 、public2.4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类3.具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类 修饰类的话，只能使用：缺省、public四. 四种访问权限修饰符修饰符类内部同一个包不同包的子类同一个工程privateYes (缺省)YesYes protectedYesYesYes publicYesYesYesYes五.java代码Order类package com.atguigu.java; /** * @program: project11 * @description: Order类 * @author: kkx * @create: 2021-12-18 23:49 **/ public class Order { private int orderPrivate; int orderDefault; public int orderPublic; private void methodPrivate(){ System.out.println("methodPrivate"); } void methodDefault(){ System.out.println("methodDefault"); } public void methodPublic(){ System.out.println("methodPublic"); } }同一个包下面调用类package com.atguigu.java; /** * @program: project11 * @description: Oeder类测试 * @author: kkx * @create: 2021-12-18 23:52 **/ public class OrderTest { public static void main(String[] args) { Order order = new Order(); order.orderDefault = 1; order.orderPublic = 2; // a.legs = 4;//The field Animal.legs is not visible order.methodDefault(); order.methodPublic(); } }不同包下面调用类package com.atguigu.java1; import com.atguigu.java.Order; /** * @program: project11 * @description: Oeder类测试 * @author: kkx * @create: 2021-12-19 00:13 **/ public class OrderTest { public static void main(String[] args) { Order order = new Order(); //出了Order类所属的包之后，私有的结构、缺省声明的结构就不可以调用了 //order.orderDefault = 1; order.orderPublic = 2; //order.methodDefault(); order.methodPublic(); } }六.封装性总结：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。类的结构之三：构造器（或构造方法、constructor）的使用construct：建设、建造。 construction:CCB constructor:建设者一、构造器的作用：创建对象初始化对象的信息二.Tip：如果定义构造器的话，则系统默认提供一个空参的构造器。定义构造器的格式：权限修饰符 类名(形参列表){}。一个类中定义的多个构造器，彼此可以构成重载。一旦我们定义了类的构造器之后，系统就不再提供默认的空参构造器。一个类中，至少会有一个构造器。三.java代码Person类package com.atguigu.exer; /** * @program: project11 * @description: Person类 * @author: kkx * @create: 2021-12-19 00:24 **/ public class Person { private int age; private String name; public Person(){ age = 18; } public Person(String n, int a){ name = n; age = a; } public void setAge(int a){ if (a < 0 || a > 130){ throw new RuntimeException("传入的数据非法！"); //报红 //也可以先sout然后return } age = a; } public int getAge() { return age; } public void setName(String n){ name = n; } public String getName() { return name; } }Person类测试package com.atguigu.exer; /** * @program: project11 * @description: Person类的使用，类权限课后题 * @author: kkx * @create: 2021-12-19 00:25 **/ public class PersonTest { public static void main(String[] args) { Person p1 = new Person(); p1.setAge(12); System.out.println(p1.getName() + "\t" + p1.getAge()); Person p2 = new Person("Tom", 21); System.out.println(p2.getName() + "\t" + p2.getAge()); } }属性赋值的先后顺序默认初始化显式初始化构造器中初始化通过"对象.方法" 或 "对象.属性"的方式，赋值以上操作的先后顺序：① - ② - ③ - ④java代码package com.atguigu.java1; /** * @program: project11 * @description: 属性赋值的先后顺序 * @author: kkx * @create: 2021-12-19 11:33 **/ public class UserTest { public static void main(String[] args) { User u1 = new User(); System.out.println(u1.age); User u2 = new User(2); u2.setAge(3); System.out.println(u2.age); } } class User{ String name; int age = 1; public User(){ } public User(int a){ age = a; } public void setAge(int a){ age = a; } }javaBeanpackage com.atguigu.java1; /** * @program: project11 * @description: JavaBean * @author: kkx * @create: 2021-12-19 11:45 **/ public class Customer { public int id; private String name; public Customer(){ } public void setId(int i){ id = i; } public int getId() { return id; } public void setName(String n){ name = n; } public String getName() { return name; } }this关键字的使用this可以用来修饰、调用：属性、方法、构造器this修饰属性和方法:this为：当前对象 或 当前正在创建的对象在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。 但是，通常情况下，我们都选择省略"this."。特殊情况下，如果方法的形参和类的属性同名时， 我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。在类的构造器同理this调用构造器我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器构造器中不能通过"this(形参列表)"方式调用自己如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)"规定："this(形参列表)"必须声明在当前构造器的首行构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器java代码package com.atguigu.java2; /** * @program: project11 * @description: this关键字 * @author: kkx * @create: 2021-12-19 12:00 **/ public class PersonTest { public static void main(String[] args) { Person p1 = new Person(); p1.setAge(1); System.out.println(p1.getAge()); Person p2 = new Person("Tom", 20); System.out.println(p2.getAge()); } } class Person{ private String name; private int age; public Person(){ System.out.println("Person初始化时，需要考虑如下的1,2,3,4"); } public Person(String name) { this(); //Person初始化时，需要考虑如下的1,2,3,4 this.name = name; } public Person(String name, int age) { this(name); //这个必须放首行，每个构造器里面只能放一个this（） this.age = age; } public void setName(String name) { this.name = name; } public String getName() { return name; } public void setAge(int age) { this.age = age; } public int getAge() { return age; } public void eat(){ System.out.println("eating"); study(); } public void study(){ System.out.println("studying"); } }boy,gril 测试package com.atguigu.exer2; /** * @program: project11 * @description: Boy类 * @author: kkx * @create: 2021-12-19 12:55 **/ public class Boy { private String name; private int age; public Boy() { } public Boy(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public void marry(Girl girl){ System.out.println("我要" + girl.getName()); } public void shout(){ if (this.age >= 22){ System.out.println("yes!"); }else { System.out.println("no~"); } } }package com.atguigu.exer2; /** * @program: project11 * @description: Girl类 * @author: kkx * @create: 2021-12-19 12:55 **/ public class Girl { private String name; private int age; public Girl(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public void marry(Boy boy){ System.out.println("我要" + boy.getName()); boy.marry(this); } /** * @Description: 比较两个对象的大小 * @Author: kkx * @Date: 2021/12/19 * @Param: [girl] * @return: 正数：当前对象大； 负数：当前对象小 ； 0：当前对象与形参对象相等 */ public int compare(Girl girl){ if(this.age > girl.age){ return 1; }else if (this.age < girl.age){ return -1; }else { return 0; } } }package com.atguigu.exer2; /** * @program: project11 * @description: Boy，Girl类测试 * @author: kkx * @create: 2021-12-19 12:55 **/ public class BoyGirlTest { public static void main(String[] args) { Boy boy = new Boy("阿强", 21); boy.shout(); Girl girl = new Girl("阿珍", 18); girl.marry(boy); Girl girl1 = new Girl("2233", 11); int compare = girl.compare(girl1); if (compare > 0){ System.out.println(girl.getName() + "大"); }else if (compare < 0){ System.out.println(girl1.getName() + "大"); }else { System.out.println("一样大"); } } }Account测试package com.atguigu.exer3; /** * @program: project11 * @description: Account类 * @author: kkx * @create: 2021-12-19 13:22 **/ public class Account { private int id;//账号 private double balance;//余额 private double annualInterestRate;//年利率 public Account(int id, double balance, double annualInterestRate) { this.id = id; this.balance = balance; this.annualInterestRate = annualInterestRate; } public int getId() { return id; } public void setId(int id) { this.id = id; } public double getBalance() { return balance; } public void setBalance(double balance) { this.balance = balance; } public double getAnnualInterestRate() { return annualInterestRate; } public void setAnnualInterestRate(double annualInterestRate) { this.annualInterestRate = annualInterestRate; } public void withdraw (double amount){//取钱 if (balance < amount){ System.out.println("余额不足，取款失败"); return; } balance -= amount; System.out.println("成功取出：" + amount); } public void deposit (double amount){//存钱 if (amount > 0){ balance += amount; System.out.println("成功存入：" + amount); } } }package com.atguigu.exer3; /** * @program: project11 * @description: Customer类 * @author: kkx * @create: 2021-12-19 13:28 **/ public class Customer { private String firstName; private String lastName; private Account account; public Customer(String f, String l) { this.firstName = f; this.lastName = l; } public void setAccount(Account account) { this.account = account; } public String getFirstName() { return firstName; } public String getLastName() { return lastName; } public Account getAccount() { return account; } }package com.atguigu.exer3; /** * @program: project11 * @description: Customer, Account测试 * @author: kkx * @create: 2021-12-19 13:32 **/ public class CustomerTest { public static void main(String[] args) { Customer cust = new Customer("Jane", "Smith"); Account acct =new Account(1000, 2000, 0.0123); cust.setAccount(acct); cust.getAccount().deposit(100); cust.getAccount().withdraw(960); cust.getAccount().withdraw(2000); System.out.println("Customer[" + cust.getLastName() + "," + cust.getLastName() + "]" + "\n" + "id:" + cust.getAccount().getId() + "\n" + "annualInterestRate:" + cust.getAccount().getAnnualInterestRate()*100 + "%" + "\n" + "balance:" +cust.getAccount().getBalance()); } }Bank测试package com.atguigu.exer4; /** * @program: project11 * @description: Account类 * @author: kkx * @create: 2021-12-19 13:43 **/ public class Account { private double balance; public Account(double init_balance) { this.balance = init_balance; } public double getBalance() { return balance; } //存钱操作 public void deposit(double amt){ if(amt > 0){ balance += amt; System.out.println("存钱成功"); } } //取钱操作 public void withdraw(double amt){ if(balance >= amt){ balance -= amt; System.out.println("取钱成功"); }else{ System.out.println("余额不足"); } } }package com.atguigu.exer4; /** * @program: project11 * @description: Bank类 * @author: kkx * @create: 2021-12-19 13:43 **/ public class Bank { private Customer[] customers;// 存放多个客户的数组 private int numberOfCustomers;// 记录客户的个数 public Bank(){ //这里要造数组，否则会空指针 customers = new Customer[10]; } public void addCustomer(String f, String l){ Customer cust = new Customer(f, l); customers[numberOfCustomers] = cust; numberOfCustomers++; //customers[numberOfCustomers++] = cust; } public int getNumberOfCustomers() { return numberOfCustomers; } public Customer getCustomer(int index){ if (index >= 0&& index < numberOfCustomers){ return customers[index]; } return null; } }package com.atguigu.exer4; /** * @program: project11 * @description: Customer类 * @author: kkx * @create: 2021-12-19 13:44 **/ public class Customer { private String firstName; private String lastName; private Account account; public Customer(String f, String l) { this.firstName = f; this.lastName = l; } public Account getAccount() { return account; } public void setAccount(Account account) { this.account = account; } public String getFirstName() { return firstName; } public String getLastName() { return lastName; } }package com.atguigu.exer4; /** * @program: project11 * @description: Bank方测试 * @author: kkx * @create: 2021-12-19 13:46 **/ public class BankTest { public static void main(String[] args) { Bank bank = new Bank(); bank.addCustomer("Jane", "Smith"); bank.getCustomer(0).setAccount(new Account(2000)); bank.getCustomer(0).getAccount().withdraw(500); double balance = bank.getCustomer(0).getAccount().getBalance(); System.out.println("客户：" + bank.getCustomer(0).getFirstName() + "的账户余额为：" + balance); System.out.println(); bank.addCustomer("万里", "杨"); System.out.println("银行客户的个数为：" + bank.getNumberOfCustomers()); } }Package的使用为了更好的实现项目中类的管理，提供包的概念使用package声明类或接口所属的包，声明在源文件的首行包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”每"."一次，就代表一层文件目录。JDK中主要的包介绍java.lang----包含一些Java语言的核心类，如String、Math、Integer、 System和Thread，提供常用功能java.net----包含执行与网络相关的操作的类和接口。java.io ----包含能提供多种输入/输出功能的类。java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。java.text----包含了一些java格式化相关的类java.sql----包含了java进行JDBC数据库编程的相关类/接口java.awt----包含了构成抽象窗口工具集（abstract window toolkits）的多个类， 这些类被用来构建和管理应用程序的图形用户界面(GUI)。Import的使用在源文件中显式的使用import结构导入指定包下的类、接口声明在包的声明和类的声明之间如果需要导入多个结构，则并列写出即可可以使用"xxx.*"的方式，表示可以导入xxx包下的所有结构在java.lang下的话（java.lang.System 常用），则可以省略import结构如果使用的类或接口是本包下定义的，则可以省略import结构如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。使用"xxx.*"方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入import static:导入指定类或接口中的静态结构:属性或方法。package com.atguigu.java2; import com.atguigu.exer4.Account; import com.atguigu.exer4.Bank; import com.atguigu.java2.java3.Dog; import java.util.*; //import 类、接口 import static java.lang.System.*; //import static 结构（属性或方法） import static java.lang.Math.*; /** * @program: project11 * @description: PackageImport测试 * @author: kkx * @create: 2021-12-20 14:59 **/ public class PackageImportTest { public static void main(String[] args) { Bank bank = new Bank(); Arrays.toString(new int[]{1, 2, 3}); HashMap map = new HashMap(); Scanner scanner = null; Account acct = new Account(1000); //全类名的方式显示 com.atguigu.exer3.Account acct1 = new com.atguigu.exer3.Account(1000,2000,0.0123); Date date = new Date(); java.sql.Date date1 = new java.sql.Date(123465l); Dog dog = new Dog(); //import static:导入指定类或接口中的静态结构:属性或方法 out.println("hello"); long num = round(81); } }

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; } }

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()); } }