52班JAVA入门基础课堂代码
Demo01_数组的概念和定义格式
package day01; public class Demo01_数组的概念和定义格式 { public static void main(String[] args) { // int age = 19; // 容器 大小 ，同类型的元素，长度 ----元素的个数 // // 数组 ---容器的一种，长度固定，元素的数据类型一致。 // // 元素的类型 [] 数组名字 = new 元素的类型[长度]; int [] arrayAge = new int[50]; // 长度为5的存储姓名的一维数组。 String [] arr = new String[5]; // 数组名[编号] int age0 = arrayAge[0]; System.out.println(age0); arrayAge[0] = 19; System.out.println(arrayAge[0]); // 数组名--- 元素 ---- 编号（索引，下标，角标）----长度（大小） 数组 array 元素 element 索引 index 长度 length 大小 size } }
Demo02_数组的遍历迭代
package day01; public class Demo02_数组的遍历迭代 { public static void main(String[] args) { // 遍历 迭代 ---依次取出容器中的元素，称为遍历或者叫迭代。 // 长度为5的存储姓名的一维数组。 String [] arr = new String[5]; arr[0] = "张三"; arr[1] = "李四"; arr[2] = "王五"; arr[3] = "赵六"; arr[4] = "田七";// 最后一个元素的索引是长度减一；length-1 // System.out.println(arr[0]); // System.out.println(arr[1]); // System.out.println(arr[2]); // System.out.println(arr[3]); // System.out.println(arr[4]); for(int i = 0; i < 5; i++) { System.out.println(arr[i]);// 通过循环的方式，通过索引获取元素。数组名[索引] } } }
Demo03_数组索引越界异常
package day01; public class Demo03_数组索引越界异常 { public static void main(String[] args) { // 数组索引越界异常 // 元素类型 [] 数组名 = {元素1,元素2,元素3..}; String [] arr = {"张三","李四","王五","赵六","田七"}; // 获取数组的长度 // 数组名.length; System.out.println(arr.length); // 数组索引的范围 ---- 0 arr.length -1 否则 数组索引越界异常 for(int i =0;i <= arr.length; i++) { System.out.println(arr[i]); } java.lang.ArrayIndexOutOfBoundsException } }
Demo04_数组的空指针异常
package day01; public class Demo04_数组的空指针异常 { public static void main(String[] args) { // 引用数据类型。可以赋值为 null; String [] arr = null; // 数组也是引用数据类型 System.out.println(arr[0]);// 用arr---Null pointer // System.out.println(arr.length); // java.lang.NullPointerException // 默认，自动，已经有的。 } }
Demo05_数组获取最大值元素
package day01; public class Demo05_数组获取最大值元素 { public static void main(String[] args) { int[] arr = { 5, 15, 2000, 200, 100, 4000 }; // 定义变量，保存数组 0 索引上的元素 // 遍历数组，获取出数组中的每个元素 // 将遍历到的元素和保存数组 0 索引上值的变量进行比较 // 如果数组元素的值大于了变量的值，变量记录住新的值 // 数组循环遍历结束，变量保存的就是数组中的最大值 int max = arr[0]; for(int i = 1;i<arr.length;i++) { if(arr[i] > max) { max = arr[i]; } } System.out.println("数组元素最大值： "+max); } }
Demo06_数组的反转
package day01; public class Demo06_数组的反转 { public static void main(String[] args) { // 1，2，3，4，5 ---- 5，4，3，2，1 int [] arr = {1,2,3,4,5,6,7,8,9}; // for(int i = 0;i<arr.length/2;i++) { // int temp = arr[i]; // arr[i] =arr[arr.length-1-i]; // arr[arr.length-1-i] =temp; // } for(int min = 0,max = arr.length-1; min < max; min++,max--) { int temp = arr[min]; arr[min] = arr[max]; arr[max] = temp; } System.out.println(min); // min cannot be resolved to a variable for (int i = 0; i < arr.length; i++) { System.out.print(arr[i]+", "); } } }
Demo07_方法的定义和调用
package day01; public class Demo07_方法的定义和调用 { public static void main(String[] args) { int [] arr = {22,33,44,22,3,4,5}; // 带返回值方法的调用。 // 1 赋值调用 int max = getMax(arr); System.out.println(max); int [] arr2 = {4,5,6,7,8,9,0}; int max2 = getMax(arr2); System.out.println(max2); // 直接使用---带返回值方法的结果 System.out.println(getMax(arr2)); // 输出语句---也是在调用方法---println(); System.out.println( 999 );//形参 还是 实参 } //This method must return a result of type int public static int getMax(int [] arr) { int max = arr[0]; for(int i =1;i<arr.length;i++) { if(arr[i] > max) { max = arr[i]; } } return max; } // 方法是平级关系，不能嵌套定义。可以在一个方法中调用其他方法。但是不能嵌套定义。 // 999 int // 方法的概念：完成特定功能的代码块 /* * 修饰符 返回值类型 方法名(参数列表){ * 方法体 * return 结果;--- 里面的东西表示可以写可以不写， * } */ // 修饰符 public static --- 公开，可以再main中调用。 // 方法名 --- 标识符，变量名，类名，数组名，---区分不同的方法的。 // 方法体，--- 完成特定功能的指令的集合。 // 返回值类型----- 做完某些操作之后的结果的类型。---数据--数据类型 --例如，两个整数的和。--- int String boolean // 参数列表 ---- 原材料，方法体里面可以使用。 // return 关键字--- 返回的意思，把想返回的结果放到return后面。 // 别的地方调用这个方法的之后，就可以得到return后面的结果。---这个结果称为返回值。 // 如果没有返回值的话，返回值类型就用 void 关键字表示。空的，无返回值的。 }
Demo08_方法的练习题
package day01; public class Demo08_方法的练习题 { public static void main(String[] args) { // int sum = getTwoIntSum(7,7); // // if(sum > 10) { // 。。。。 // } // System.out.println(sum); // 不带返回值方法的调用。直接调用。 printInfo("张三", 19); // 错误写法，不能把无返回值的方法调用结果赋值。int result = printInfo("张三", 19);//Type mismatch: cannot convert from void to int close();// 没有参数，也没有返回值的方法调用--- 直接调用。 // 后面调用方法的时候，调用方法。但是方法定义在别的文件中。可能需要用引用（对象）去调用---例如。fs.close(); } // 求两个整数的和的方法。----- 返回值类型，参数。 public static int getTwoIntSum(int a ,int b){ return a + b; } // 输出学生个人信息的模板。 // 返回值类型；和参数。void ---- String name,int age public static void printInfo(String name,int age) { System.out.println("姓名："+name); System.out.println("年龄："+age); } public static void close() { System.out.println("关闭冰箱门"); } // 判断两个整数是否相等。---修饰符public static---方法名 isEquals --- // 返回值类型 boolean ---- 参数列表 int num1 ,int num2 public static boolean isEquals(int num1,int num2) { // if(num1 == num2) { // return true; // }else { // return false; // } // 初学者，没有好坏对错之分。---只有动手动脑操作思考问题就行，---慢慢提高能力。 return num1 == num2; } }
Demo09_面向对象基础概念
package day01; public class Demo09_面向对象基础概念 { public static void main(String[] args) { // 数据类型 ---- int // // int 整数 --- 类型 --- 范围 // // 999 ---- 具体的数据---实实在在的数据 // 888 // 777 // 666 // 555 // 一个类型，---可以有多个具体的数据。 // int [] arr ; // // {1,2,3,4} // {4,5,6,7} // {7,8,9,2} // String 字符串 // // "张三" // "你好" // "helloworld" // "heiheihei" 类类型的 --- 具体数据--有时候也称为 实例--或者叫对象--- 实体。 // "你好"---这就是字符串对象，实例， String str = "你好"; String str2; 形参 --- 实参 对象能当形参吗？ } }
Demo10_类和对象的概念
package day01; public class Demo10_类和对象的概念 { public static void main(String[] args) { 对象--- 是具体的，实例，实实在在的客体； 类 --- 宽泛的，大概的范围，抽象的。不太具体，大致的。模板。 } }
Demo11_类的定义
// 类 ---- 自定义类型的数据。 // class 类名{ // 成员变量--- 属性值。日历 --学生---卡车 --- 员工--- // 成员方法---功能 // } package day01; public class Student{// 要求，需求，看着写。类型的事物。 // 成员变量 String name; int age; //成员方法。 public void study() { System.out.println("好好学习，天天向上"); } public void sleep() { System.out.println("好好休息，早睡早起。"); } }
Demo12_对象的使用
package day01; /** * *创建对象。int a = 99; 类名 对象名 = new 类名(); 类名 对象名 = new 类名(); 每new 一次就会创建一个新的对象。 * */ public class Demo12_对象的使用 { public static void main(String[] args) { Student stu1 = new Student(); Student stu2 = new Student(); stu1.study(); stu1.sleep(); stu2.study(); System.out.println(stu1.name); System.out.println(stu1.age); stu1.name = "张三"; stu1.age = 19; System.out.println(stu1.name); System.out.println(stu1.age); // 对象之间是独立的个体。 System.out.println(stu2.name); System.out.println(stu2.age); // System.out.println(stu1); // System.out.println(stu2); // 每个对象，都具有该类型的相关属性和功能。 } }
Demo13_封装的步骤
package day01; public class Person { // 1 使用private 关键字 修饰成员变量。 private int age ;// 私有之后，别处不可直接访问，但是本类中可以直接用。 public void eat() { System.out.println("person类的eat()方法"); } // 2 对需要访问的数据，提供 公开的访问方式，----通过公开的方法，让别处访问。 // 赋值 public void setAge(int a){ if(a < 0) { System.out.println("年龄不能小于零，默认赋值为 18"); age = 18; return ; } age = a; } // 得到值 public int getAge(){ return age; } } ====================== package day01; public class Demo13_封装的步骤 { public static void main(String[] args) { // 以Person类为例 Person person = new Person(); // person.age = 19;// 访问person类的数据。// 赋值 // System.out.println(person.age);// 得到，使用。 // 封装的步骤 //1 使用private 关键字 修饰成员变量。---The field Person.age is not visible // 2 对需要访问的数据，提供 公开的访问方式，----通过公开的方法，让别处访问。 person.setAge(-22); int age = person.getAge(); System.out.println(age); } }
Demo14_this关键字
package day01; public class Demo14_this关键字 { /* * this关键字，表示当前对象的引用。谁调用当前方法，this关键字就代表谁。 * */ public static void main(String[] args) { Person per1 = new Person(); Person per2 = new Person(); System.out.println(per1); per1.setAge(19); } } ========================= package day01; public class Person { // 1 使用private 关键字 修饰成员变量。 private int age ;// 私有之后，别处不可直接访问，但是本类中可以直接用。 public void eat() { System.out.println("person类的eat()方法"); } // 2 对需要访问的数据，提供 公开的访问方式，----通过公开的方法，让别处访问。 // 赋值 public void setAge(int age){// 就近 System.out.println(this); this.age = age;// } // 得到值 public int getAge(){ return age; } }
Demo15_封装的练习题
public class Phone { private String brand; private int price; private String color; public String getBrand() { return brand; } public void setBrand(String brand) { this.brand = brand; } public int getPrice() { return price; } public void setPrice(int price) { this.price = price; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } } =================== package day01; public class Demo15_封装的练习题 { public static void main(String[] args) { // 创建手机对象 Phone phone = new Phone(); phone.setBrand("诺基亚"); phone.setPrice(1999); phone.setColor("黑色"); System.out.println("品牌："+phone.getBrand()); System.out.println("价格："+phone.getPrice()); System.out.println("颜色："+phone.getColor()); } }
Demo16_show方法_完成属性值的拼接
package day01; public class Demo16_show方法_完成属性值的拼接 { /* * 在Phone类中添加show方法。 * 在Demo15_封装练习题--文件中，完成对show方法的调用演示 */ } =================== package day01; public class Phone { private String brand; private int price; private String color; public String getBrand() { return brand; } public void setBrand(String brand) { this.brand = brand; } public int getPrice() { return price; } public void setPrice(int price) { this.price = price; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } // show方法，---拼接属性用的。--- 把属性值拼接成字符串返回。 public String show() { return "品牌："+brand +"价格："+ this.price +"颜色"+this.getColor(); // 上面的写法---本类属性值可以直接用；也可以用this关键字点出来。也可以调用封装好的getXxx方法 } } ================== package day01; public class Demo15_封装的练习题 { public static void main(String[] args) { // 创建手机对象 Phone phone = new Phone(); phone.setBrand("诺基亚"); phone.setPrice(1999); phone.setColor("黑色"); System.out.println("品牌："+phone.getBrand()); System.out.println("价格："+phone.getPrice()); System.out.println("颜色："+phone.getColor()); // 把上面的输出语句---替换成调用show方法。 String result = phone.show(); System.out.println(result); } }
Demo17_构造方法_对属性进行赋值操作
package day01; public class Demo17_构造方法_对属性进行赋值操作 { /* * 构造方法的语法格式 * * 修饰符 类名(参数列表){ * 方法体； * } * * ---作用 对属性进行赋值操作 ----- 初始化对象用的。 * new的时候调用构造方法。 * 没有写构造方法，系统会默认有个无参构造。 * 如果给了带参构造方法，系统就不再默认给无参构造。---所以也手动给出无参构造。 * */ public static void main(String[] args) { System.out.println(true); // 创建手机对象 Phone phone = new Phone(); // phone.setBrand("诺基亚"); // phone.setPrice(1999); // phone.setColor("黑色"); // 这里只是引入构造方法的讲解用的。phone.setFields("诺基亚",1999,"黑色"); System.out.println(phone.show()); Phone phone2 = new Phone("苹果手机",5999,"白色"); System.out.println(phone2.show()); } } ===================== package day01; public class Phone { private String brand; private int price; private String color; public Phone() { } // 同一个类中出现了一样的方法名，但是参数不同，这样的情况，称为方法的重载---Overload public Phone(String brand, int price, String color) { this.brand = brand; this.price = price; this.color = color; } // 这里只是引入构造方法的讲解用的。以后不用了。 public void setFields(String brand, int price, String color) { this.brand = brand; this.price = price; this.color = color; } public String getBrand() { return brand; } public void setBrand(String brand) { this.brand = brand; } public int getPrice() { return price; } public void setPrice(int price) { this.price = price; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } // show方法，---拼接属性用的。--- 把属性值拼接成字符串返回。 public String show() { return "品牌："+brand +"价格："+ this.price +"颜色"+this.getColor(); // 上面的写法---本类属性值可以直接用；也可以用this关键字点出来。也可以调用封装好的getXxx方法 } }
Demo18_构造函数作业
package day02; public class Demo18_构造函数作业 { public static void main(String[] args) { // 类 --- 猴子类 Monkey 类 // 属性 名称 name 特征 feature // 无参有参构造。 // 创建两个对象。 } } ==================== package day02; public class Monkey { // 类 --- 猴子类 Monkey 类 // 属性 名称 name 特征 feature // 无参有参构造。 private String name; private String feature; public Monkey() { } public Monkey(String name, String feature) { this.name = name; this.feature = feature; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getFeature() { return feature; } public void setFeature(String feature) { this.feature = feature; } public String show() { return "名称："+name +"\n特征："+feature; } } ======================= package day02; public class MonkeyTest { public static void main(String[] args) { // 创建两个对象。 System.out.println("通过无参构造创建猴子对象"); Monkey monkey1 = new Monkey(); monkey1.setName("长尾猴"); monkey1.setFeature("尾巴长"); System.out.println(monkey1.show()); System.out.println("==========================="); System.out.println("通过有参构造创建猴子对象"); Monkey monkey2 = new Monkey("白头叶猴","头上有白毛，喜欢吃树叶"); System.out.println(monkey2.show()); } }
Demo19_封装练习题_用户信息校验
package day02; public class User { // 定义属性，用户名，密码 private String username; private int password; public User() { } public User(String username, int password) { this.username = username; this.password = password; } public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public int getPassword() { return password; } public void setPassword(int password) { this.password = password; } public String show() { return "用户名:"+this.username +"密码："+this.password; } } =================== package day02; public class UserManager { // 用于用户信息校验的方法 public String checkUser(User one ,User two) { if(one == null || two == null) { return "用户不一致。。。"; } String user1name = one.getUsername(); int user1password = one.getPassword(); String user2name = two.getUsername(); int user2password = two.getPassword(); // 用户名和用户密码都一样。 boolean res = user1name.equals(user2name) && user1password == user2password; if(res) { return "用户一致。。。"; } return "用户不一致。。。"; } } =============================== package day02; public class UserManagerTest { public static void main(String[] args) { //创建用户管理类UserManager 对象，用于调用校验checkUser 方法。 UserManager um = new UserManager(); // 创建用户对象，用来当实际参数。 User u1 = new User("Lucy",123456); User u2 = new User("Mike",123456); // System.out.println(u1.show()); // System.out.println(u2.show()); System.out.println("====================="); //调用校验方法， String result = um.checkUser(u1, u2); System.out.println(result); } }
Demo21_继承概念
package day02; public class Demo21_继承概念 { public static void main(String[] args) { // 共性--- 单都抽取到一个类中。其他类 继承这个共性的类。 // 父类。 // 子类。 // 子类可以用父类的非私有数据。 // 子类的对象---可以用父类的类型表示。 } } ==================== package day02; public class Employee { // 员工。 String name; public void work() { System.out.println("工作"); } } ================ package day02; public class Teacher extends Employee { } ---------- package day02; public class TeacherTest { public static void main(String[] args) { Teacher t = new Teacher(); System.out.println(t.name); t.work(); Employee e = new Employee(); fun(e); fun(t); } public static void fun(Employee e) { } }
Demo22_继承的定义和语法格式
package day02; public class Demo22_继承的定义和语法格式 { // 子类继承父类的属性和行为，；子类对象就具有与父类相同的属性和行为。 // 子类里面可以直接访问父类中的非私有的属性和行为 // stu.age = 19 // print(stu.age) // sut.show() // 提高代码的复用性---- 让类之间建立联系。是多态的前提。 // extends --- 可以声明一个类继承另外一个类。 // class 父类{ // ,,, // ,,, // } // class 子类 extends 父类{ // ,,,,, // ,,,, // } // 定义一个父类 Employee 类 --有name属性，work方法 // 定义子类Teacher 继承父类 -- 子类中有个printName方法，在方法体中调用name属性。 // 定义子类的测试类TeacherTest ，main--- 创建子类Teacher对象--给name赋值，然后调用printName方法。 } =================== package day02; public class Employee { // 定义name属性 String name; // 定义 工作的方法 --- 只是看一下方法的调用和执行，写成简单的无参无返回值的方法了。 public void work() { System.out.println("好好工作"); } } ============== package day02; // 定义子类Teacher 继承 父类Employee public class Teacher extends Employee{ // 定义打印姓名的方法 public void printName() { System.out.println("姓名：" + name);//子类就具有了和父类同意的属性和行为 //；在子类中访问父类的属性和行为。 } } ============== package day02; public class TeacherTest {// Teacher的测试类。 public static void main(String[] args) { // 创建子类Teacher类对象。 Teacher t = new Teacher(); // 给属性name赋值 t.name = "张三"; // 调用pritname方法 t.printName();// 调用无参无返回值方法。直接调用。 t.work(); } }
Demo23_方法的重写
package day02; public class Demo23_方法的重写 { } =========== package day02; public class Fu { public void show() {// show--展示 System.out.println("父类的show方法"); } } ================ package day02; public class Zi extends Fu{ // 子类出现和父类一样的方法。 public void show() { System.out.println("子类重写后的show方法"); } } ============ package day02; public class ZiTest {// test测试 public static void main(String[] args) { // 创建Zi对象。 Zi z = new Zi(); z.show();// 调用方法。// 自己有就用自己的方法。执行的是重写之后的方法。 // 谁的东西谁用。--自己没有找父类 Fu f = new Fu(); f.show(); // 拿着f去点的时候，能点出来的东西，f的类型中得有，或者父类型中有。才能点出来 } }
Demo24_super关键字
package day02; public class Demo24_super关键字 {// superclass ---- 超类，父类。subclass 子类 substring子字符串 // 父类空间优先于子类对象产生 // 在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中 // 包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非 private 修饰，则子 // 类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定先调用父类的构造方法。 // super 和 this 的含义 // super ：代表父类的存储空间标识(可以理解为父亲的引用)。 // this ：代表当前对象的引用(谁调用就代表谁)。 // super 和 this 的用法 // // new Zi();---无参构造 super() public static void main(String[] args) { Zi z = new Zi(); z.show(); // "helloworld" ----- "llo" ------ 截取子串 } } ======================== package day02; public class Fu { int age ; public Fu() { // this();本类的构造 --- super()父类的构造 System.out.println("父类的无参构造"); } public Fu(int age) { this(); this.age = age; } public void show() {// show--展示 System.out.println("父类的show方法"); } } ========================= package day02; public class Zi extends Fu{ // Exception public Zi() { super();// 父类的构造方法 System.out.println("子类的无参构造"); } public Zi(int age) { super(age); } // 子类出现和父类一样的方法。 public void show() { // this.show();// 递归 --- 停 --- 出去 ---- // 衍生 --- super.show(); System.out.println("子类重写后的show方法"); } }
Demo25_String类的方法
package day02; public class Demo25_String类的方法 { public static void main(String[] args) { // String ---- 方法 ---- 成员方法，实例方法，对象方法，非静态方法。---- 不被static关键字修饰的方法 // 用对象调用,实例调用。 String str = "helloworld"; int len = str.length();// 带返回值方法的调用 --- 赋值调用。 System.out.println(len); // // "helloworld" ----- "llo" ------ 截取子串 String str2 = str.substring(2, 5); System.out.println(str2); System.out.println(str.charAt(0)); } }
Demo26_继承的特点
package day03; class A{ } class B extends A{ } //class C extends A,B{// 类不支持多继承，只支持单继承。 // //} class C extends B{ } class D{ } public class Demo26_继承的特点 { public static void main(String[] args) { // 类不支持多继承，只支持单继承。 // 支持多层继承。 A a = new C(); B b = new C(); } }
Demo27_继承的练习题1
2-8 编程练习 编程练习：请使用面向对象的思想，设计自定义类完成如下功能要求： 接收用户输入的信息，选择需要完成的工作任务。其中，可供选择的有：测试工作和研发工作。 关于类型设定描述如下： 测试工作 属性：工作名称、编写的测试用例个数、发现的 Bug 数量 方法：工作描述 研发工作 属性：工作名称、有效编码行数、目前没有解决的 Bug 个数 方法：工作描述 程序运行参考效果图如下： 任务 思路分析： 第一步：分析测试工作和研发工作的共性： 都是工作类型 都有工作名称的属性，工作描述的方法 第二步：根据共性，定义工作类 属性：工作名称 方法： 编写无参构造方法、带参构造方法完成对属性的赋值 编写工作描述的方法，描述内容为：开心工作。 第三步：定义测试工作类、研发工作类分别继承工作类，要求： 测试工作类： 增加属性：编写的测试用例个数、发现的 Bug 数量 在构造方法中调用父类相关赋值方法，完成属性赋值 重写运行方法，描述内容为：**的日报是：今天编写了**个测试用例，发现了**bug。其中** 的数据由属性提供 研发工作类： 增加属性：有效编码行数、目前没有解决的 Bug 个数 在构造方法中调用父类相关赋值方法，完成属性赋值 重写运行方法，描述内容为：**的日报是：今天编写了**行代码，目前仍然有**个 bug 没有解 决。其中**的数据由属性提供 public class Work { // 属性：工作 ming private String name ; // 无参构造方法 // 带参构造方法，完成工作类型的赋值 // 公有的 get***/set***方法完成属性封装 // 方法：工作描述，描述内容为：开心工作 public String work() { } } public class TestWork extends Work { //属性：编写的测试用例个数、发现的 Bug 数量 // 编写构造方法，并调用父类相关赋值方法，完成属性赋值 // 公有的 get***/set***方法完成属性封装 // 重写运行方法，描述内容为：**的日报是：今天编写了**个测试用例，发现了**bug。 其中**的数据由属性提供 public String work() { } } public class DevelopmentWork extends Work { // 属性：有效编码行数、目前没有解决的 Bug 个数 //编写构造方法，并调用父类相关赋值方法，完成属性赋值 // 公有的 get***/set***方法完成属性封装 // 重写运行方法，描述内容为：**的日报是：今天编写了**行代码，目前仍然有**个 bug 没有解决。其中**的数据由属性提供 public String work() { } } public class Test { public static void main(String[] args) { System.out.print("父类信息测试："); System.out.print("测试工作类信息测试："); System.out.print("研发工作类信息测试："); } }
2-23 编程练习 编程练习：某公司要开发“XX 车行管理系统”，请使用面向对象的思想，设计自定义类描述自 行车、电动车和三轮车。 程序参考运行效果图如下： 任务 任务分析； 第一步：分析自行车、电动车和三轮车的共性： 1 都是非机动车，具有非机动车的基本特征 2 都有运行的方法 第二步：根据共性，定义非机动车 属性：品牌、颜色、轮子(默认 2 个)、座椅（默认 1 个） 方法： 1 编写无参构造方法、双参构造方法和四参构造方法，其中，在双参构造方法中，完成对品牌 和颜色的赋值；在四参构造方法中，完成对所有属性的赋值 2 编写运行的方法，描述内容为：这是一辆**颜色的，**牌的非机动车，有**个轮子，有**个 座椅的非机动车。其中**的数据由属性提供 第三步：定义自行车、电动车和三轮车分别继承非机动车类，要求： 自行车类： 1 在构造方法中调用父类多参构造，完成属性赋值 2 重写运行方法，描述内容为：这是一辆**颜色的，**牌的自行车。其中**的数据由属性提供 电动车： 1 增加“电池品牌”属性 2 重写运行方法，描述内容为：这是一辆使用**牌电池的电动车。其中**的数据由属性提供 三轮车： 1 在无参构造中实现对轮子属性值进行修改 2 重写运行方法，描述内容为：三轮车是一款有**个轮子的非机动车。其中**的数据由属性提 供 public class NonMotor { // 私有属性：品牌、颜色、轮子(默认 2 个)、座椅（默认 1 个） // 无参构造方法 // 双参构造方法，完成对品牌和颜色的赋值 // 四参构造方法，分别对所有属性赋值 // 公有的 get***/set***方法完成属性封装 // 方法：运行，描述内容为：这是一辆**颜色的，**牌的非机动车，有**个轮子，有**个 座椅的非机动车。其中**的数据由属性提供 public String work() { return str; } } public class Bicycle extends NonMotor { // 在构造方法中调用父类多参构造，完成属性赋值 // 重写运行方法，描述内容为：这是一辆**颜色的，**牌的自行车。其中**的数据由属性 提供 } public class ElectricVehicle extends NonMotor { // 私有属性：电池品牌 // 公有的 get***/set***方法完成属性封装 // 重写运行方法，描述内容为：这是一辆使用**牌电池的电动车。其中**的数据由属性提 供 } public class Tricycle extends NonMotor { // 在无参构造中实现对轮子属性值进行修改 // 重写运行方法，描述内容为：三轮车是一款有**个轮子的非机动车。其中**的数据由属 性提供 } public class Test { public static void main(String[] args) { System.out.print("父类信息测试："); System.out.print("自行车类信息测试："); System.out.print("电动车类信息测试："); System.out.print("三轮车类信息测试："); } }
Demo28_抽象类
package day03; abstract class Animal{ // 抽象类中可以有构造方法， public Animal() {} public abstract void run(); // 抽象类可以没有抽象方法；但是包含抽象方法的类，必须是抽象类。 } class Cat extends Animal{ // Override 注解的一种-- 用于校验--是否是重写下来的 @Override public void run() { System.out.println("重写后的run方法"); } } public class Demo28_抽象类 { // 继承，父类--子类--- 重新实现方法体。--- // 父类里面的方法体没有意义。---没有方法体的方法。称为抽象方法。 // 包含抽象方法的类--- 抽象类。 // 抽象方法的语法格式 //修饰符 abstract 返回值类型 方法名(参数列表); // 抽象类定义格式 // abstract class 类名{} // 非抽象的子类应该重写抽象父类的所有抽象方法。 // 抽象类不能创建对象，只能创建其非抽象子类对象。 public static void main(String[] args) { //Animal a = new Animal();//抽象类不能创建对象， Cat a = new Cat();//只能创建其非抽象子类对象。 a.run(); } }
Demo29_匿名对象
package day03; class Person{ public void close() { System.out.println("关闭"); } } public class Demo29_匿名对象 { public static void main(String[] args) { // 匿名对象：没有变量名的对象。 // Person p = new Person(); // p.close(); // p.close(); // // new Person().close(); // 匿名对象的用法： // 直接调用方法。只使用一次的时候，如果多次使用，就给出变量名； // 可以当实际参数。 // 可以当方法的返回值。 fun(new Person()); Person per = getInstance(); per.close(); } public static void fun(Person person) { person.close(); } public static Person getInstance() { return new Person();// 匿名对象当返回值。 } }
Demo30_Random类
package day03; import java.util.Random; public class Demo30_Random类 { public static void main(String[] args) { // Random --- 已经存在的类。 //---有无参构造--- 可以直接new Random r = new Random(); System.out.println(r.nextInt(5)); } }
Demo31_String类的方法
package day03; public class Demo31_String类的方法 { public static void main(String[] args) { String str1 = "helloworld"; String str2 = "HELLOWORLD"; // 判断字符串内容是否相等。 boolean res = str1.equals(str2); System.out.println(res); // 判断字符串内容是否相等。忽略大小写，判断 boolean res2 = str1.equalsIgnoreCase(str2); System.out.println(res2); // 获取字符串长度。 int len = str1.length(); System.out.println(len); //字符串拼接 String res3 = str1.concat(str2); System.out.println(res3); // 获取指定索引处的字符值。 char res4 = str1.charAt(0); System.out.println(res4); // 返回指定字符串第一次出现的索引值。 int res5 = str1.indexOf("o"); System.out.println(res5); // 截取子串，--从指定位置到末尾。 String res6 = str1.substring(5); System.out.println(res6); String str3 = "nihao"; String res7 = str3.substring(2, 4); System.out.println(res7); } }
Demo32_String类方法02
package day03; public class Demo32_String类方法02 { public static void main(String[] args) { String str = "helloworld"; //char [] arr = str.toCharArray(); // for (int i = 0; i < arr.length; i++) { // System.out.println(arr[i]); // } //--- 调用方法 --- fun("nihao".toCharArray());// fun("nihaoma".getBytes()); // 替换 replace System.out.println("nihao".replace("ni", "hello")); // 你调用的方法的形式参数的类型是高类型（父类型）--调用的时候，可以传子类对象。 String str2 = "zhangsan 12345 dsgadfga"; String [] arr = str2.split(" "); System.out.println(arr[1]); System.out.println("\\n"); for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } public static void fun(char [] arr) { } public static void fun(byte [] arr) {} }
Demo34_static关键字
package day03; class Per{ static int age; public static void fun() { System.out.println("fun-------"); } } public class Demo34_static关键字 { public static void main(String[] args) { // 成员--变量--方法 --- 属于类的---外部使用类名直接调用 Per p = new Per(); Per.fun();// 用类名直接调用 // p.age; // p.fun(); } }
Demo35_Arrays类
package day03; import java.util.Arrays; public class Demo35_Arrays类 { public static void main(String[] args) { // Array -- 数组 ---数组 // 静态方法 static --- int [] arr = {32,23,14}; String str = Arrays.toString(arr);// 把数组转换成字符串。 System.out.println(str); Arrays.sort(arr); for(int e :arr) System.out.println(e); // 2 -- 3 ---- 10 } }
Demo36_接口
package day03; interface I1{ // 抽象方法 public abstract void fun(); void fun2();// 可以省去前面的两个单词。 } // 类 和接口 的关系 ---类可以实现接口 --- 实现关系。 // class MyClass implements I1,I2{// 子类。实现类。 @Override public void fun() { // TODO Auto-generated method stub } @Override public void fun2() { // TODO Auto-generated method stub } } interface I2{} interface I3 extends I1,I2{} public class Demo36_接口 { public static void main(String[] args) { /* * 定义一个类 * class 类名{ * 变量 * 方法 * } * * 定义一个接口 --- 引用数据类型的一种。 * interface 接口名{ * 常量 * 抽象方法 * } * */ } }
Demo37_接口中的方法
1 package day03; 2 3 interface I5{ 4 // 抽象方法 5 void fun(); 6 // 默认方法---default --实现类可以重写，也可以不重写。 7 public default void fun2() { 8 fun3(); 9 } 10 // 私有方法 --- 可以供默认方法调用 11 private void fun3() { 12 13 } 14 // 静态方法 --- 在外部通过接口名. 点 调用 15 public static void fun4() { 16 17 } 18 19 } 20 class C5 implements I5{ 21 22 @Override 23 public void fun() { 24 25 26 } 27 28 } 29 30 31 public class Demo37_接口中的方法 { 32 public static void main(String[] args) { 33 I5.fun4(); 34 } 35 36 }
Demo38_接口的练习题
package day03; // 定义 IFly接口 interface IFly{ //抽象方法fly public abstract void fly(); } class Plane implements IFly{ @Override public void fly() { System.out.println("飞机在天上飞"); } } class Bird implements IFly{ @Override public void fly() { System.out.println("小鸟在天上翱翔"); } } class Balloon implements IFly{ @Override public void fly() { System.out.println("气球飞上天空"); } } public class Demo38_接口的练习题 { public static void main(String[] args) { // 创建三个实现类对象。 IFly p = new Plane(); IFly b = new Bird(); IFly b2 = new Balloon(); p.fly(); b.fly(); b2.fly(); // 多态 } }
Demo39_多态的概念
package day04; class Person{ // 在父类中定义一个方法。 public void eat() { System.out.println("父类person中的eat方法"); } } class Student extends Person{ @Override public void eat() { System.out.println("子类student中的eat方法"); } } class Teacher extends Person{ @Override public void eat() { System.out.println("子类teacher中的eat方法"); } } interface IFu{ public abstract void fun(); } class CZi2 implements IFu{ @Override public void fun() { System.out.println("实现类CZi2 重写的fun方法"); } } class CZi implements IFu{ @Override public void fun() { System.out.println("实现类CZi 重写的fun方法"); } } public class Demo39_多态的概念 { public static void main(String[] args) { // 对象的类型 对象名 = 子类对象或者实现类对象;// 实现类也可以称为接口的子类 // 对象的类型可以写出 父类型 Person t = new Teacher(); Person t2 = new Student(); IFu c = new CZi(); IFu c2 = new CZi2(); c.fun(); c2.fun(); // 方法的重写。 // 拿着谁去调用数据。能点出来，这谁的左边的数据类型里面得有这个东西（或者父类型里面得有） t.eat(); t2.eat(); // 具体执行操作得时候，右边（这变量，引用）具体是哪个对象。-- // 结果就是哪个对象在做操作。 // 谁得东西谁用。自己有用自己的。 // 同一类型的事物。执行同一操作的时候。由于具体代表的实例（对象）不同。 // 所呈现出的状态（结果）不同。---这就是多态。 } } 定义一个父类型 --- 可以是类；接口 在父类型中定义一个方法。 定义两个子类型去继承或者实现接口。 在子类中重写父类型中的方法。 定义测试类。 创建两个子类对象。--类型赋值为父类型 分别调用同一方法。
Demo40_多态的使用_已知类型用到上个文档的PersonStudentTeacherIFUCZi类型
package day04; class Person{ // 在父类中定义一个方法。 public void eat() { System.out.println("父类person中的eat方法"); } } class Student extends Person{ @Override public void eat() { System.out.println("子类student中的eat方法"); } } class Teacher extends Person{ @Override public void eat() { System.out.println("子类teacher中的eat方法"); } } interface IFu{ public abstract void fun(); } class CZi2 implements IFu{ @Override public void fun() { System.out.println("实现类CZi2 重写的fun方法"); } } class CZi implements IFu{ @Override public void fun() { System.out.println("实现类CZi 重写的fun方法"); } } public class Demo40_多态的使用_已知类型用到上个文档的PersonStudentTeacherIFUCZi类型 { public static void main(String[] args) { //多态的使用1 参数的问题 2 返回值的问题 // 1 ：参数--当你调用一个方法的时候，形参是夫类类型，你可以传入子类对象。 // 2 当你调用一个方法的时候，得到的数据类型是父类型，得到的对象是子类对象。 // 已知类型用到上个文档的PersonStudentTeacherIFUCZi类型 fun(new Teacher()); fun(new Student()); fun2(new CZi());// 形参是接口。调用的时候，可以传入实现类对象。 fun2(new CZi2());// 形参是接口。调用的时候，可以传入实现类对象。 Person init = getInstance();//带返回值方法的调用。 init.eat(); IFu z = getInstance2(); z.fun(); } public static IFu getInstance2() { return new CZi(); } // 方法的返回值类型是父类型。方法的返回值是子类对象。 public static Person getInstance() { return new Student(); } // 父类型 对象名 = 子类对象；===== 如果形式参数的类型是父类型。 // 调用方法--传入实际参数的时候 ，可以传入子类对象。 public static void fun(Person p) { p.eat(); } public static void fun2(IFu i) { i.fun(); } }
Demo41_类型转换
package day01; class Person{ } class Student extends Person{ public void love() { System.out.println("ilv"); } } class Teacher extends Person{ public void jh() { System.out.println("jh"); } } public class Demo41_类型转换 { public static void main(String[] args) { // int i = 99; // double d = i;// 小---> 大 --- 自动转型，隐式转型。 // int a = (int) d;// 大 ---> 小 --- 强制类型转换。 // 类型可以相互转换---- 一般是同类型的才能转。男 --> 女 ---- 上下转换。 // 上下转换。高低 大小 Person p1 = new Student();// 隐私转型。自动类型提升。 Person p2 = new Teacher(); Student stu1 = (Student) p1;// 强制类型转换。高-->低。 // Teacher tea = ()stu1;// 并不是想怎么转，怎么转的。 // Teacher t = (Teacher)p1;//java.lang.ClassCastException ---类型转换异常。 if(p1 instanceof Teacher ) { Teacher t = (Teacher)p1; }else if(p1 instanceof Student) { Student stu2 = (Student)p1; } // 为啥要做类型转换。---- Person p3 = new Student(); Person p4 = new Teacher(); Student stu3 = (Student)p3; stu3.love(); } }
Demo42_Object类的toString方法
package day01; import java.util.*; class Animal { String kind; int month; public Animal() { } public Animal(String kind, int month) { this.kind = kind; this.month = month; } @Override public String toString() { return "Animal [kind=" + kind + ", month=" + month + "]"; } } public class Demo42_Object类的toString方法 { public static void main(String[] args) { ArrayList list = new ArrayList(); System.out.println(list);// 多层继承。 // 根类，父类。 Animal a = new Animal("英国短猫猫",9); System.out.println(a.toString()); System.out.println(a); //day01.Animal@2133c8f8 Animal a2 = new Animal("中华田园犬",20); System.out.println(a); System.out.println(a2.toString()); // 对象的输出打印。打印对象。---- 自己描述对象的内容。 } }
Demo43_Object类的equals方法
package day02; import java.util.*; class Animal { String kind; int month; public Animal() { } public Animal(String kind, int month) { this.kind = kind; this.month = month; } @Override public String toString() { return "Animal [kind=" + kind + ", month=" + month + "]"; } @Override public boolean equals(Object obj) { if(obj == null) { return false; } Animal a = (Animal)obj; // 对象属性值的一个比较 return this.kind.equals(a.kind) && this.month == a.month; } } public class Demo43_Object类的equals方法 { public static void main(String[] args) { ArrayList list = new ArrayList(); System.out.println(list); Animal a1 = new Animal("英国短猫猫",9); Animal a2 = new Animal("中华田园犬",20); Animal a3 = new Animal("英国短猫猫",9); System.out.println(a1.equals(a3)); System.out.println(a1 == a3);// == 比较的是地址值。 } }
Demo44_Objects类
package day02; import java.util.Objects; public class Demo44_Objects类 { public static void main(String[] args) { Animal a1 = null; Animal a2 = new Animal("中华田园犬",20); // Animal a2 = null; //System.out.println(a1.equals(a2)); // Object类的equals方法不容忍空指针。 // Objects类 工具类，静态方法。类方法，static方法。----怎么调用？类名 boolean result = Objects.equals(a1, a2); System.out.println(result); System.out.println( a1 != null && a1.equals(a2)); // 就是在a1对象调用equals之前,先做个判断。 } }
Demo45_final关键字
package day02; //class Zi extends String{ // //} //class Fu { // public final void fun() {} // //} //class Zi extends Fu{ // // public void fun() {}//Cannot override the final method from Fu //} public class Demo45_final关键字 { public static void main(String[] args) { // final 最终得意思。 // 1 修饰类，最终的类---不能被继承--没有子类。 // 2 修饰方法。---不能被重写。 // 3 修饰变量，被final修饰的变量称为常量。不可再次更改（不能重新赋值）。 // final int a = 9; // a = 10; // 一般要求：常量的命名规则---所有字母全大写。单词间用下划线隔开。MY_VALUE // Math.PI } }
Demo46_访问权限修饰符
package day02; import java.util.Calendar; public class Demo46_访问权限修饰符 { public static void main(String[] args) { // public --- 公开的。 // protected 受保护的。同一个类中；同一个包的无关类可访问到。不同包的子类可以访问到。 // 默认（default）默认权限。---不写权限修饰符---不是带这个单词。 // 默认同类可以使用；同一个包可以用。 // private ---- 私有。除了本类中用，其他地方不可访问。 // Calendar // new Calendar(); ---- 创建对象--获取对象。以前通常可以通过new方式，获取。 // // （获取对象，不一定是通过new的方式获取。可以通过调用他们提供的公开的方法获取对象（实例）） // static Calendar cal = Calendar.getInstance(); } }
Demo47_Date类
package day02; import java.util.Date; public class Demo47_Date类 { public static void main(String[] args) { // 提供好的类---日期。时间。类（属性和方法） public long getTime(); // 对象，获取对象。--- 构造方法。 Date date = new Date(); long time = date.getTime(); System.out.println(time);//1684131217323 --- 毫秒值。---一秒是1000毫秒。---1970年1月1日 // 1684131325587 // 1684131217323 // 以后用这些需求的时候，你才能够快速的想到，调用哪个类的哪个方法。帮你做事情。 // 你学习开车，考驾照。挡位，转向灯， // Scanner 键盘录入 } }
Demo48_DateFormat类
package day02; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; public class Demo48_DateFormat类 { public static void main(String[] args) throws ParseException {// 解析异常。 // // Date date = new Date(); // System.out.println(date);// toString(); // // Mon May 15 14:50:22 CST 2023 // 2023-05-15 14:50:22 --- // // Date date2 = new Date(); // 2023-05-15 14:50:22 // 2006-05-15 14:50:22 // DateFormat --- 规则 --- 抽象方法。----- 非抽象的子类。 // SimpleDateFormat ---- 构造方法。 // public SimpleDateFormat(String pattern)：// pattern 规则，解析方式。 // xxxx年xx月xx日 // xxxx/xx/xx日 // xxxx-xx-xx日 // yyyy MM d H m s // // yyyy年MM月dd日 SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日"); // public String format(Date date)：将 Date 对象格式化为字符串。 // public Date parse(String source)：将字符串解析为 Date 对象。 Date date = new Date(); String dateStr = sdf.format(date); System.out.println(dateStr);//2023年05月15日 String str = "2006年5月15日"; Date date2 = sdf.parse(str);// 异常 System.out.println(date); System.out.println(date2); format --- 格式化日期对象 parse ---- 解析日期字符串 } }
Demo49_SimpleDateFormat类
package day02; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.*; public class Demo49_SimpleDateFormat类 { public static void main(String[] args) throws ParseException { String birthday = "2006年5月15日"; // 出生多少天了。 // 获取当前日期对象。 Date d1 = new Date(); // 给出指定日期字符串的date对象。 SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日"); Date d2 = sdf.parse(birthday); long now = d1.getTime(); long bir = d2.getTime(); System.out.println((now - bir)/1000/60/60/24); System.out.println((now - bir)/1000/60/60/24/365);//17 } }
Demo50_Calendar类
package day01; import java.util.Calendar; public class Demo50_Calendar类 { public static void main(String[] args) { // 日历类。字段，get(字段) --- static get(Calendar.Y) // get(XXX) 实例方法。对象。获取日历对象。protected ---new //通过类方法（静态方法）getInstance()获取实例 // getAge getName // 获取对象 Calendar cal = Calendar.getInstance(); int year = cal.get(Calendar.YEAR); int month = cal.get(Calendar.MONTH) + 1; int day = cal.get(Calendar.DATE); System.out.println(year+"年"+month+"月"+day+"日");//2023年4月16日 cal.set(Calendar.YEAR, 2024); System.out.println(cal.get(Calendar.YEAR)); cal.add(Calendar.YEAR, -2);// System.out.println(cal.get(Calendar.YEAR)); System.out.println(cal.getTime());//Mon May 16 08:46:25 CST 2022 } }
package day02; public class Demo51_System类 { // 日记 字。词语 。古诗词 。 public static void main(String[] args) { // System；类 中提供了很多静态的东西。--- 字段。 // System.out.println();// 类名. --- static 静态 类的。----实例的，非静态的；对象的。 // 类型转换？ // 获取毫秒值，---- 1970 // System.out.println(System.currentTimeMillis());//1684198553318 // // long start = System.currentTimeMillis(); // for (int i = 0; i < 1008000; i++) { // // } // // long end = System.currentTimeMillis(); // // System.out.println(end - start); int [] srcArr = {33,44,55,66,88,99}; int [] destArr = new int[5]; System.arraycopy(srcArr, 2, destArr, 0, 3); // @param src the source array. // * @param srcPos starting position in the source array. // * @param dest the destination array. // * @param destPos starting position in the destination data. // * @param length the number of array elements to be copied. for (int i : destArr) { System.out.println(i); } } }
Demo52_StringBuilder类
package day02; import java.util.ArrayList; public class Demo52_StringBuilder类 { public static void main(String[] args) { // String "nihao" String str = "helloworld"; StringBuilder sb = new StringBuilder(str); // 类型转换 String str4 = sb.toString(); //--- // 调方法。 // ArrayList list ; // System.out.println(list.toString()); // sb.append("nihao"); // // // System.out.println(sb); // // // String str2 = "nihao"; // String str3 = str2.concat("hhhh"); // System.out.println(str2); // System.out.println(str3); } }
Demo53_包装类
package day02; public class Demo53_包装类 { public static void main(String[] args) { // 999 int int a = 999; // -- "999" 方法。 // a. 数据 基本数据类型 ---- 类 --- class Integer // boolean --- Boolean // char === Character // Integer i2 = a; // 基本类型--->包装类型 ---- 装箱。自动装箱 // int i3 = i2;//包装类型 --- > 基本类型 ---- 拆箱 自动拆箱。 // parseXxx(String str) // int i4 = Integer.parseInt("999"); // int i4 = Integer.parseInt("abc");//NumberFormatException // System.out.println(i4); // System.out.println(i4+1); // "true"--True boolean b5 = Boolean.parseBoolean("Trueabc");// System.out.println(b5); // "9.8" System.out.println(Double.parseDouble("9.8")); } }
Demo54_内部类的分类
package day02; class Outer{ class Inner{}//1 成员内部类 static class staticInner{}//2 静态内部类 public void fun() { class methodInner{} // 3 局部内部类，方法内部类 } } interface Iouter{ interface Iinner{ } } public class Demo54_内部类的分类 { public static void main(String[] args) { //4 匿名内部类。 // new 类名() {} ---- } }
Demo55_匿名内部类
package day03; abstract class Animal{ public abstract void method(); } class Cat extends Animal{ @Override public void method() { System.out.println("子类重写的抽象方法"); } } interface IFly{ void fly(); } //class FlyAble implements IFly{ // //} 匿名对象的用法。 1 直接调用方法 2 可以当实际参数。 3 当返回值。 匿名内部类本质上就是一个相应类型的子类对象。 所以匿名内部类的使用参考 匿名对象的使用。 public class Demo55_匿名内部类 { public static void showFly(IFly fly) { } public static void main(String[] args) { IFly f = new IFly() { @Override public void fly() { // TODO Auto-generated method stub }}; showFly(f); // showFly(new FlyAble()); fun(new Cat()); //fun();// 要调用方法。---传入参数。Aniaml 抽象类型。 // 自定义一类型，继承形参的子类型；传入子类对象。 fun(new Animal() { @Override public void method() { System.out.println("抽象方法的重写"); }}); // 一个类型的子类对象。 // new A() {} ---- 这就是A类型的子类对象。 ---也就是匿名内部类。 //匿名内部类本质上就是子类对象。 } public static void fun(Animal animal) { } }
Demo56_集合体系
package day03; public class Demo56_集合体系 { public static void main(String[] args) { // 集合类型 --- 类，接口--- String --- 容器 。 // 生活中不同的容器 ---- 水杯 ；房间 ；集装箱；油桶。 // class 类 --- 描述单个的类型。--- // 单列集合。Collection类型 接口。 // 双列集合。键值对对象 Map } }
Demo57_Collection接口
package day03; import java.util.*; public class Demo57_Collection接口 { public static void main(String[] args) { // 共性的方法。---List Set Collection coll = new ArrayList(); coll.add("nihao"); coll.add(true); coll.add(9999);// 自动装箱 // 集合里面的元素类型是引用数据类型。 System.out.println(coll);//[nihao, true, 9999] System.out.println(coll.size());// 大小，元素的个数。 System.out.println(coll.isEmpty());// 是否为空 //coll.clear();// 清空。 // System.out.println(coll.isEmpty()); coll.remove(true); System.out.println(coll); System.out.println(coll.contains("nihao")); Object [] arr = coll.toArray(); for (Object e : arr) { String str = (String)e; System.out.println(e); } // 取出元素 } }
Demo58_泛型的使用
package day03; import java.util.ArrayList; import java.util.Collection; public class Demo58_泛型的使用 { public static void main(String[] args) { // 共性的方法。---List Set Collection<String> coll = new ArrayList<>(); coll.add("nihao"); //coll.add(true); Object [] arr = coll.toArray(); for (Object e : arr) { String str = (String)e; System.out.println(str.length()); } System.out.println("nihao" instanceof String); } }
Demo59_List接口
package day03; import java.util.*; public class Demo59_List接口 { public static void main(String[] args) { // List集合的特点 有序 ，可重复。 // 有序，有索引的概念，会有通过索引操作的方法。 List<String> list = new ArrayList<String>(); list.add("aaa"); list.add("aaa"); list.add("bbb"); list.add("ccc"); list.add("ddd"); list.add("eee"); System.out.println(list);//[aaa, bbb, ccc, ddd, eee] // list.add(2, "nihao"); // list.set(2, "nihao"); // System.out.println(list.get(0)); // System.out.println(list.get(1)); // System.out.println(list.get(2)); // System.out.println(list.get(3)); // // System.out.println(list); for(int i = 0;i<list.size();i++) { System.out.println(list.get(i)); } } }
Demo60_Iterator迭代器
package day03; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class Demo60_Iterator迭代器 { public static void main(String[] args) { // 迭代 -- 依次取出容器中的元素。 // 接口类型。规矩。集合， List<String> list = new ArrayList<String>(); list.add("aaa"); list.add("aaa"); list.add("bbb"); list.add("ccc"); list.add("ddd"); list.add("eee"); for(String e : list) {// 增强for循环。 System.out.println(e); } Iterator<String> iter = list.iterator(); while(iter.hasNext()) { String str = iter.next(); System.out.println(str); } // iter.next();NoSuchElementException // 可迭代对象，调用iterator（）方法 转成迭代器 对象。 // 迭代器对象调用自己的判断是否有元素的方法hasNext(); // 有元素就调用next()取元素。 } }
Demo61_Set接口
package day03; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedHashSet; import java.util.Set; public class Demo61_Set接口 { public static void main(String[] args) { // Set 接口--- 无序，不重复。 Set<String> s = new HashSet<String>(); s.add("aaa"); s.add("bbb"); s.add("ccc"); s.add("aaa"); System.out.println(s); // for(String e :s) { // System.out.println(e); // } for(Iterator<String> iter = s.iterator();iter.hasNext(); ) { String str = iter.next(); System.out.println(str); } } }
Demo62_Map接口迭代的方式_通过键找值
package day03; import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Set; public class Demo62_Map接口迭代的方式_通过键找值 { public static void main(String[] args) { // { "aaa", "bbb","cccc" } // // { "aaa" : 99999 , "bbb":8888,"cccc":555 } // key键 - value值 --- kv对 Map<String,Integer> map = new HashMap<>(); map.put("aaa", 999); map.put("bbb", 777); map.put("ccc", 666); map.put("ddd", 555); System.out.println(map);//{aaa=999, ccc=666, bbb=777, ddd=555} System.out.println(map.get("aaa"));// 通过键找值。 System.out.println(map.get("aaa222"));//null Set<String> set = map.keySet(); for(String k :set) { Integer v = map.get(k); System.out.println(k + " ---- " + v); } Collection<Integer> coll = map.values(); for (Integer i : coll) { System.out.println(i); } } }
Demo63_Map接口迭代的方式_键值对方式获取
package day03; import java.util.HashMap; import java.util.Map; import java.util.Set; class Outer{ class Inner{ } } public class Demo63_Map接口迭代的方式_键值对方式获取 { public static void main(String[] args) { Map<String,Integer> map = new HashMap<>(); map.put("aaa", 999); map.put("bbb", 777); map.put("ccc", 666); map.put("ddd", 555); System.out.println(map);//{aaa=999, ccc=666, bbb=777, ddd=555} // {aaa = 999, ccc = 666, bbb = 777, ddd = 555 } Set<Map.Entry<String,Integer>> set = map.entrySet(); // 键值对的类型 --- Map.Entry<String,Integer> for(Map.Entry<String,Integer> entry : set) { String k = entry.getKey(); Integer v = entry.getValue(); System.out.println(k +" ---- "+v); } } }
Demo64_单例模式_饿汉模式
package day03; class SingletonTwo{// 懒汉模式。 private SingletonTwo() {} // 私有构造，外部不能创建实例。 // 创建该类型的私有静态实例 private static SingletonTwo instance = null; // 写个公开的静态方法 用于 提供实例对象。 public static SingletonTwo getInstance() { if(instance == null) { instance = new SingletonTwo(); } return instance; } } public class Demo65_单例模式_懒汉模式 {// 类内实例对象创建的时候，并不直接初始化。直到第一次调用get方法时，才完成初始化操作。 public static void main(String[] args) { SingletonOne s = SingletonOne.getInstance(); SingletonOne s2 = SingletonOne.getInstance(); System.out.println(s); System.out.println(s2); System.out.println(SingletonOne.getInstance()); } }
Demo65_单例模式_懒汉模式
package day03; class SingletonTwo{// 懒汉模式。 private SingletonTwo() {} // 私有构造，外部不能创建实例。 // 创建该类型的私有静态实例 private static SingletonTwo instance = null; // 写个公开的静态方法 用于 提供实例对象。 public static SingletonTwo getInstance() { if(instance == null) { instance = new SingletonTwo(); } return instance; } } public class Demo65_单例模式_懒汉模式 {// 类内实例对象创建的时候，并不直接初始化。直到第一次调用get方法时，才完成初始化操作。 public static void main(String[] args) { SingletonOne s = SingletonOne.getInstance(); SingletonOne s2 = SingletonOne.getInstance(); System.out.println(s); System.out.println(s2); System.out.println(SingletonOne.getInstance()); } }
Demo66_Set集合存储自定义类型元素
package day03; import java.util.HashSet; import java.util.Objects; import java.util.Set; class Person{ private String name; private int age; public Person() { super(); // TODO Auto-generated constructor stub } public Person(String name, int age) { super(); 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; } @Override public String toString() { return "Person [name=" + name + ", age=" + age + "]"; } @Override public int hashCode() { return Objects.hash(age, name); } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Person other = (Person) obj; return age == other.age && Objects.equals(this.name, other.name); } // String 类 --- equals --- 两个字符串的内容 } //Set集合去重的原理。 public class Demo66_Set集合存储自定义类型元素 { public static void main(String[] args) { // Set接口 --- 不重复的。 Set<Person> set = new HashSet<>(); set.add(new Person("zhangsan",19)); set.add(new Person("tianqi",17)); set.add(new Person("lisi",21)); set.add(new Person("wangwu",15)); set.add(new Person("zhangsan",19)); // 判断两个元素是同一个对象。 // for (Person person : set) { System.out.println(person); } } }
Demo67_单列集合工具类Collections类
package day03; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; public class Demo67_单列集合工具类Collections类 { public static void main(String[] args) { // Collections ArrayList<String> c = new ArrayList<String>(); Collections.addAll(c , "aaa","bbb","ccc"); System.out.println(Collections.min(c)); Collections.shuffle(c); System.out.println(c); } }
Demo68_Comparator比较器接口
package day03; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; class SortClass implements Comparator<String>{ @Override public int compare(String o1, String o2) { return o2.compareTo(o1);// 降序 } } public class Demo68_Comparator比较器接口 { public static void main(String[] args) { ArrayList<String> c = new ArrayList<String>(); Collections.addAll(c , "aaa","bbb","ccc"); // Collections.sort(c, null); System.out.println(c); } }
Demo69_Comparator比较器接口自定义类型的元素比较
package day05; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; class Student{ String name; int age; public Student(String name,int age) { this.name = name; this.age = age; } public String toString() { return "姓名："+name+" 年龄："+age; } } //class SortClass implements Comparator<Student>{ // // @Override // public int compare(Student o1, Student o2) { // // return o2.age - o1.age; // } // // // //} public class Demo69_Comparator比较器接口自定义类型的元素比较 { public static void main(String[] args) { ArrayList<Student> c = new ArrayList<>(); Student stu = new Student("aaa",14); Student stu3 = new Student("ccc",16); Student stu4 = new Student("ddd",17); Student stu2 = new Student("bbb",15); Student stu5 = new Student("ddd",16); c.add(stu); c.add(stu2); c.add(stu3); c.add(stu4); c.add(stu5); // Collections.sort(c, new SortClass()); // Collections.sort(c, new Comparator<Student>() { // // @Override // public int compare(Student o1, Student o2) { // return o2.age - o1.age; // } // }); // 年龄降序，如果年龄一样，就姓名的降序。 Collections.sort(c, new Comparator<Student>() { @Override public int compare(Student o1, Student o2) { int result = o2.age - o1.age; return result == 0 ? o2.name.compareTo(o1.name) : result; } }); Collections.sort(c);// 如果用的时sort（list）这个方法排序，要求容器中的元素必须时可比较的。 // 要实现Comparable接口 // All elements in the list must implement the {@link Comparable} // * interface. for (Student student : c) { System.out.println(student); } } }
Demo70_Comparable接口
package day05; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; class Person implements Comparable<Person>{ String name; int age; public Person(String name,int age) { this.name = name; this.age = age; } public String toString() { return "姓名："+ name +" 年龄："+age; } @Override public int compareTo(Person o) { return this.age -o.age; } } public class Demo70_Comparable接口 { public static void main(String[] args) { ArrayList<Person> list = new ArrayList<>(); Person p1 = new Person("aaa",50); Person p2 = new Person("ccc",53); Person p3 = new Person("ddd",52); Person p4 = new Person("eee",56); Person p5 = new Person("fff",54); Person p6 = new Person("ccc",54); list.add(p1); list.add(p2); list.add(p3); list.add(p4); list.add(p5); list.add(p6); // 调用工具类Collections 的sort方法 // Collections.sort(list); Collections.sort(list, new Comparator<Person>() { @Override public int compare(Person o1, Person o2) { return o2.age - o1.age; } }); for (Person person : list) { System.out.println(person); } } }
