Chapter08_OOP中级 面向对象编程（中级）IDEA 使用快捷键File -> Settings -> Keymap模板FIle -> Settings -> Editor -> Live Templates包包的作用区分相同名字的类当类很多时，包可以很好地管理类控制访问范围包的基本语法package com.hspedupackage 关键字，表示打包com.hspedu 表示包名包的本质分析（原理）包的本质就是创建不同的文件夹（目录）来保存类文件快速入门命名规则只能包含数字、字母、下划线、小圆点，但不能以数字开头，不能是关键字或保留字命名规范一般是小写字母 + 小圆点com.公司名.项目名.业务模块名常用的包java.lang.* // lang 包是基本包，默认引入的，不需要再引入java.util.* // util 包，系统提供的工具包，工具类，使用 Scannerjava.net.* // 网络包，网络并发java.awt.* // 做 java 界面开发，GUI细节我们引入一个包的主要目的是要使用该包下的类比如 import java.util.Scanner ，就只是引入一个类Scannerimport java.util.* ，表示将 java.util 包所有引入建议：需要使用哪个类就导入哪个类即可，不建议使用 * 导入package 的作用是声明当前类所在的包，需要放在类的最上面，一个类中最多有一句 packageimport 指令，放在 package 的下面，在类定义前面，可以有多句且没有顺序要求访问修饰符(modifier)基本介绍java 提供四种访问控制修饰符号，用于控制方法和属性（成员变量）的访问权限（范围）：公开级别：用 public 修饰，对外公开受保护级别：用 protected 修饰，对子类和同一个包中的类公开默认级别：没有修饰符号，向同一个包的类公开私有级别：用 private 修饰，只有类本身可以访问，不对外公开细节修饰符可以用来修饰类中的属性、成员方法以及类只有默认修饰符和 public 才能修饰类子类后面再讨论成员方法的访问规则和属性完全一样*封装(encapsulation)封装是把抽象出的数据（属性）和对数据的操作（方法）封装在一起，数据被保护在内部，程序的其他部分只有通过授权的操作（方法），才能对数据进行操作。封装的好处隐藏实现细节 方法 <-- 调用可以对数据进行验证，保证安全合理实现步骤将属性私有化 private【不能直接修改属性】提供一个公共的 public set 方法，用于对属性判断并赋值public void setXxx(参数列表){​ // 加入数据验证的业务逻辑​ 属性 = 参数名;}提供一个公共的 public get 方法，用于获取属性的值public 数据类型 getXxx(){​ // 权限判断，Xxx 某个属性​ return xx;}快速入门package com.bbedu.encap; public class Encapsulation01 { public static void main(String[] args) { Person person = new Person(); person.setName("Jack"); person.setAge(30); person.setSalary(30000); System.out.println(person.info()); Person tim = new Person("Tim", 2000, 20000); System.out.println("======Tim's information======\n" + tim.info()); } } class Person { public String name; // 名字公开 private int age; // 年龄私有化 private double salary; // 与构造器结合 public Person() { } public Person(String name, int age, double salary) { // this.name = name; // this.age = age; // this.salary = salary; // 我们可以将set方法写在构造器中，这样仍然可以验证 setName(name); setAge(age); setSalary(salary); } // 自动 set get, alt + insert public String getName() { return name; } public void setName(String name) { // 加入对数据的校验 if(name.length() >= 2 && name.length() <= 6){ this.name = name; }else{ System.out.println("名字长度有误，需要(2-6)字符，默认佚名"); this.name = "佚名"; } } public int getAge() { return age; } public void setAge(int age) { // 判断 if(age >= 1 && age <= 120){ this.age = age; }else{ System.out.println("年龄输入有误，要在1-120岁，默认为18"); this.age = 18; // 默认年龄 } } public double getSalary() { return salary; } public void setSalary(double salary) { // 可以增加当前对象的权限判断 this.salary = salary; } // 写一个方法，返回属性信息 public String info(){ return "信息为 name=" + name + " age=" + age + " salary=" + salary; } } 练习Account.javapackage com.bbedu.encap; public class Account { // 三个属性设为 private private String name; private double balance; private String pwd; // 提供两个构造器 public Account(){ } public Account(String name, double balance, String pwd) { this.setName(name); this.setBalance(balance); this.setPwd(pwd); } public String getName() { return name; } public void setName(String name) { if(name.length() >= 2 && name.length() <= 4){ this.name = name; }else{ System.out.println("姓名输入错误，应为(2-4位)，默认为佚名"); this.name = "佚名"; } } public double getBalance() { return balance; } public void setBalance(double balance) { if(balance > 20){ this.balance = balance; }else{ System.out.println("余额必须(>20), 默认位0"); this.balance = 0; } } public String getPwd() { return pwd; } public void setPwd(String pwd) { if(pwd.length() == 6){ this.pwd = pwd; }else { System.out.println("密码必须是(6位), 默认为000000"); this.pwd = "000000"; } } //显示账号信息 public void showInfo() { System.out.println("账号信息 name="+ name + " 余额=" + balance + "" + " 密码=" + pwd); } } TestAccount.javapackage com.bbedu.encap; public class TestAccount { public static void main(String[] args) { // 创建Account Account account = new Account(); account.setName("Jack Chan"); account.setBalance(6); account.setPwd("222"); account.showInfo(); Account tim = new Account("Tim", 123, "233233"); tim.showInfo(); } }*继承基本介绍继承可以解决代码复用，让我们的编程更加靠近人类思维，当多个嘞存在相同的属性（变量）和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过 extends 来声明继承父类即可基本语法class 子类 extends 父类{}子类会自动拥有父类定义的属性和方法父类又叫超类，基类子类又叫派生类快速入门package com.bbedu.extend_; // 父类，是 Pupil 和 Graduate 的父类 public class Student { // 共有属性 public String name; public int age; private double score; // 共有方法 public void setScore(double score) { this.score = score; } public void showInfo() { System.out.println("学生名 " + name + " 年龄 " + age + " 成绩 " + score); } } package com.bbedu.extend_; public class Pupil extends Student{ public void testing() { System.out.println("小学生" + name + "正在考小学数学.."); } } package com.bbedu.extend_; public class Graduate extends Student{ public void testing() { System.out.println("大学生 " + name + "正在考高等数学.."); } } package com.bbedu.extend_; public class Extends01 { public static void main(String[] args) { Pupil pupil = new Pupil(); pupil.name = "Lily"; pupil.age = 10; pupil.testing(); pupil.setScore(70); pupil.showInfo(); System.out.println("=========="); Graduate graduate = new Graduate(); graduate.name = "Kris"; graduate.age = 20; graduate.testing(); graduate.setScore(60); graduate.showInfo(); } } 细节子类继承所有的属性和方法，非私有的属性和方法可以在子类直接访问，但是私有属性不能直接在子类访问，要通过公共的方法去访问子类必须调用父类的构造器，完成父类的初始化当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会调用父类的无参构造器；如果父类没有无参构造器，则必须在子类的构造器中用 super 去指定使用父类的哪个构造器去完成对父类的初始化工作，否则编译不会通过如果希望指定去调用父类的某个构造器，则需要显示地调用：super(参数列表)super 必须放在方法的第一行（super 只能在构造器中使用）super() 和 this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器java 所有类都是 Object 类的子类，Object 是所有类的基类父类构造器的调用不限于直接父类，将一直往上追溯直到 Object 类（顶级父类）子类最多只能继承一个父类（指直接继承），即 java 中是单继承机制不能滥用继承，子类和父类之间必须要满足 is-a 的逻辑关系继承的本质package com.bbedu.extend_; /** * 继承的本质 */ public class ExtendsTheory { public static void main(String[] args) { Son son = new Son(); // 内存的布局 // 要按查找规则返回信息 // 首先看子类是否有该属性，如果有且能访问，则返回 // 如果子类没有这个信息，就看父类有没有这个属性，如果有且能访问，则访问 // 依次向上找 System.out.println(son.name); System.out.println(son.getFatherAge()); System.out.println(son.hobby); } } class GrandPa { String name = "大头爷爷"; String hobby = "旅游"; } class Father extends GrandPa { String name = "大头爸爸"; private int age = 39; public int getFatherAge() { return age; } } class Son extends Father { String name = "大头儿子"; } 练习会输出：a b name b正确会输出：我是A类 hahah我是B类的有参构造 我是c类的有参构造 我是c类的无参构造package com.bbedu.extend_.exercise; class PC extends Computer { private String brand; public PC(String cpu, String memory, String drive, String brand) { super(cpu, memory, drive); this.brand = brand; } public void printInfo(){ System.out.println(getDetails() + " brand=" + brand); } } package com.bbedu.extend_.exercise; class Computer { private String cpu; private String memory; private String drive; public Computer(String cpu, String memory, String drive) { this.cpu = cpu; this.memory = memory; this.drive = drive; } public String getDetails(){ return ("CPU型号:" + cpu + " 内存大小:" + memory + " 硬盘大小:" + drive); } } package com.bbedu.extend_.exercise; class NotePad extends Computer { private String color; public NotePad(String cpu, String memory, String drive, String color) { super(cpu, memory, drive); this.color = color; } public void printInfo(){ System.out.println(getDetails() + " color=" + color); } } package com.bbedu.extend_.exercise; public class ExtendsExercise03 { public static void main(String[] args) { PC pc = new PC("Apple", "16GB", "512GB", "Apple"); pc.printInfo(); NotePad notePad = new NotePad("Qualcomm", "6GB", "128GB", "Silver"); notePad.printInfo(); } } super 关键字基本介绍super 代表父类的引用，用于访问父类的属性、方法、构造器基本语法访问父类的属性，但不能访问父类的 private 属性访问父类的方法，不能访问父类的 private 方法访问父类的构造器：super(参数列表)，只能放在构造器的第一句，且只能出现一句好处、细节调用父类的构造器的好处：分工明确，父类属性由父类初始化，子类的属性由子类初始化当子类中有和父类中的成员重名时，为了访问父类中的成员，则必须使用 super，若不重名，使用 super、 this 和 直接访问 效果相同super 的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用 super 去访问爷爷类的成员，如果多个基类中都有相同名字的成员，使用 super 时遵循就近原则。A -> B -> Cpackage com.bbedu.super_; public class Base { public int n1 = 999; public int age = 111; public void cal(){ System.out.println("Base类的 cal() 方法"); } public void eat() { System.out.println("Base类的 eat() 方法"); } } package com.bbedu.super_; public class A extends Base { // 四个属性 // public int n1 = 100; protected int n2 = 200; int n3 = 300; private int n4 = 400; public A(){ } public A(String name){ } public A(String name, int age){ } // public void cal(){ // System.out.println("A类的 cal() 方法"); // } public void test100(){ } protected void test200(){ } void test300(){ } private void test400() { } } package com.bbedu.super_; public class B extends A { public int n1 = 888; // 访问父类的构造器：super(参数列表)，只能放在构造器的第一句，且只能出现一句 public B() { // super(); // super("Jack"); super("Tim", 20); } public void cal() { System.out.println("B类的 cal() 方法"); } public void sum() { System.out.println("B类的 sum() 方法"); // 调用父类A的cal方法,有三种方法： // cal(): 先找本类，再向父类追溯 // 若找到但不能访问，则报错，若找不到，则提示不存在 cal(); // 等价于 cal() this.cal(); // 没有查找本类的过程，直接查找父类 super.cal(); // 访问属性的规则, n1 和 this.n1 相同 // 本类没有则查找父类 System.out.println(n1); System.out.println(this.n1); System.out.println(super.n1); System.out.println(age); eat(); } // 访问父类的属性，但不能访问父类的 private 属性 public void hi() { System.out.println(super.n1 + " " + super.n2 + " " + super.n3); } // 访问父类的方法，不能访问 private 方法 public void ok() { // super.test100(); // super.test200(); super.test300(); } } package com.bbedu.super_; public class super01 { public static void main(String[] args) { B b = new B(); b.sum(); } } super 和 this 的比较No.区别点thissuper1访问属性访问本类中的属性，如果本类没有则从父类继续查找从父类开始查找属性2调用方法访问本类中的方法，如果本类没有，则从父类继续查找从父类开始查找方法3调用构造器调用本类构造器，必须放在构造器的首行调用父类的构造器，必须放在子类构造器的首行4特殊表示当前对象子类中访问父类对象方法重写 / 覆盖（override）基本介绍方法重写就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法细节子类的方法的参数，方法名称，要和父类方法一致子类方法的返回类型和父类返回方法一致，或是父类返回类型的子类子类方法不能缩小父类方法的访问权限练习名称发生范围方法名参数列表返回类型修饰符重载（overload）本类必须一样类型，个数或顺新至少有一个不同无要求无要求重写（override）父子类必须一样相同一致或子是父的子类子类不能缩小package com.bbedu.override_; public class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } public String say(){ String s = "name = " + this.name + " age = " + this.age; return s; } } package com.bbedu.override_; public class Student extends Person{ private String id; private int score; public Student(String name, int age, String id, int score) { super(name, age); this.id = id; this.score = score; } @Override public String say() { return super.say() + " id = " + id + " score = " + score; } } package com.bbedu.override_; public class OverrideExercise { public static void main(String[] args) { Person jack = new Person("Jack", 35); System.out.println(jack.say()); Student student = new Student("Tim", 20, "123456", 100); System.out.println(student.say()); } } *多态(polymorphic)基本介绍方法或对象具有多种形态，是面向对象的第三大特征，多态是建立在封装和继承的基础之上的重写和重载就体现多态对象的多态（核心）(1) 一个对象的编译类型和运行类型可以不一致(2) 编译类型在定义对象时，就确定了，不能改变(3) 运行类型是可以变化的(4) 编译类型看定义时 = 的左边，运行类型看 = 的右边package com.bbedu.poly_.objectpoly_; public class Animal { public void cry(){ System.out.println("Animal 动物在叫..."); } } package com.bbedu.poly_.objectpoly_; public class Dog extends Animal { public void cry(){ System.out.println("Dog 小狗在叫..."); } } package com.bbedu.poly_.objectpoly_; public class Cat extends Animal { public void cry(){ System.out.println("Cat 小猫在叫..."); } } package com.bbedu.poly_.objectpoly_; public class PolyObject { public static void main(String[] args) { Animal animal = new Dog(); animal.cry(); animal = new Cat(); animal.cry(); } } 细节*多态的前提是：两个对象（类）存在继承关系多态的向上转型本质：父类的引用指向了子类的对象语法：父类类型 引用名 = new 子类类型();特点：编译类型看左边，运行类型看右边可以调用父类中的所有成员无法调用子类的特有成员，因为在编译阶段，能调用那些成员，是由编译类型来绝决定的最终的运行效果看子类的具体实现package com.bbedu.poly_.detail_; public class Animal { String name = "动物"; int age = 10; public void sleep(){ System.out.println("睡"); } public void run(){ System.out.println("跑"); } public void eat(){ System.out.println("吃"); } public void show(){ System.out.println("hello 你好"); } } package com.bbedu.poly_.detail_; public class Cat extends Animal{ public void eat(){ System.out.println("Cat 猫吃鱼"); } public void catchMouse(){ System.out.println("Cat 猫猫抓老鼠"); } }package com.bbedu.poly_.detail_; public class PolyDetail { public static void main(String[] args) { // 向上转型，父类的引用指向了子列的对象 Animal animal = new Cat(); Object object = new Cat(); // 可行 // (1)可以调用父类中的所有成员 // animal.catchMouse(); // 错误，(2)无法调用子类的特有成员 // (3)因为在编译阶段，能调用那些成员，是由编译类型来绝决定的 // (4)最终的运行效果看子类的具体实现 // 调用方法时，按照从子类开始查找方法，规则与前面的方法调用一致 animal.eat(); animal.run(); animal.show(); animal.sleep(); } }多态的向下转型语法：子类类型 引用名 = (子类类型) 父类引用;只能强转父类的引用，不能强转父类的对象要求父类的引用必须指向的是当前目标类型的对象当向下转型后，可以调用子类类型中的所有成员细节属性没有重写之说，属性的值看编译类型package com.bbedu.poly_.detail_; public class PolyDetail02 { public static void main(String[] args) { Sub sub = new Sub(); System.out.println(sub.count); Base base = new Sub(); System.out.println(base.count); } } class Base { int count = 10; } class Sub extends Base { int count = 20; }instanceof 比较操作符，用于判断对象 的运行类型是否为XX类型或XX类型的子类型package com.bbedu.poly_.detail_; public class PolyDetail03 { public static void main(String[] args) { BB bb = new BB(); System.out.println(bb instanceof BB); // true System.out.println(bb instanceof AA); // true // aa 编译类型 AA， 运行类型 BB AA aa = new BB(); System.out.println(aa instanceof AA); // true System.out.println(aa instanceof BB); // true Object obj = new Object(); System.out.println(obj instanceof AA); // false String str = "hello"; System.out.println(str instanceof Object); // true } } class AA { } class BB extends AA { } 练习package com.bbedu.poly_; public class PolyExercise02 { public static void main(String[] args) { Sub sub = new Sub(); System.out.println(sub.count); sub.display(); Base b = sub; System.out.println(sub == b); System.out.println(b.count); b.display(); } } class Base { int count = 10; public void display(){ System.out.println(this.count); } } class Sub extends Base{ int count = 20; public void display(){ System.out.println(this.count); } }属性看编译，方法看运行java 的动态绑定机制 (重要)当调用对象方法时，该方法会和该对象的内存地址/运行类型 绑定当调用属性时，没有动态绑定机制，哪里声明，哪里使用package com.bbedu.poly_.danamic_; public class DynamicBinding { public static void main(String[] args) { A a = new B(); // 子类中有的话，为40 // 子类没有的话，getI()调用子类的，此为动态绑定，20+10，为30 System.out.println(a.sum()); // 属性没有动态绑定，10+10，为20 System.out.println(a.sum1()); } } class A{ public int i = 10; public int sum(){ return getI() + 10; } public int getI() { return i; } public int sum1() { return i + 10; } } class B extends A { public int i = 20; // public int sum() { // return i + 20; // } @Override public int getI() { return i; } // public int sum1() { // return i + 10; // } }多态数组数组的定义类型为父类类型，里面保存的实际元素类型为子类类型package com.bbedu.poly_.polyarr_; public class Person { private String name; private int age; public Person(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 String say() { return "name = " + name + "\tage = " + age; } }package com.bbedu.poly_.polyarr_; public class Student extends Person { private double score; public Student(String name, int age, double score) { super(name, age); this.score = score; } public double getScore() { return score; } public void setScore(double score) { this.score = score; } @Override public String say() { return super.say() + "\tscore=" + score; } public void study() { System.out.println("学生 " + getName() + " 正在学习"); } }package com.bbedu.poly_.polyarr_; public class Teacher extends Person{ private double salary; public Teacher(String name, int age, double salary) { super(name, age); this.salary = salary; } public double getSalary() { return salary; } public void setSalary(double salary) { this.salary = salary; } @Override public String say() { return super.say() + "\tsalary=" + salary; } public void teach() { System.out.println("老师 " + getName() + " 正在上课"); } }package com.bbedu.poly_.polyarr_; public class PolyArray { public static void main(String[] args) { // 1 Person、2 Student、1 Teacher Person[] persons = new Person[5]; persons[0] = new Person("Tim", 20); persons[1] = new Student("Sam", 20, 80); persons[2] = new Student("Amy", 30, 60); persons[3] = new Teacher("Rain", 50, 20000); persons[4] = new Teacher("Peter", 34, 14000); for (int i = 0; i < persons.length; i++) { // person[i] 的编译类型都为 Person，运行类型根据实际情况 System.out.println(persons[i].say()); // 判断运行类型，向下转型 if(persons[i] instanceof Student){ // Student s = (Student) persons[i]; // s.study(); ((Student) persons[i]).study(); } else if(persons[i] instanceof Teacher){ // Teacher t = (Teacher) persons[i]; // t.teach(); ((Teacher) persons[i]).teach(); } else { System.out.println("不是学生也不是老师"); } } } }多态参数package com.bbedu.poly_.polyparameter_; public class Employee { private String name; private double salary; public Employee(String name, double salary) { this.name = name; this.salary = salary; } public double getAnnual() { return 12 * salary; } public String getName() { return name; } public void setName(String name) { this.name = name; } public double getSalary() { return salary; } public void setSalary(double salary) { this.salary = salary; } }package com.bbedu.poly_.polyparameter_; public class Worker extends Employee { public Worker(String name, double salary) { super(name, salary); } public void work(){ System.out.println("员工 " + getName() + " is working"); } @Override public double getAnnual() { // 直接调用父类方法 return super.getAnnual(); } }package com.bbedu.poly_.polyparameter_; public class Manager extends Employee { private double bonus; public Manager(String name, double salary, double bonus) { super(name, salary); this.bonus = bonus; } public double getBonus() { return bonus; } public void setBonus(double bonus) { this.bonus = bonus; } public void manage(){ System.out.println("经理 " + getName() + " is managing"); } @Override public double getAnnual() { return super.getAnnual() + bonus; } }package com.bbedu.poly_.polyparameter_; public class PolyParameter { public static void main(String[] args) { Worker tom = new Worker("Tom", 7000); Manager sam = new Manager("Sam", 10000, 30000); PolyParameter polyParameter = new PolyParameter(); polyParameter.showEmpAnnual(tom); polyParameter.showEmpAnnual(sam); polyParameter.testWork(tom); polyParameter.testWork(sam); } public void showEmpAnnual(Employee e) { System.out.println(e.getAnnual()); } public void testWork(Employee e){ // 向下转型 if(e instanceof Worker) { ((Worker) e).work(); }else if(e instanceof Manager){ ((Manager) e).manage(); }else { System.out.println("不做处理..."); } } }Object 类equals 方法== 和 equals 的对比== 是一个比较运算符既可以判断基本类型，又可以判断引用类型如果判断基本类型，判断的是 值 是否相等如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象euqals 方法euqals 是Object 类中的方法，只能判断引用类型默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等。比如 Integer, String练习package com.bbedu.object_; public class EuqalsExercise01 { public static void main(String[] args) { Person person = new Person("Tom", 10, '男'); Person person1 = new Person("Tom", 10, '男'); Person person2 = new Person("Jack", 20, '男'); System.out.println(person.equals(person1)); // 默认为false, Object 比较的是地址 System.out.println(person.equals(person2)); } } class Person { private String name; private int age; private char gender; @Override public boolean equals(Object obj) { // 如果比较的对象是同一个，则直接返回true if (this == obj){ // this 即为调用此方法的当前对象 return true; } if(obj instanceof Person){ //类型是Person才比较 Person p = (Person) obj; return this.name.equals(this.name) && this.age == p.age && this.gender == p.gender; // if (((Person) obj).age == this.age && // ((Person) obj).name.equals(this.name) && // ((Person) obj).gender == this.gender){ // return true; // } } return false; } public Person(String name, int age, char gender) { this.name = name; this.age = age; this.gender = gender; } 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 char getGender() { return gender; } public void setGender(char gender) { this.gender = gender; } } false/true/false/true/falsetrue/true/true/false/true/编译错误（不是同一种对象）字符的本质是整数hashCode返回该对象的哈希码值提高哈结构的容器的效率两个引用，如果指向的是同一个对象，则哈希值肯定是一样的两个引用，如果指向的是不同对象，则哈希值是不一样的哈希值主要是根据地址来计算的，但不能完全等价为地址示例后面的集合中再重写该方法package com.bbedu.object_; public class HashCode_ { public static void main(String[] args) { AA aa = new AA(); AA aa2 = new AA(); AA aa3 = aa; System.out.println("aa.hashCode()=" + aa.hashCode()); System.out.println("aa2.hashCode()=" + aa2.hashCode()); System.out.println("aa3.hashCode()=" + aa3.hashCode()); } } class AA { }toString返回该对象的字符串表示默认返回：全类型+@+哈希值的十六进制重写 toString 方法，打印对象或拼接对象式，都会自动调用该对象的 toString 形式当直接输出一个对象时，toString 方法就会默认调用该对象的 toString 方法package com.bbedu.object_; public class ToString_ { public static void main(String[] args) { /* jdk 源码 public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); } */ Monster monster = new Monster("妖怪", "巡山", 2000); System.out.println(monster.toString()); System.out.println(monster.hashCode() + " HEX: " + Integer.toHexString(monster.hashCode())); // 直接输出一个对象时，toString 方法就会默认调用该对象的 toString 方法 System.out.println(monster); } } class Monster { private String name; private String job; private double sal; // 重写输出对象的属性 @Override public String toString() { // 一般是输出对象的属性 return "Monster{" + "name='" + name + '\'' + ", job='" + job + '\'' + ", sal=" + sal + '}'; } public Monster(String name, String job, double sal) { this.name = name; this.job = job; this.sal = sal; } }finalize （废弃）当对象被回收时，系统自动会调用该对象的 finalize 方法，子类可以重写该方法，做一些释放资源的操作什么时候被回收：当某个对象没有任何引用时，则 jvm 就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会调用 finalize() 方法断点调试 (debug)需求断点调试可以一步一步的看源码执行的过程，从而发现错误所在在断点调试过程中，是运行状态，是以对象的运行类型来执行的介绍断点调试是指在程序的某一行设置一个断点，调试时，程序运行到这一行就会停住，然后你可以一步一步往下调试，调试过程中可以看各个变量当前的值，出错的话，调试到出错的代码行即显示错误，停下。进行分析从而找到这个Bug断点调试是程序员必须掌握的技能。断点调试也能帮助我们查看java底层源代码的执行过程;提高程序员的Java水平。快捷键F7 跳入 F8 跳过、逐行执行 shift + F8 跳出 F9 resume, 执行到下一个断点案例1.package com.bbedu.debug_; public class Debug01 { public static void main(String[] args) { // 演示逐行执行 int sum = 0; for (int i = 0; i < 5; i++) { sum += i; System.out.println("i=" + i); System.out.println("sum=" + sum); } System.out.println("退出for..."); } }2.package com.bbedu.debug_; public class Debug02 { public static void main(String[] args) { int[] arr = {1, 10, -1}; for (int i = 0; i <= arr.length; i++) { System.out.println(arr[i]); } System.out.println("退出for..."); } }强制进入，查看源码package com.bbedu.debug_; import java.util.Arrays; public class Debug03 { public static void main(String[] args) { int[] arr = {8, -1, 10, 98, 45}; Arrays.sort(arr); for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + "\t"); } } }resume, 动态下断点package com.bbedu.debug_; import java.util.Arrays; public class Debug04 { public static void main(String[] args) { int[] arr = {8, -1, 10, 98, 45}; Arrays.sort(arr); for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + "\t"); } System.out.println("Hello100"); System.out.println("Hello200"); System.out.println("Hello300"); System.out.println("Hello400"); System.out.println("Hello500"); System.out.println("Hello600"); } }jdk 源码也可下断点调试，不能到的会有下图显示：练习项目实战-零钱通化繁为简先完成显示菜单，并且可以选择，给出对应的提示信息完成零钱通明细完成收益入账消费退出，确认退出判断入账和消费金额是否合理将面向过程的代码改为面向对象的面向过程版本：package com.bbedu.smallchange; import java.text.SimpleDateFormat; import java.util.Date; import java.util.Scanner; import static java.lang.Thread.sleep; public class SmallChangeSys { public static void main(String[] args) throws InterruptedException { // 定义相关变量 boolean loop = true; Scanner scanner = new Scanner(System.in); String key = ""; String details = "\n------------------零钱通明细------------------"; double money = 0; double balance = 0; Date date = null; // Date 是 java.util.Date 类型，表示日期 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm"); String note = null; String confirm = null; do { System.out.println("\n------------------零钱通菜单------------------"); System.out.println("\t\t\t1 零钱通明细"); System.out.println("\t\t\t2 收 益 入 账"); System.out.println("\t\t\t3 消 费"); System.out.println("\t\t\t4 退 出"); System.out.print("请选择(1-4):"); key = scanner.next(); switch (key){ case "1": System.out.println(details); break; case "2": System.out.print("收益入账金额:"); money = scanner.nextDouble(); // money 应该校验 // 不合理的直接退出 if (money <= 0) { System.out.println("! 收益入账金额需要大于0"); break; } balance += money; date = new Date(); // 日期格式化 details += "\n收益入账\t" + "+￥" + money + "\t" + sdf.format(date) + " 余额:" + balance; break; case "3": System.out.println("消费金额:"); money = scanner.nextDouble(); // 校验 if ( money <= 0 || money > balance){ System.out.println("! 消费金额应在 (0-"+balance+")"); break; } System.out.println("消费说明:"); note = scanner.next(); balance -= money; date = new Date(); details += "\n" + note + "\t-￥" + money + "\t" + sdf.format(date) + "\t余额:" + balance; break; case "4": // 编程遵守原子性 while (true){ System.out.println("确定要退出吗? (y/n)"); confirm = scanner.next(); if(confirm.equals("y") || confirm.equals("n")){ break; }else { System.out.println("! 输入有误, 请重新输入"); } } if (confirm.equals("y")){ System.out.print(" 退 出 中"); for (int i = 0; i < 3; i++) { Thread.sleep(300); System.out.print(" ."); } System.out.println(); loop = false; } break; default: System.out.println("! 选择有误，请重新选择"); } }while (loop); System.out.println("-----零钱通已退出-----"); } }面向对象版本：package com.bbedu.smallchange.oop; import java.text.SimpleDateFormat; import java.util.Date; import java.util.Scanner; /** * 该类完成零钱通的各个功能 * 使用OOP * 将各个功能对应应该方法 */ public class SmallChangeSysOOP { // 定义相关变量 boolean loop = true; Scanner scanner = new Scanner(System.in); String key = ""; String details = "\n------------------零钱通明细------------------"; double money = 0; double balance = 0; Date date = null; // Date 是 java.util.Date 类型，表示日期 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm"); String note = null; String confirm = null; public void showTab(){ do { System.out.println("\n------------------零钱通选择菜单------------------"); System.out.println("\t\t\t1 零钱通明细"); System.out.println("\t\t\t2 收 益 入 账"); System.out.println("\t\t\t3 消 费"); System.out.println("\t\t\t4 退 出"); System.out.print("请选择(1-4):"); key = scanner.next(); switch (key){ case "1": detail(); break; case "2": income(); break; case "3": pay(); break; case "4": exit(); break; default: System.out.println("! 选择有误，请重新选择"); } }while (loop); } public void detail(){ System.out.println(details); } public void income(){ System.out.print("收益入账金额:"); money = scanner.nextDouble(); // money 应该校验 // 不合理的直接退出 if (money <= 0) { System.out.println("! 收益入账金额需要大于0"); return; // 退出方法，不在执行后面的代码 } balance += money; date = new Date(); // 日期格式化 details += "\n收益入账\t" + "+" + money + "\t" + sdf.format(date) + " 余额:" + balance; } public void pay(){ System.out.println("消费金额:"); money = scanner.nextDouble(); // 校验 if ( money <= 0 || money > balance){ System.out.println("! 消费金额应在 (0-"+balance+")"); return; } System.out.println("消费说明:"); note = scanner.next(); balance -= money; date = new Date(); details += "\n" + note + "\t-" + money + "\t" + sdf.format(date) + "\t余额:" + balance; } public void exit() { // 编程遵守原子性 while (true){ System.out.println("确定要退出吗? (y/n)"); confirm = scanner.next(); if(confirm.equals("y") || confirm.equals("n")){ break; }else { System.out.println("! 输入有误, 请重新输入"); } } if (confirm.equals("y")){ System.out.println(" 退 出 中"); loop = false; } System.out.println("-----零钱通已退出-----"); } }package com.bbedu.smallchange.oop; public class SmallChangeSysApp { public static void main(String[] args) { SmallChangeSysOOP smallChangeSysOOP = new SmallChangeSysOOP(); smallChangeSysOOP.showTab(); } }本章练习package com.bbedu.homework; public class Homework01 { public static void main(String[] args) { // 对象数组，注意声明方式: Person[] people = new Person[3]; people[0] = new Person("Jack", 30, "Coder"); people[1] = new Person("Tim", 20, "teacher"); people[2] = new Person("Mary", 40, "seller"); for (int i = 0; i < people.length; i++) { System.out.println(people[i]); } // 冒泡排序 for (int i = 0; i < people.length - 1; i++) { for (int j = 0; j < people.length - i -1; j++) { if (people[j].getAge() < people[j+1].getAge()){ int tmp = people[j].getAge(); people[j].setAge(people[j+1].getAge()); people[j+1].setAge(tmp); } } } System.out.println("===排序后==="); for (int i = 0; i < people.length; i++) { System.out.println(people[i]); } } } class Person{ private String name; private int age; private String job; public Person(String name, int age, String job) { this.name = name; this.age = age; this.job = job; } 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 String getJob() { return job; } public void setJob(String job) { this.job = job; } @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + ", job='" + job + '\'' + '}'; } }package com.bbedu.homework; public class Homework03 { public static void main(String[] args) { Professor professor = new Professor("Cook", 50, "CEO", 1500000, 1.3); professor.introduce(); } } class Teacher{ private String name; private int age; private String post; private double salary; private double grade; public Teacher(String name, int age, String post, double salary, double grade) { this.name = name; this.age = age; this.post = post; this.salary = salary; this.grade = grade; } 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 String getPost() { return post; } public void setPost(String post) { this.post = post; } public double getSalary() { return salary; } public void setSalary(double salary) { this.salary = salary; } public double getGrade() { return grade; } public void setGrade(double grade) { this.grade = grade; } public void introduce(){ System.out.print("name=" + name + " age=" + age + " post=" + post + " salary=" + salary); } } class Professor extends Teacher{ public Professor(String name, int age, String post, double salary, double grade) { super(name, age, post, salary, grade); } @Override public void introduce() { super.introduce(); System.out.println(" grade=" + this.getGrade()); } }package com.bbedu.homework; public class Homework04 { public static void main(String[] args) { Worker tim = new Worker("Tim", 100, 30); tim.printSalary(); Manager cook = new Manager("Cook", 300, 20); cook.printSalary(); } } class Employee { private String name; private double dayPay; private int workDay; public Employee(String name, double dayPay, int workDay) { this.name = name; this.dayPay = dayPay; this.workDay = workDay; } public String getName() { return name; } public void setName(String name) { this.name = name; } public double getDayPay() { return dayPay; } public void setDayPay(double dayPay) { this.dayPay = dayPay; } public int getWorkDay() { return workDay; } public void setWorkDay(int workDay) { this.workDay = workDay; } public void printSalary(){ System.out.print("name=" + name + " dayPay=" + dayPay + "workDay="+ workDay); } } class Worker extends Employee{ public Worker(String name, double dayPay, int workDay) { super(name, dayPay, workDay); } @Override public void printSalary() { System.out.print("Worker "); super.printSalary(); System.out.println(" salary=" + getWorkDay()*getDayPay()*1.0); } } class Manager extends Employee{ public Manager(String name, double dayPay, int workDay) { super(name, dayPay, workDay); } @Override public void printSalary() { System.out.print("Manager "); super.printSalary(); System.out.println(" salary=" + getWorkDay()*getDayPay()*1.2); } }package com.bbedu.homework.homework5; public class Test { public static void main(String[] args) { Employee[] e = new Employee[5]; e[0] = new Worker("Sam", 100); e[1] = new Waiter("Peter", 120); e[2] = new Peasant("Tony", 80); e[3] = new Teacher("Mary", 150, 20); e[4] = new Scientist("Bob", 200, 100000); for (int i = 0; i < e.length; i++) { e[i].printSal(); } } }package com.bbedu.homework.homework5; public class Employee { private String name; private double sal; public Employee(String name, double sal) { this.name = name; this.sal = sal; } public String getName() { return name; } public void setName(String name) { this.name = name; } public double getSal() { return sal; } public void setSal(double sal) { this.sal = sal; } public void printSal(){ System.out.println("name=" + name + " salary=" + sal*365); } }package com.bbedu.homework.homework5; public class Worker extends Employee { public Worker(String name, double sal) { super(name, sal); } @Override public void printSal() { System.out.print("Worker "); super.printSal(); } }package com.bbedu.homework.homework5; public class Peasant extends Employee { public Peasant(String name, double sal) { super(name, sal); } @Override public void printSal() { System.out.print("Peasant "); super.printSal(); } }package com.bbedu.homework.homework5; public class Teacher extends Employee { private double dayPay; public Teacher(String name, double sal, double dayPay) { super(name, sal); this.dayPay = dayPay; } public double getDayPay() { return dayPay; } public void setDayPay(double dayPay) { this.dayPay = dayPay; } @Override public void printSal() { System.out.print("Teacher "); System.out.println("name=" + getName() + " salary=" + (getSal()+getDayPay())*365); } }package com.bbedu.homework.homework5; public class Scientist extends Employee{ private double bonus; public Scientist(String name, double sal, double bonus) { super(name, sal); this.bonus = bonus; } public double getBonus() { return bonus; } public void setBonus(double bonus) { this.bonus = bonus; } @Override public void printSal() { System.out.print("Scientist "); System.out.println("name=" + getName() + " salary=" + (getSal()*365+getBonus())); } }package com.bbedu.homework.homework5; public class Waiter extends Employee{ public Waiter(String name, double sal) { super(name, sal); } @Override public void printSal() { System.out.print("Waiter "); super.printSal(); } }package com.bbedu.homework.homework8; public class BankAccount { private double balance; public BankAccount(double initialBalance) { this.balance = initialBalance; } public void deposit(double amount) { balance += amount; } public void withdraw(double amount) { balance -= amount; } public double getBalance() { return balance; } }package com.bbedu.homework.homework8; public class CheckingAccount extends BankAccount { public CheckingAccount(double initialBalance) { super(initialBalance); } @Override public void deposit(double amount) { super.deposit(amount - 1); } @Override public void withdraw(double amount) { super.withdraw(amount + 1); } }package com.bbedu.homework.homework8; public class SavingAccount extends BankAccount{ private int freeCount = 3; private double rate = 0.01; // 利率 public SavingAccount(double initialBalance) { super(initialBalance); } public int getFreeCount() { return freeCount; } public void setFreeCount(int freeCount) { this.freeCount = freeCount; } public double getRate() { return rate; } public void setRate(double rate) { this.rate = rate; } @Override public void deposit(double amount) { if (freeCount > 0){ super.deposit(amount); } else { super.deposit(amount - 1); } freeCount--; } @Override public void withdraw(double amount) { if (freeCount > 0){ super.withdraw(amount); } else { super.withdraw(amount + 1); } freeCount--; } public void earnMonthlyInterest(){ freeCount = 3; super.deposit(getBalance()*rate); } }package com.bbedu.homework.homework8; public class Homework08 { public static void main(String[] args) { // CheckingAccount checkingAccount = new CheckingAccount(1000); // checkingAccount.deposit(100); // checkingAccount.withdraw(10); // System.out.println(checkingAccount.getBalance()); SavingAccount savingAccount = new SavingAccount(1000); savingAccount.deposit(100); savingAccount.deposit(100); savingAccount.deposit(100); System.out.println(savingAccount.getBalance()); savingAccount.deposit(100); System.out.println(savingAccount.getBalance()); savingAccount.earnMonthlyInterest(); savingAccount.deposit(100); System.out.println(savingAccount.getBalance()); } }public LabeledPoint(String label, double x, double y) { super(x, y); this.label = label; }package com.bbedu.homework.homework10; public class Doctor { private String name; private int age; private String job; private String gender; private double sal; public Doctor(String name, int age, String job, String gender, double sal) { this.name = name; this.age = age; this.job = job; this.gender = gender; this.sal = sal; } 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 String getJob() { return job; } public void setJob(String job) { this.job = job; } public String getGender() { return gender; } public void setGender(String gender) { this.gender = gender; } public double getSal() { return sal; } public void setSal(double sal) { this.sal = sal; } @Override public boolean equals(Object obj) { if(this == obj){ return true; } if(!(obj instanceof Doctor)){ return false; } Doctor doctor = (Doctor) obj; return doctor.age == this.age && doctor.sal == this.sal && doctor.name.equals(this.name) && doctor.job.equals((this.job)) && doctor.gender.equals(this.gender); } }package com.bbedu.homework.homework11; import java.rmi.StubNotFoundException; public class Homework11 { public static void main(String[] args) { // 向上转型 Person p = new Student(); // 可以用 Person 的 eat()和 run() 方法, 但run方法被Student类重写 // 不能调用子类的特有方法, 因为编译类型为父类 p.eat(); p.run(); // 向下转型 Student s = (Student) p; // 可以调用子类的所有方法 s.run(); s.eat(); s.study(); } }

小说推荐——呼吸 Exhalation 呼吸为何喜欢科幻？无非是因为它能将你从纷繁的世界中抽离，以极冷峻的视角看待我们所处的世界。“人必生活着，爱才有所附丽”。看清了悲剧的最终，更加努力地去生存、生活乃至享受。在实验过程中，这些机械手的本质不正是我的双手吗？潜望镜末端的显微镜头实际上不也是我的双眼吗？作为一个得到了拓展的个体，我微不足道的身体充当了中央的超级大脑。就是以这种不可思议的配合，我开始了探索自身的旅程。我身体的每一个动作都对宇宙气压的平衡起到了推波助澜的作用，我所思考的每一个想法，都加速了世界末日的到来。我们的脑研究没有为我们揭示过去的秘密，反而展现了未来的结局。我所有的欲望和沉思，都是这个宇宙缓缓呼出的气流。在这漫长的呼气结束之前，我的思维将一直存在。我们的宇宙在滑向平衡点的过程中也许只能静静地呼气，但它繁衍出的我们这个丰富多彩的世界却是个奇迹，只有诞生了你们的宇宙才能与之媲美。仔细想想，得以存在便是一个奇迹，能够思考就是一件乐事。

PHP 初探 原起必应壁纸看着很眼馋，这玩意还是每日更新的，如果我的网站也能用上每日更新的壁纸那该多帅！说搞就搞，Google 了一下 bing壁纸api，有用 java + Github Actions的，例如这个大佬的，这个也很棒，正好在学java，之后再复刻吧。偶然间看见了用 PHP 写的脚本，只需要短短几行，我试着上传到我的网站，竟完全可以调用！惊到了，因而想要尝试下这玩意儿。开搞！PHP是什么？PHP（全称：PHP：Hypertext Preprocessor，即"PHP：超文本预处理器"）是一种通用开源脚本语言。PHP 脚本在服务器上执行。PHP 可免费下载使用。能做什么PHP 可以生成动态页面内容PHP 可以创建、打开、读取、写入、关闭服务器上的文件PHP 可以收集表单数据PHP 可以发送和接收 cookiesPHP 可以添加、删除、修改您的数据库中的数据PHP 可以限制用户访问您的网站上的一些页面PHP 可以加密数据通过 PHP，您不再限于输出 HTML。您可以输出图像、PDF 文件，甚至 Flash 电影。您还可以输出任意的文本，比如 XHTML 和 XML。基本语法先来看看我上传到网站上的API<?php $str = file_get_contents('http://cn.bing.com/HPImageArchive.aspx?idx=0&n=1'); // 从bing获取数据 if(preg_match('/<url>([^<]+)<\/url>/isU', $str, $matches)) { // 正则匹配抓取图片url $imgurl = 'http://cn.bing.com'.$matches[1]; } else { // 如果由于某些原因，没抓取到图片地址 $imgurl = 'http://img.infinitynewtab.com/InfinityWallpaper/2_14.jpg'; // 使用默认的图像(默认图像链接可修改为自己的) } header("Location: {$imgurl}"); // 跳转至目标图像 ?>容易看出：PHP 以 <? php 开始，以 ?> 结束$表示变量，PHP 是一门弱类型语言PHP 会根据变量的值，自动把变量转换为正确的数据类型。在强类型的编程语言中，我们必须在使用变量前先声明（定义）变量的类型和名称。逻辑语句很容易理解，下来就是几个函数：file_get_contents():file_get_contents() 把整个文件读入一个字符串中。该函数是用于把文件的内容读入到一个字符串中的首选方法。如果服务器操作系统支持，还会使用内存映射技术来增强性能。直接返回 $str 为：preg_match()：preg_match 函数用于执行一个正则表达式匹配。正则表达式又是一节知识，还好有之前学 python 爬虫时的一点点积累，把这个模式串拿来研究一下：'/<url>([^<]+)<\/url>/isU'从外而内，isU 是修饰符，i 表示不区分大小写，s 表示是包含换行符\n，u 表示开启 Unicode。最外层的两个反斜杠为标识，标识此为正则表达式，内部的一个反斜杠是区分斜杠的。内部的元字符咱们下次再研究。语法int preg_match ( string $pattern , string $subject [, array &$matches [, int $flags = 0 [, int $offset = 0 ]]] )搜索 subject 与 pattern 给定的正则表达式的一个匹配。参数说明：$pattern: 要搜索的模式，字符串形式。$subject: 输入字符串。$matches: 如果提供了参数matches，它将被填充为搜索结果。 $matches[0]将包含完整模式匹配到的文本， $matches[1] 将包含第一个捕获子组匹配到的文本，以此类推。$flags：flags 可以被设置为以下标记值：PREG_OFFSET_CAPTURE: 如果传递了这个标记，对于每一个出现的匹配返回时会附加字符串偏移量(相对于目标字符串的)。 注意：这会改变填充到matches参数的数组，使其每个元素成为一个由 第0个元素是匹配到的字符串，第1个元素是该匹配字符串 在目标字符串subject中的偏移量。offset: 通常，搜索从目标字符串的开始位置开始。可选参数 offset 用于 指定从目标字符串的某个未知开始搜索(单位是字节)。header()header() 函数向客户端发送原始的 HTTP 报头。根据上述所研究，简单改写程序得到：<?php $str = file_get_contents('http://cn.bing.com/HPImageArchive.aspx?idx=0&n=1'); // 从bing获取数据 if(preg_match('/<url>([^<]+)<\/url>/isU', $str, $matches)) { // 正则匹配抓取图片url $imgurl = 'http://cn.bing.com'.$matches[1]; } else { // 如果由于某些原因，没抓取到图片地址 $imgurl = 'http://img.infinitynewtab.com/InfinityWallpaper/2_14.jpg'; // 使用默认的图像(默认图像链接可修改为自己的) } if(preg_match('/<copyright>([^<]+)<\/copyright>/isU', $str, $matches)) { // 正则匹配抓取图片版权信息 $copyrightStr = $matches[1]; } else { $copyrightStr = 'No Copyright'; // 没有找到版权信息 } echo $copyrightStr ?>得出图片的版权信息，现需要将版权信息和图片结合起来，得到下图效果：PHP + HTMLPHP 天生对 Web 和 HTML 友好，在 PHP 诞生之初，主要用于在 Web 1.0 中构建个人主页，那个时候，PHP 代表的是 Personal Home Page，随着 Web 互联网的发展，在 Web 2.0 时代，PHP 进一步进化为 PHP:Hypertext Preprocessor，即超文本处理器，而 HTML 则是 HyperText Markup Language 的缩写，也就是超文本标记语言。一个是标记语言，一个是处理器，可见二者之间的渊源，它们之间的关系甚至亲密到可以直接混合在一起进行编程，PHP 脚本在 HTML 文档中只是一种特殊标记而已，并且可以在 HTML 文档中直接编写任何 PHP 脚本代码，然后将文档保存为 .php 文件，就可以被 PHP 解释器解析和执行。下面我们就来看看如何基于 PHP + HTML 进行混合编程。先凭直觉尝试一下：<header class="w3-display-container w3-content w3-center" style="max-width:100%" height="600"> <img class="w3-image smallImg" src="https://cn.bing.com/th?id=OHR.PWPeaceDoves_EN-US7797522376_UHD.jpg&amp;pid=hp&amp;w=100" width="100%"> <img class="w3-image bigImg" onload="imgloading(this)" src=<?php $str = file_get_contents('http://cn.bing.com/HPImageArchive.aspx?idx=0&n=1'); // 从bing获取数据 if(preg_match('/<url>([^<]+)<\/url>/isU', $str, $matches)) { // 正则匹配抓取图片url $imgurl = 'http://cn.bing.com'.$matches[1]; } else { // 如果由于某些原因，没抓取到图片地址 $imgurl = 'http://img.infinitynewtab.com/InfinityWallpaper/2_14.jpg'; // 使用默认的图像(默认图像链接可修改为自己的) } echo $str; ?> width="100%" style="opacity: 1.28;"> <div class="w3-display-middle w3-padding-large w3-wide w3-text-light-grey w3-center"> <h1 class="w3-hide-medium w3-hide-small w3-xxxlarge">Bing Wallpaper</h1> <div class=" w3-padding-large w3-text-light-grey" style="max-width: 800px"> <p><?php if(preg_match('/<copyright>([^<]+)<\/copyright>/isU', $str, $matches)) { // 正则匹配抓取图片版权信息 $copyrightStr = $matches[1]; } else { $copyrightStr = 'No Copyright'; // 没有找到版权信息 } echo $copyrightStr; ?></p> </div> <h5 class="w3-hide-large" style="white-space:nowrap">Bing Wallpaper</h5> </div> </header>一团糟，再看看~<img src=<?php $str = file_get_contents('http://cn.bing.com/HPImageArchive.aspx?idx=0&n=1'); // 从bing获取数据 if(preg_match('/<url>([^<]+)<\/url>/isU', $str, $matches)) { // 正则匹配抓取图片url $imgurl = 'http://cn.bing.com'.$matches[1]; } else { // 如果由于某些原因，没抓取到图片地址 $imgurl = 'http://img.infinitynewtab.com/InfinityWallpaper/2_14.jpg'; // 使用默认的图像(默认图像链接可修改为自己的) } echo $imgurl ?>>成功载入图片，现在尝试加入版权信息。再加入一点点的 CSS，完善 html 格式<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>W3Cschool</title> <style> div{ position: relative; } h1{font-size: 16px; color: white; position:absolute; top:50px; left:10px;} </style> </head> <body> <div> <img src=<?php $str = file_get_contents('http://cn.bing.com/HPImageArchive.aspx?idx=0&n=1'); // 从bing获取数据 if(preg_match('/<url>([^<]+)<\/url>/isU', $str, $matches)) { // 正则匹配抓取图片url $imgurl = 'http://cn.bing.com'.$matches[1]; } else { // 如果由于某些原因，没抓取到图片地址 $imgurl = 'http://img.infinitynewtab.com/InfinityWallpaper/2_14.jpg'; // 使用默认的图像(默认图像链接可修改为自己的) } echo $imgurl ?>> <h1><?php $str = file_get_contents('http://cn.bing.com/HPImageArchive.aspx?idx=0&n=1'); // 从bing获取数据 if(preg_match('/<copyright>([^<]+)<\/copyright>/isU', $str, $matches)) { // 正则匹配抓取图片版权信息 $copyrightStr = $matches[1]; } else { $copyrightStr = 'No Copyright'; // 没有找到版权信息 } echo $copyrightStr ?></h1> </div> </body> </html>保存为 .php 文件效果还不错，缺少些艺术感，不过也凑合吧，现在上传到我的网站试一试。不显示，应该是主题的问题，改改主题试试。尝试失败，最终成为一个导航页至此结束，总结：学到了以下这些东西：PHP基本语法，正则表达式，PHP 如何嵌入 HTML，PHP 如何运行还需学习：PHP 高级用法，正则表达式细节，CSS 如何配合 PHP以达到更好的效果

线性回归实验 html {overflow-x: initial !important;}:root { --bg-color:#ffffff; --text-color:#333333; --select-text-bg-color:#B5D6FC; --select-text-font-color:auto; --monospace:"Lucida Console",Consolas,"Courier",monospace; --title-bar-height:20px; } .mac-os-11 { --title-bar-height:28px; } html { font-size: 14px; background-color: var(--bg-color); color: var(--text-color); font-family: "Helvetica Neue", Helvetica, Arial, sans-serif; -webkit-font-smoothing: antialiased; } body { margin: 0px; padding: 0px; height: auto; inset: 0px; font-size: 1rem; line-height: 1.42857; overflow-x: hidden; background: inherit; tab-size: 4; } iframe { margin: auto; } a.url { word-break: break-all; } a:active, a:hover { outline: 0px; } .in-text-selection, ::selection { text-shadow: none; background: var(--select-text-bg-color); color: var(--select-text-font-color); } #write { margin: 0px auto; height: auto; width: inherit; word-break: normal; overflow-wrap: break-word; position: relative; white-space: normal; overflow-x: visible; padding-top: 36px; } #write.first-line-indent p { text-indent: 2em; } #write.first-line-indent li p, #write.first-line-indent p * { text-indent: 0px; } #write.first-line-indent li { margin-left: 2em; } .for-image #write { padding-left: 8px; padding-right: 8px; } body.typora-export { padding-left: 30px; padding-right: 30px; } .typora-export .footnote-line, .typora-export li, .typora-export p { white-space: pre-wrap; } .typora-export .task-list-item input { pointer-events: none; } @media screen and (max-width: 500px) { body.typora-export { padding-left: 0px; padding-right: 0px; } #write { padding-left: 20px; padding-right: 20px; } } #write li > figure:last-child { margin-bottom: 0.5rem; } #write ol, #write ul { position: relative; } img { max-width: 100%; vertical-align: middle; image-orientation: from-image; } button, input, select, textarea { color: inherit; font: inherit; } input[type="checkbox"], input[type="radio"] { line-height: normal; padding: 0px; } *, ::after, ::before { box-sizing: border-box; } #write h1, #write h2, #write h3, #write h4, #write h5, #write h6, #write p, #write pre { width: inherit; } #write h1, #write h2, #write h3, #write h4, #write h5, #write h6, #write p { position: relative; } p { line-height: inherit; } h1, h2, h3, h4, h5, h6 { break-after: avoid-page; break-inside: avoid; orphans: 4; } p { orphans: 4; } h1 { font-size: 2rem; } h2 { font-size: 1.8rem; } h3 { font-size: 1.6rem; } h4 { font-size: 1.4rem; } h5 { font-size: 1.2rem; } h6 { font-size: 1rem; } .md-math-block, .md-rawblock, h1, h2, h3, h4, h5, h6, p { margin-top: 1rem; margin-bottom: 1rem; } .hidden { display: none; } .md-blockmeta { color: rgb(204, 204, 204); font-weight: 700; font-style: italic; } a { cursor: pointer; } sup.md-footnote { padding: 2px 4px; background-color: rgba(238, 238, 238, 0.7); color: rgb(85, 85, 85); border-radius: 4px; cursor: pointer; } sup.md-footnote a, sup.md-footnote a:hover { color: inherit; text-transform: inherit; text-decoration: inherit; } #write input[type="checkbox"] { cursor: pointer; width: inherit; height: inherit; } figure { overflow-x: auto; margin: 1.2em 0px; max-width: calc(100% + 16px); padding: 0px; } figure > table { margin: 0px; } thead, tr { break-inside: avoid; break-after: auto; } thead { display: table-header-group; } table { border-collapse: collapse; border-spacing: 0px; width: 100%; overflow: auto; break-inside: auto; text-align: left; } table.md-table td { min-width: 32px; } .CodeMirror-gutters { border-right: 0px; background-color: inherit; } .CodeMirror-linenumber { user-select: none; } .CodeMirror { text-align: left; } .CodeMirror-placeholder { opacity: 0.3; } .CodeMirror pre { padding: 0px 4px; } .CodeMirror-lines { padding: 0px; } div.hr:focus { cursor: none; } #write pre { white-space: pre-wrap; } #write.fences-no-line-wrapping pre { white-space: pre; } #write pre.ty-contain-cm { white-space: normal; } .CodeMirror-gutters { margin-right: 4px; } .md-fences { font-size: 0.9rem; display: block; break-inside: avoid; text-align: left; overflow: visible; white-space: pre; background: inherit; position: relative !important; } .md-fences-adv-panel { width: 100%; margin-top: 10px; text-align: center; padding-top: 0px; padding-bottom: 8px; overflow-x: auto; } #write .md-fences.mock-cm { white-space: pre-wrap; } .md-fences.md-fences-with-lineno { padding-left: 0px; } #write.fences-no-line-wrapping .md-fences.mock-cm { white-space: pre; overflow-x: auto; } .md-fences.mock-cm.md-fences-with-lineno { padding-left: 8px; } .CodeMirror-line, twitterwidget { break-inside: avoid; } svg { break-inside: avoid; } .footnotes { opacity: 0.8; font-size: 0.9rem; margin-top: 1em; margin-bottom: 1em; } .footnotes + .footnotes { margin-top: 0px; } .md-reset { margin: 0px; padding: 0px; border: 0px; outline: 0px; vertical-align: top; background: 0px 0px; text-decoration: none; text-shadow: none; float: none; position: static; width: auto; height: auto; white-space: nowrap; cursor: inherit; -webkit-tap-highlight-color: transparent; line-height: normal; font-weight: 400; text-align: left; box-sizing: content-box; direction: ltr; } li div { padding-top: 0px; } blockquote { margin: 1rem 0px; } li .mathjax-block, li p { margin: 0.5rem 0px; } li blockquote { margin: 1rem 0px; } li { margin: 0px; position: relative; } blockquote > :last-child { margin-bottom: 0px; } blockquote > :first-child, li > :first-child { margin-top: 0px; } .footnotes-area { color: rgb(136, 136, 136); margin-top: 0.714rem; padding-bottom: 0.143rem; white-space: normal; } #write .footnote-line { white-space: pre-wrap; } @media print { body, html { border: 1px solid transparent; height: 99%; break-after: avoid; break-before: avoid; font-variant-ligatures: no-common-ligatures; } #write { margin-top: 0px; padding-top: 0px; border-color: transparent !important; padding-bottom: 0px !important; } .typora-export * { -webkit-print-color-adjust: exact; } .typora-export #write { break-after: avoid; } .typora-export #write::after { height: 0px; } .is-mac table { break-inside: avoid; } .typora-export-show-outline .typora-export-sidebar { display: none; } } .footnote-line { margin-top: 0.714em; font-size: 0.7em; } a img, img a { cursor: pointer; } pre.md-meta-block { font-size: 0.8rem; min-height: 0.8rem; white-space: pre-wrap; background: rgb(204, 204, 204); display: block; overflow-x: hidden; } p > .md-image:only-child:not(.md-img-error) img, p > img:only-child { display: block; margin: auto; } #write.first-line-indent p > .md-image:only-child:not(.md-img-error) img { left: -2em; position: relative; } p > .md-image:only-child { display: inline-block; width: 100%; } #write .MathJax_Display { margin: 0.8em 0px 0px; } .md-math-block { width: 100%; } .md-math-block:not(:empty)::after { display: none; } .MathJax_ref { fill: currentcolor; } [contenteditable="true"]:active, [contenteditable="true"]:focus, [contenteditable="false"]:active, [contenteditable="false"]:focus { outline: 0px; box-shadow: none; } .md-task-list-item { position: relative; list-style-type: none; } .task-list-item.md-task-list-item { padding-left: 0px; } .md-task-list-item > input { position: absolute; top: 0px; left: 0px; margin-left: -1.2em; margin-top: calc(1em - 10px); border: none; } .math { font-size: 1rem; } .md-toc { min-height: 3.58rem; position: relative; font-size: 0.9rem; border-radius: 10px; } .md-toc-content { position: relative; margin-left: 0px; } .md-toc-content::after, .md-toc::after { display: none; } .md-toc-item { display: block; color: rgb(65, 131, 196); } .md-toc-item a { text-decoration: none; } .md-toc-inner:hover { text-decoration: underline; } .md-toc-inner { display: inline-block; cursor: pointer; } .md-toc-h1 .md-toc-inner { margin-left: 0px; font-weight: 700; } .md-toc-h2 .md-toc-inner { margin-left: 2em; } .md-toc-h3 .md-toc-inner { margin-left: 4em; } .md-toc-h4 .md-toc-inner { margin-left: 6em; } .md-toc-h5 .md-toc-inner { margin-left: 8em; } .md-toc-h6 .md-toc-inner { margin-left: 10em; } @media screen and (max-width: 48em) { .md-toc-h3 .md-toc-inner { margin-left: 3.5em; } .md-toc-h4 .md-toc-inner { margin-left: 5em; } .md-toc-h5 .md-toc-inner { margin-left: 6.5em; } .md-toc-h6 .md-toc-inner { margin-left: 8em; } } a.md-toc-inner { font-size: inherit; font-style: inherit; font-weight: inherit; line-height: inherit; } .footnote-line a:not(.reversefootnote) { color: inherit; } .reversefootnote { font-family: ui-monospace, sans-serif; } .md-attr { display: none; } .md-fn-count::after { content: "."; } code, pre, samp, tt { font-family: var(--monospace); } kbd { margin: 0px 0.1em; padding: 0.1em 0.6em; font-size: 0.8em; color: rgb(36, 39, 41); background: rgb(255, 255, 255); border: 1px solid rgb(173, 179, 185); border-radius: 3px; box-shadow: rgba(12, 13, 14, 0.2) 0px 1px 0px, rgb(255, 255, 255) 0px 0px 0px 2px inset; white-space: nowrap; vertical-align: middle; } .md-comment { color: rgb(162, 127, 3); opacity: 0.6; font-family: var(--monospace); } code { text-align: left; vertical-align: initial; } a.md-print-anchor { white-space: pre !important; border-width: initial !important; border-style: none !important; border-color: initial !important; display: inline-block !important; position: absolute !important; width: 1px !important; right: 0px !important; outline: 0px !important; background: 0px 0px !important; text-decoration: initial !important; text-shadow: initial !important; } .os-windows.monocolor-emoji .md-emoji { font-family: "Segoe UI Symbol", sans-serif; } .md-diagram-panel > svg { max-width: 100%; } [lang="flow"] svg, [lang="mermaid"] svg { max-width: 100%; height: auto; } [lang="mermaid"] .node text { font-size: 1rem; } table tr th { border-bottom: 0px; } video { max-width: 100%; display: block; margin: 0px auto; } iframe { max-width: 100%; width: 100%; border: none; } .highlight td, .highlight tr { border: 0px; } mark { background: rgb(255, 255, 0); color: rgb(0, 0, 0); } .md-html-inline .md-plain, .md-html-inline strong, mark .md-inline-math, mark strong { color: inherit; } .md-expand mark .md-meta { opacity: 0.3 !important; } mark .md-meta { color: rgb(0, 0, 0); } @media print { .typora-export h1, .typora-export h2, .typora-export h3, .typora-export h4, .typora-export h5, .typora-export h6 { break-inside: avoid; } } .md-diagram-panel .messageText { stroke: none !important; } .md-diagram-panel .start-state { fill: var(--node-fill); } .md-diagram-panel .edgeLabel rect { opacity: 1 !important; } .md-fences.md-fences-math { font-size: 1em; } .md-fences-advanced:not(.md-focus) { padding: 0px; white-space: nowrap; border: 0px; } .md-fences-advanced:not(.md-focus) { background: inherit; } .typora-export-show-outline .typora-export-content { max-width: 1440px; margin: auto; display: flex; flex-direction: row; } .typora-export-sidebar { width: 300px; font-size: 0.8rem; margin-top: 80px; margin-right: 18px; } .typora-export-show-outline #write { --webkit-flex:2; flex: 2 1 0%; } .typora-export-sidebar .outline-content { position: fixed; top: 0px; max-height: 100%; overflow: hidden auto; padding-bottom: 30px; padding-top: 60px; width: 300px; } @media screen and (max-width: 1024px) { .typora-export-sidebar, .typora-export-sidebar .outline-content { width: 240px; } } @media screen and (max-width: 800px) { .typora-export-sidebar { display: none; } } .outline-content li, .outline-content ul { margin-left: 0px; margin-right: 0px; padding-left: 0px; padding-right: 0px; list-style: none; } .outline-content ul { margin-top: 0px; margin-bottom: 0px; } .outline-content strong { font-weight: 400; } .outline-expander { width: 1rem; height: 1.42857rem; position: relative; display: table-cell; vertical-align: middle; cursor: pointer; padding-left: 4px; } .outline-expander::before { content: ""; position: relative; font-family: Ionicons; display: inline-block; font-size: 8px; vertical-align: middle; } .outline-item { padding-top: 3px; padding-bottom: 3px; cursor: pointer; } .outline-expander:hover::before { content: ""; } .outline-h1 > .outline-item { padding-left: 0px; } .outline-h2 > .outline-item { padding-left: 1em; } .outline-h3 > .outline-item { padding-left: 2em; } .outline-h4 > .outline-item { padding-left: 3em; } .outline-h5 > .outline-item { padding-left: 4em; } .outline-h6 > .outline-item { padding-left: 5em; } .outline-label { cursor: pointer; display: table-cell; vertical-align: middle; text-decoration: none; color: inherit; } .outline-label:hover { text-decoration: underline; } .outline-item:hover { border-color: rgb(245, 245, 245); background-color: var(--item-hover-bg-color); } .outline-item:hover { margin-left: -28px; margin-right: -28px; border-left: 28px solid transparent; border-right: 28px solid transparent; } .outline-item-single .outline-expander::before, .outline-item-single .outline-expander:hover::before { display: none; } .outline-item-open > .outline-item > .outline-expander::before { content: ""; } .outline-children { display: none; } .info-panel-tab-wrapper { display: none; } .outline-item-open > .outline-children { display: block; } .typora-export .outline-item { padding-top: 1px; padding-bottom: 1px; } .typora-export .outline-item:hover { margin-right: -8px; border-right: 8px solid transparent; } .typora-export .outline-expander::before { content: "+"; font-family: inherit; top: -1px; } .typora-export .outline-expander:hover::before, .typora-export .outline-item-open > .outline-item > .outline-expander::before { content: "−"; } .typora-export-collapse-outline .outline-children { display: none; } .typora-export-collapse-outline .outline-item-open > .outline-children, .typora-export-no-collapse-outline .outline-children { display: block; } .typora-export-no-collapse-outline .outline-expander::before { content: "" !important; } .typora-export-show-outline .outline-item-active > .outline-item .outline-label { font-weight: 700; } .md-inline-math-container mjx-container { zoom: 0.95; } .CodeMirror { height: auto; } .CodeMirror.cm-s-inner { background: inherit; } .CodeMirror-scroll { overflow: auto hidden; z-index: 3; } .CodeMirror-gutter-filler, .CodeMirror-scrollbar-filler { background-color: rgb(255, 255, 255); } .CodeMirror-gutters { border-right: 1px solid rgb(221, 221, 221); background: inherit; white-space: nowrap; } .CodeMirror-linenumber { padding: 0px 3px 0px 5px; text-align: right; color: rgb(153, 153, 153); } .cm-s-inner .cm-keyword { color: rgb(119, 0, 136); } .cm-s-inner .cm-atom, .cm-s-inner.cm-atom { color: rgb(34, 17, 153); } .cm-s-inner .cm-number { color: rgb(17, 102, 68); } .cm-s-inner .cm-def { color: rgb(0, 0, 255); } .cm-s-inner .cm-variable { color: rgb(0, 0, 0); } .cm-s-inner .cm-variable-2 { color: rgb(0, 85, 170); } .cm-s-inner .cm-variable-3 { color: rgb(0, 136, 85); } .cm-s-inner .cm-string { color: rgb(170, 17, 17); } .cm-s-inner .cm-property { color: rgb(0, 0, 0); } .cm-s-inner .cm-operator { color: rgb(152, 26, 26); } .cm-s-inner .cm-comment, .cm-s-inner.cm-comment { color: rgb(170, 85, 0); } .cm-s-inner .cm-string-2 { color: rgb(255, 85, 0); } .cm-s-inner .cm-meta { color: rgb(85, 85, 85); } .cm-s-inner .cm-qualifier { color: rgb(85, 85, 85); } .cm-s-inner .cm-builtin { color: rgb(51, 0, 170); } .cm-s-inner .cm-bracket { color: rgb(153, 153, 119); } .cm-s-inner .cm-tag { color: rgb(17, 119, 0); } .cm-s-inner .cm-attribute { color: rgb(0, 0, 204); } .cm-s-inner .cm-header, .cm-s-inner.cm-header { color: rgb(0, 0, 255); } .cm-s-inner .cm-quote, .cm-s-inner.cm-quote { color: rgb(0, 153, 0); } .cm-s-inner .cm-hr, .cm-s-inner.cm-hr { color: rgb(153, 153, 153); } .cm-s-inner .cm-link, .cm-s-inner.cm-link { color: rgb(0, 0, 204); } .cm-negative { color: rgb(221, 68, 68); } .cm-positive { color: rgb(34, 153, 34); } .cm-header, .cm-strong { font-weight: 700; } .cm-del { text-decoration: line-through; } .cm-em { font-style: italic; } .cm-link { text-decoration: underline; } .cm-error { color: red; } .cm-invalidchar { color: red; } .cm-constant { color: rgb(38, 139, 210); } .cm-defined { color: rgb(181, 137, 0); } div.CodeMirror span.CodeMirror-matchingbracket { color: rgb(0, 255, 0); } div.CodeMirror span.CodeMirror-nonmatchingbracket { color: rgb(255, 34, 34); } .cm-s-inner .CodeMirror-activeline-background { background: inherit; } .CodeMirror { position: relative; overflow: hidden; } .CodeMirror-scroll { height: 100%; outline: 0px; position: relative; box-sizing: content-box; background: inherit; } .CodeMirror-sizer { position: relative; } .CodeMirror-gutter-filler, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler, .CodeMirror-vscrollbar { position: absolute; z-index: 6; display: none; outline: 0px; } .CodeMirror-vscrollbar { right: 0px; top: 0px; overflow: hidden; } .CodeMirror-hscrollbar { bottom: 0px; left: 0px; overflow: auto hidden; } .CodeMirror-scrollbar-filler { right: 0px; bottom: 0px; } .CodeMirror-gutter-filler { left: 0px; bottom: 0px; } .CodeMirror-gutters { position: absolute; left: 0px; top: 0px; padding-bottom: 10px; z-index: 3; overflow-y: hidden; } .CodeMirror-gutter { white-space: normal; height: 100%; box-sizing: content-box; padding-bottom: 30px; margin-bottom: -32px; display: inline-block; } .CodeMirror-gutter-wrapper { position: absolute; z-index: 4; background: 0px 0px !important; border: none !important; } .CodeMirror-gutter-background { position: absolute; top: 0px; bottom: 0px; z-index: 4; } .CodeMirror-gutter-elt { position: absolute; cursor: default; z-index: 4; } .CodeMirror-lines { cursor: text; } .CodeMirror pre { border-radius: 0px; border-width: 0px; background: 0px 0px; font-family: inherit; font-size: inherit; margin: 0px; white-space: pre; overflow-wrap: normal; color: inherit; z-index: 2; position: relative; overflow: visible; } .CodeMirror-wrap pre { overflow-wrap: break-word; white-space: pre-wrap; word-break: normal; } .CodeMirror-code pre { border-right: 30px solid transparent; width: fit-content; } .CodeMirror-wrap .CodeMirror-code pre { border-right: none; width: auto; } .CodeMirror-linebackground { position: absolute; inset: 0px; z-index: 0; } .CodeMirror-linewidget { position: relative; z-index: 2; overflow: auto; } .CodeMirror-wrap .CodeMirror-scroll { overflow-x: hidden; } .CodeMirror-measure { position: absolute; width: 100%; height: 0px; overflow: hidden; visibility: hidden; } .CodeMirror-measure pre { position: static; } .CodeMirror div.CodeMirror-cursor { position: absolute; visibility: hidden; border-right: none; width: 0px; } .CodeMirror div.CodeMirror-cursor { visibility: hidden; } .CodeMirror-focused div.CodeMirror-cursor { visibility: inherit; } .cm-searching { background: rgba(255, 255, 0, 0.4); } span.cm-underlined { text-decoration: underline; } span.cm-strikethrough { text-decoration: line-through; } .cm-tw-syntaxerror { color: rgb(255, 255, 255); background-color: rgb(153, 0, 0); } .cm-tw-deleted { text-decoration: line-through; } .cm-tw-header5 { font-weight: 700; } .cm-tw-listitem:first-child { padding-left: 10px; } .cm-tw-box { border-style: solid; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-color: inherit; border-top-width: 0px !important; } .cm-tw-underline { text-decoration: underline; } @media print { .CodeMirror div.CodeMirror-cursor { visibility: hidden; } } :root { --side-bar-bg-color: #fafafa; --control-text-color: #777; } @include-when-export url(https://fonts.loli.net/css?family=Open+Sans:400italic,700italic,700,400&subset=latin,latin-ext); /* open-sans-regular - latin-ext_latin */ /* open-sans-italic - latin-ext_latin */ /* open-sans-700 - latin-ext_latin */ /* open-sans-700italic - latin-ext_latin */ html { font-size: 16px; -webkit-font-smoothing: antialiased; } body { font-family: "Open Sans","Clear Sans", "Helvetica Neue", Helvetica, Arial, 'Segoe UI Emoji', sans-serif; color: rgb(51, 51, 51); line-height: 1.6; } #write { max-width: 860px; margin: 0 auto; padding: 30px; padding-bottom: 100px; } @media only screen and (min-width: 1400px) { #write { max-width: 1024px; } } @media only screen and (min-width: 1800px) { #write { max-width: 1200px; } } #write > ul:first-child, #write > ol:first-child{ margin-top: 30px; } a { color: #4183C4; } h1, h2, h3, h4, h5, h6 { position: relative; margin-top: 1rem; margin-bottom: 1rem; font-weight: bold; line-height: 1.4; cursor: text; } h1:hover a.anchor, h2:hover a.anchor, h3:hover a.anchor, h4:hover a.anchor, h5:hover a.anchor, h6:hover a.anchor { text-decoration: none; } h1 tt, h1 code { font-size: inherit; } h2 tt, h2 code { font-size: inherit; } h3 tt, h3 code { font-size: inherit; } h4 tt, h4 code { font-size: inherit; } h5 tt, h5 code { font-size: inherit; } h6 tt, h6 code { font-size: inherit; } h1 { font-size: 2.25em; line-height: 1.2; border-bottom: 1px solid #eee; } h2 { font-size: 1.75em; line-height: 1.225; border-bottom: 1px solid #eee; } /*@media print { .typora-export h1, .typora-export h2 { border-bottom: none; padding-bottom: initial; } .typora-export h1::after, .typora-export h2::after { content: ""; display: block; height: 100px; margin-top: -96px; border-top: 1px solid #eee; } }*/ h3 { font-size: 1.5em; line-height: 1.43; } h4 { font-size: 1.25em; } h5 { font-size: 1em; } h6 { font-size: 1em; color: #777; } p, blockquote, ul, ol, dl, table{ margin: 0.8em 0; } li>ol, li>ul { margin: 0 0; } hr { height: 2px; padding: 0; margin: 16px 0; background-color: #e7e7e7; border: 0 none; overflow: hidden; box-sizing: content-box; } li p.first { display: inline-block; } ul, ol { padding-left: 30px; } ul:first-child, ol:first-child { margin-top: 0; } ul:last-child, ol:last-child { margin-bottom: 0; } blockquote { border-left: 4px solid #dfe2e5; padding: 0 15px; color: #777777; } blockquote blockquote { padding-right: 0; } table { padding: 0; word-break: initial; } table tr { border: 1px solid #dfe2e5; margin: 0; padding: 0; } table tr:nth-child(2n), thead { background-color: #f8f8f8; } table th { font-weight: bold; border: 1px solid #dfe2e5; border-bottom: 0; margin: 0; padding: 6px 13px; } table td { border: 1px solid #dfe2e5; margin: 0; padding: 6px 13px; } table th:first-child, table td:first-child { margin-top: 0; } table th:last-child, table td:last-child { margin-bottom: 0; } .CodeMirror-lines { padding-left: 4px; } .code-tooltip { box-shadow: 0 1px 1px 0 rgba(0,28,36,.3); border-top: 1px solid #eef2f2; } .md-fences, code, tt { border: 1px solid #e7eaed; background-color: #f8f8f8; border-radius: 3px; padding: 0; padding: 2px 4px 0px 4px; font-size: 0.9em; } code { background-color: #f3f4f4; padding: 0 2px 0 2px; } .md-fences { margin-bottom: 15px; margin-top: 15px; padding-top: 8px; padding-bottom: 6px; } .md-task-list-item > input { margin-left: -1.3em; } @media print { html { font-size: 13px; } pre { page-break-inside: avoid; word-wrap: break-word; } } .md-fences { background-color: #f8f8f8; } #write pre.md-meta-block { padding: 1rem; font-size: 85%; line-height: 1.45; background-color: #f7f7f7; border: 0; border-radius: 3px; color: #777777; margin-top: 0 !important; } .mathjax-block>.code-tooltip { bottom: .375rem; } .md-mathjax-midline { background: #fafafa; } #write>h3.md-focus:before{ left: -1.5625rem; top: .375rem; } #write>h4.md-focus:before{ left: -1.5625rem; top: .285714286rem; } #write>h5.md-focus:before{ left: -1.5625rem; top: .285714286rem; } #write>h6.md-focus:before{ left: -1.5625rem; top: .285714286rem; } .md-image>.md-meta { /*border: 1px solid #ddd;*/ border-radius: 3px; padding: 2px 0px 0px 4px; font-size: 0.9em; color: inherit; } .md-tag { color: #a7a7a7; opacity: 1; } .md-toc { margin-top:20px; padding-bottom:20px; } .sidebar-tabs { border-bottom: none; } #typora-quick-open { border: 1px solid #ddd; background-color: #f8f8f8; } #typora-quick-open-item { background-color: #FAFAFA; border-color: #FEFEFE #e5e5e5 #e5e5e5 #eee; border-style: solid; border-width: 1px; } /** focus mode */ .on-focus-mode blockquote { border-left-color: rgba(85, 85, 85, 0.12); } header, .context-menu, .megamenu-content, footer{ font-family: "Segoe UI", "Arial", sans-serif; } .file-node-content:hover .file-node-icon, .file-node-content:hover .file-node-open-state{ visibility: visible; } .mac-seamless-mode #typora-sidebar { background-color: #fafafa; background-color: var(--side-bar-bg-color); } .md-lang { color: #b4654d; } /*.html-for-mac { --item-hover-bg-color: #E6F0FE; }*/ #md-notification .btn { border: 0; } .dropdown-menu .divider { border-color: #e5e5e5; opacity: 0.4; } .ty-preferences .window-content { background-color: #fafafa; } .ty-preferences .nav-group-item.active { color: white; background: #999; } .menu-item-container a.menu-style-btn { background-color: #f5f8fa; background-image: linear-gradient( 180deg , hsla(0, 0%, 100%, 0.8), hsla(0, 0%, 100%, 0)); } mjx-container[jax="SVG"] { direction: ltr; } mjx-container[jax="SVG"] > svg { overflow: visible; min-height: 1px; min-width: 1px; } mjx-container[jax="SVG"] > svg a { fill: blue; stroke: blue; } mjx-assistive-mml { position: absolute !important; top: 0px; left: 0px; clip: rect(1px, 1px, 1px, 1px); padding: 1px 0px 0px 0px !important; border: 0px !important; display: block !important; width: auto !important; overflow: hidden !important; -webkit-touch-callout: none; -webkit-user-select: none; -khtml-user-select: none; -moz-user-select: none; -ms-user-select: none; user-select: none; } mjx-assistive-mml[display="block"] { width: 100% !important; } mjx-container[jax="SVG"][display="true"] { display: block; text-align: center; margin: 1em 0; } mjx-container[jax="SVG"][display="true"][width="full"] { display: flex; } mjx-container[jax="SVG"][justify="left"] { text-align: left; } mjx-container[jax="SVG"][justify="right"] { text-align: right; } g[data-mml-node="merror"] > g { fill: red; stroke: red; } g[data-mml-node="merror"] > rect[data-background] { fill: yellow; stroke: none; } g[data-mml-node="mtable"] > line[data-line], svg[data-table] > g > line[data-line] { stroke-width: 70px; fill: none; } g[data-mml-node="mtable"] > rect[data-frame], svg[data-table] > g > rect[data-frame] { stroke-width: 70px; fill: none; } g[data-mml-node="mtable"] > .mjx-dashed, svg[data-table] > g > .mjx-dashed { stroke-dasharray: 140; } g[data-mml-node="mtable"] > .mjx-dotted, svg[data-table] > g > .mjx-dotted { stroke-linecap: round; stroke-dasharray: 0,140; } g[data-mml-node="mtable"] > g > svg { overflow: visible; } [jax="SVG"] mjx-tool { display: inline-block; position: relative; width: 0; height: 0; } [jax="SVG"] mjx-tool > mjx-tip { position: absolute; top: 0; left: 0; } mjx-tool > mjx-tip { display: inline-block; padding: .2em; border: 1px solid #888; font-size: 70%; background-color: #F8F8F8; color: black; box-shadow: 2px 2px 5px #AAAAAA; } g[data-mml-node="maction"][data-toggle] { cursor: pointer; } mjx-status { display: block; position: fixed; left: 1em; bottom: 1em; min-width: 25%; padding: .2em .4em; border: 1px solid #888; font-size: 90%; background-color: #F8F8F8; color: black; } foreignObject[data-mjx-xml] { font-family: initial; line-height: normal; overflow: visible; } mjx-container[jax="SVG"] path[data-c], mjx-container[jax="SVG"] use[data-c] { stroke-width: 3; } g[data-mml-node="xypic"] path { stroke-width: inherit; } .MathJax g[data-mml-node="xypic"] path { stroke-width: inherit; } mjx-container[jax="SVG"] path[data-c], mjx-container[jax="SVG"] use[data-c] { stroke-width: 0; } 线性回归实验 线性回归回归问题是非常常见的一类问题，目的是寻找变量之间的关系。比如要从数据中寻找房屋面积与价格的关系，年龄和身高的关系，气体压力和体积的关系等等。而机器学习要做的正是要让机器自己来学习这些关系，并为对未知的情况做出预测。对于线性回归，假设变量之间的关系是线性的，即： hθ(x)=θ0+θ1xh_{\theta}(x)= \theta_{0} + \theta_{1} x 其中 θθ\pmb{\theta} 就是学习算法需要学习的参数，在线性回归的问题上，就是θ1\theta_{1}和θ0\theta_{0}，而 xx 是我们对于问题所选取的特征，也即输入。hh表示算法得到的映射。 代价函数的表示为了找到这个算法中合适的参数，我们需要制定一个标准。一般而言算法拟合出来的结果与真实的结果误差越小越好，试想一下如果算法拟合出来的结果与真实值的误差为零，那么就是说算法完美地拟合了数据。所以可以根据“真实值与算法拟合值的误差”来表示算法的“合适程度”。在线性回归中，我们经常使用最小二乘的思路构建代价函数： J(θθ)=12n∑i=1n(hθ(x(i))−y(i))2J(\pmb{\theta}) = \frac{1}{2n}\sum_{i=1}^{n} \Big( h_{\theta}(x^{(i)}) - y^{(i)} \Big)^2 这里 hθ(x(i))h_{\theta}(x^{(i)}) 由假设模型得出。对线性回归任务，代价函数可以展开为： J(θθ)=12n∑i=1n(θ0+θ1x(i)−y(i))2J(\pmb{\theta}) = \frac{1}{2n} \sum_{i=1}^{n} \Big( \theta_0 + \theta_1 x^{(i)} - y^{(i)} \Big)^2 误差函数的值越小，则代表算法拟合结果与真实结果越接近。 梯度下降梯度下降算法沿着误差函数的反向更新θ\theta的值，知道代价函数收敛到最小值。梯度下降算法更新θi\theta_i的方法为： θi=θi−α∂∂θiJ(θθ)\theta_i = \theta_i - \alpha\frac{\partial }{\partial \theta_i}J(\pmb{\theta})其中 α\alpha表示学习率。对于线性回归的的参数，可以根据代价函数求出其参数更新公式： ∂J∂θ0=1n∑i=1n(hθ(x(i))−y(i))⋅1,\frac{\partial J}{\partial \theta_{0} } = \frac{1}{n} \sum_{i=1}^{n} \Big( h_{\theta}(x^{(i)}) - y^{(i)} \Big) \cdot 1, ∂J∂θ1=1n∑i=1n(hθ(x(i))−y(i))⋅x(i). \frac{\partial J}{\partial \theta_{1} } = \frac{1}{n} \sum_{i=1}^{n} \Big( h_{\theta}(x^{(i)}) - y^{(i)} \Big) \cdot x^{(i)}. 代码实现现在让我们开始动手实现，首先让我们回顾一下numpy和matplotlib：xxxxxxxxxximport numpy as npimport matplotlib.pyplot as plt def warm_up_exercise():    A = None    A = np.eye(5,5)    return A # 当你的实现正确时，下面会输出一个单位矩阵：print(warm_up_exercise())运行时长: 403毫秒结束时间: 2022-09-21 09:37:05[[1. 0. 0. 0. 0.] [0. 1. 0. 0. 0.] [0. 0. 1. 0. 0.] [0. 0. 0. 1. 0.] [0. 0. 0. 0. 1.]] 你需要实现绘制数据集中图像的函数，当你的实现|正确时，你应该会得到如下的图像： def plot_data(x, y):    """绘制给定数据x与y的图像"""    plt.figure()    # ====================== 你的代码 ==========================    # 绘制x与y的图像    # 使用 matplotlib.pyplt 的命令 plot, xlabel, ylabel 等。    # 提示：可以使用 'rx' 选项使数据点显示为红色的 "x"，    #       使用 "markersize=8, markeredgewidth=2" 使标记更大    # 给制数据    # 设置y轴标题为 'Profit in $10,000s'        # 设置x轴标题为 'Population of City in 10,000s'        # =========================================================    plt.xlabel("Population of City in 10,000s")    plt.ylabel("Profit in $10,000s")    # 数据载入，由","分割，且按列解包    # numpy.loadtxt参见https://numpy.org/doc/stable/reference/generated/numpy.loadtxt.html    x, y = np.loadtxt("data/data5984/PRML_LR_data.txt", delimiter=',', unpack=True)    # 横纵坐标标签    plt.xlabel("Population of City in 10,000s")    plt.ylabel("Profit in $10,000s")    # matplotlib.pyplot.plot 参见 https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html    # 加入 "markersize=8, markeredgewidth=2" 使标记更大    plt.plot(x, y, "rx", markersize = 8, markeredgewidth = 2)    # 让我们测试一下你的实现是否正确# 从txt中加载数据print('Plotting Data ...\n')data = np.loadtxt('./data/data5984/PRML_LR_data.txt', delimiter=',')x, y = data[:, 0], data[:, 1] # 绘图plot_data(x, y)plt.show()运行时长: 190毫秒结束时间: 2022-09-21 09:49:45 现在运用所学的知识，对上述数据利用线性回归进行拟合。首先我们对要学习的参数和数据做一个准备:# Add a column of ones to xm = len(y)X = np.ones((m, 2))X[:, 1] = data[:, 0] # initialize fitting parameterstheta = np.zeros((2, 1)) # Some gradient descent settingsiterations = 1500alpha = 0.01计算初始误差函数的值，你需要实现误差函数的计算：def compute_cost(X, y, theta):    """计算线性回归的代价。"""    J = 0.0    # ====================== 你的代码 ==========================    # 计算给定 theta 参数下线性回归的代价    # 请将正确的代价赋值给 J    # predictions = np.dot(X, theta)    # sqrErrors = np.multiply((predictions - y), (predictions - y))    # J = np.sum(sqrErrors) / (2 * m)    # J /= m    J = 1/(2*m) * sum((y - (theta[1] * X[:,1] + theta[0])) **2)    # =========================================================    return J # compute and display initial cost# Expected value 32.07J0 = compute_cost(X, y, theta)print(J0)  现在你验证了代价计算的正确性，接下来就需要实现最核心的部分：梯度下降。在实现这一部分之前，确定你理解了上述各种变量及其表示。你需要完成梯度下降的核心代码部分：def gradient_descent(X, y, theta, alpha, num_iters):    """执行梯度下降算法来学习参数 theta。"""    m = len(y)    J_history = np.zeros((num_iters,))    theta_history = np.zeros((2, iterations))    for iter in range(num_iters):        # ====================== 你的代码 ==========================        # 计算给定 theta 参数下线性回归的梯度，实现梯度下降算法        # =========================================================        # 将各次迭代后的代价进行记录        # print(X.shape)        # print(theta.shape)        # print(np.dot(X, theta).shape)        # print(y.shape)        # print(np.dot((np.dot(X, theta).T - y), X).T.shape)        theta -= (alpha / m) * np.dot((np.dot(X, theta).T - y), X).T        J_history[iter] = compute_cost(X, y, theta)        theta_history[0, iter] = theta[0]        theta_history[1, iter] = theta[1]    return theta, J_history, theta_history # run gradient descent# Expected value: theta = [-3.630291, 1.166362]theta, J_history, theta_history = gradient_descent(X, y, theta,                                    alpha, iterations)print(theta)print(J_history.shape)print(theta_history.shape)plt.figure()plt.plot(range(iterations),J_history)plt.xlabel("iterations")plt.ylabel(r'$J(\theta)$')plt.show()为了验证梯度下降方法实现的正确性，你需要把学习的到的直线绘制出来，确定你的实现是否正确。前面你已经绘制了数据集中的点，现在你需要在点的基础上绘制一条直线，如果你的实现正确，那么得到的图像应该是如下这样： 现在你已经正确实现了线性回归，你可能会对误差函数的优化过程比较好奇。为了更好地理解这个过程，你可以将损失函数的图像绘制出来。为此你需要将需要优化的参数的各个取值时误差函数的取值在图像上绘制出来，以下代码需要你进行填写。def plot_visualize_cost(X, y, theta_best):    """可视化代价函数"""    # 生成参数网格    theta0_vals = np.linspace(-10, 10, 101)    theta1_vals = np.linspace(-1, 4, 101)    t = np.zeros((2, 1))    J_vals = np.zeros((101, 101))    for i in range(101):        for j in range(101):            # =============== 你的代码 ===================            # 加入代码，计算 J_vals 的值            J_vals[i][j] = compute_cost(X,y,[theta0_vals[i],theta1_vals[j]])            # ===========================================    plt.figure()    plt.contour(theta0_vals, theta1_vals, J_vals,                levels=np.logspace(-2, 3, 21))    plt.plot(theta_best[0], theta_best[1], 'rx',             markersize=8, markeredgewidth=2)    plt.xlabel(r'$\theta_0$')    plt.ylabel(r'$\theta_1$')    plt.title(r'$J(\theta)$')   plot_visualize_cost(X, y, theta)plt.show() 在梯度更新时，我们保留了代价的历史信息。在参数的学习过程中，代价函数的变化过程你也可以作一个图来查看。观察最后得到的J(θ)J(\theta)的图像以及代价的变化过程，可以加深你的理解。在梯度下降的迭代中，我们设置终止条件为完成了固定的迭代次数，但是在迭代次数完成时，由于学习率等参数的设置，可能得到的参数并不是使得代价最低的值。你可以通过观察代价函数的变化过程，想办法调整学习率等参数或者改进程序，使得参数的取值为搜索到的最优结果。请利用历史信息，改造plot_visual_cost函数，在等高线图上绘制线性回归模型的优化迭代过程。def plot_visual_history(X, y, theta_histroy):    """可视化线性回归模型迭代优化过程"""    plt.figure()    # =============== 你的代码 ===================    # 生成参数网格    theta0_vals = np.linspace(-10, 10, 101)    theta1_vals = np.linspace(-1, 4, 101)    t = np.zeros((2, 1))    J_vals = np.zeros((101, 101))    for i in range(101):        for j in range(101):            J_vals[i][j] = compute_cost(X,y,[theta0_vals[i],theta1_vals[j]])    plt.figure()    plt.contour(theta0_vals, theta1_vals, J_vals,                levels=np.logspace(-2, 3, 21))    for i in range(0, iterations, 100):        plt.plot(theta_history[0, i], theta_history[1, i],  'rx',             markersize=8, markeredgewidth=1)    # ===========================================    plt.xlabel(r'$\theta_0$')    plt.ylabel(r'$\theta_1$')    plt.title(r'$J(\theta)$')   plot_visual_history(X, y, theta_history)plt.show()进阶在实现中，你可能采取了像上面公式中给出的结果一样逐个样本计算代价函数，或者在梯度下降的更新时也采用了逐个样本计算的方式。但事实上，你可以采用numpy的矩阵函数一次性计算所有样本的代价函数。可以采用矩阵乘法(np.matmul())求和等方式（np.sum（））。利用你学到的线性代数知识，将其实现更改一下吧。

Chapter 07 OOP初级 part3 本章练习以下代码均已编译通过public class Homework01 { public static void main(String[] args) { double[] arr = {2.45, 45.4, -4324.4, 434.7, 2.76}; A01 m = new A01(); Double ret = m.max(arr); if(ret != null){ System.out.println("最大值为："+ret); }else{ System.out.println("Wrong input!"); } } } //完成基本功能后，再考虑健壮性 class A01{ // 包装类 Double public Double max(double[] arr){ // 先判不为空，再判长度大于零 if(arr != null && arr.length > 0){ double max = arr[0]; // 假定第一个数就是最大 for (int i = 1; i < arr.length; i++) { if(arr[i] > max){ max = arr[i]; } } return max; }else{ return null; } } } public class Homework02 { public static void main(String[] args) { A02 p = new A02(); String[] arr = {"Tim", "Jack", "Mary"}; System.out.println(p.find(arr, "Jack")); System.out.println(p.find(arr, "Java")); } } class A02 { public int find(String[] arr, String partten){ if(arr != null && arr.length > 0){ for(int i = 0; i < arr.length; i++){ if(partten.equals(arr[i])){ return i; } } } return -1; } } public class Homework03 { public static void main(String[] args) { Book b1 = new Book("三体", 120.99); b1.info(); b1.updatePrice(); b1.info(); } } class Book { String name; double price; public Book(String name, double price){ this.name = name; this.price = price; } public void updatePrice(){ if(this.price > 150){ this.price = 150; }else if(this.price > 100){ this.price = 100; } } public void info(){ System.out.println(this.name + "的价格为：" + this.price); } } public class Homework04 { public static void main(String[] args) { int[] arr = {1, 4, 6, 2, 3}; A03 a = new A03(); int[] newArr = a.copyArr(arr); for (int i = 0; i < newArr.length; i++) { System.out.print(newArr[i] + "\t"); } } } class A03 { public int[] copyArr(int[] oldArr){ // 在堆中创建一个长度为 oldArr.length 的数组 int[] newArr = new int[oldArr.length]; for(int i = 0; i < oldArr.length; i++){ newArr[i] = oldArr[i]; } return newArr; } } public class Homework05 { public static void main(String[] args) { Circle circle = new Circle(3); System.out.printf("周长为：%.2f\n", circle.perimeter()); System.out.printf("面积为：%.2f", circle.area()); } } class Circle { double radius; public Circle(double radius){ this.radius = radius; } // 周长 public double perimeter(){ return 2.0 * this.radius * Math.PI; } // 面积 public double area(){ return Math.PI * this.radius * this.radius; } } public class Homework06 { public static void main(String[] args) { Cale cale = new Cale(20, 4); System.out.println(cale.add()); System.out.println(cale.sub()); System.out.println(cale.mul()); if(cale.div() != null){ System.out.println(cale.div()); } Cale cale1 = new Cale(20, 0); if(cale1.div() != null){ System.out.println(cale1.div()); } } } class Cale { double op1, op2; public Cale(double op1, double op2){ this.op1 = op1; this.op2 = op2; } double add(){ return op1 + op2; } double sub(){ return op1 - op2; } double mul(){ return op1 * op2; } Double div(){ if(op2 == 0){ System.out.println("除数不能为零"); return null; }else{ return op1 / op2; } } } public class Homework07 { public static void main(String[] args) { Dog dog = new Dog("大黄", "White", 4); dog.show(); } } class Dog { String name; String color; int age; public Dog(String name, String color, int age){ this.name = name; this.color = color; this.age = age; } public void show(){ System.out.println("名字=" + this.name + " 颜色=" + this.color+ " 年龄=" + this.age); } } public class Homework07 { public static void main(String[] args) { Dog dog = new Dog("大黄", "White", 4); dog.show(); } } class Dog { String name; String color; int age; public Dog(String name, String color, int age){ this.name = name; this.color = color; this.age = age; } public void show(){ System.out.println("名字=" + this.name + " 颜色=" + this.color+ " 年龄=" + this.age); } } 9.略10.输出为：i=101j=100101101public double method(double n1, double n2){...}public class Homework12 { public static void main(String[] args) { Emploee emploee = new Emploee("Tim", "male", 20); System.out.println(emploee.name + "\t" + emploee.gender + "\t" + emploee.age); } } class Emploee { String name; String gender; int age; String position; int salary; public Emploee(String position, int salary){ this.position = position; this.salary = salary; } public Emploee(String name, String gender, int age){ this.name = name; this.gender = gender; this.age = age; } public Emploee(String name, String gender, int age, String position, int salary) { this(name, gender, age); // 复用第二个构造器，注意不能同时复用前两个 this.position = position; this.salary = salary; } } public class Homework13 { public static void main(String[] args) { new PassObject().printAreas(5); } } class Circle { double radius; public Circle(double radius){ this.radius = radius; } public double findArea(){ return radius * radius * Math.PI; } } class PassObject { public void printAreas(int times){ System.out.println("Radius" + "\t" + "Area"); for(double i = 1.0; i <= times; i++){ System.out.print(i + "\t"); System.out.print(new Circle(i).findArea()); System.out.println(); } } } import java.util.Random; import java.util.Scanner; import javax.lang.model.util.ElementScanner6; public class Homework14 { public static void main(String[] args) { // 创建扫描器接收数据 Scanner scanner = new Scanner(System.in); Tom tom = new Tom(); System.out.println("输入你想玩的局数:"); int countTotal = scanner.nextInt(); // 循环 countToatal 次 for(int i = 1; i <= countTotal; i++){ System.out.println("请出拳: 0-拳头 1-石头 2-剪刀 "); tom.tomGuessNum = scanner.nextInt(); tom.setTomGuessNum(tom.tomGuessNum); tom.comGuessNum = tom.computerNum(); String outcome = tom.vsComputer(); tom.winCountNum = tom.winCount(outcome); tom.showInfo(i, outcome); } System.out.println("你总共赢了：" + tom.winCountNum + "局"); scanner.close(); } } class Tom{ int tomGuessNum; int comGuessNum; int winCountNum; // 显示当前局信息 public void showInfo(int count, String outcome){ System.out.println("=================================================================="); System.out.println("当前局数\t你的出拳\t电脑出拳\t结果"); System.out.println(count + "\t\t" + tomGuessNum + "\t\t" + comGuessNum + "\t\t" + outcome); System.out.println("=================================================================="); } public int computerNum(){ Random r = new Random(); return r.nextInt(3); // 0-2的随机数 } public void setTomGuessNum(int tomGuessNum){ if(tomGuessNum > 2 || tomGuessNum < 0){ throw new IllegalArgumentException("输入有误"); } this.tomGuessNum = tomGuessNum; } public int getTomGuessNum(){ return tomGuessNum; } public String vsComputer(){ if(tomGuessNum == 0 && comGuessNum ==1 || tomGuessNum ==1 && comGuessNum == 2 || tomGuessNum == 2 && comGuessNum == 0){ return "你赢了"; }else if(tomGuessNum == comGuessNum){ return "平局"; }else{ return "你输了"; } } public int winCount(String s){ if(s.equals("你赢了")){ winCountNum++; } return winCountNum; } }