你的程序造型有点扁平啊，多态性也不行，杂乱无章，类之间的继承毫无造型上的美感……

import java.util.Random;

public class Main {
   public static void main(String[] args) {
       StringPrinter mySP = new StringPrinter();
       mySP.append("Hello");
       mySP.append(" there");
       mySP.print();

       Figure fig = new Figure(3,3);
       Rectangle rect = new Rectangle(10,6);
       System.out.println("Area is "+fig.area());
       System.out.println("Area is "+rect.area());

       //Lambda表达式的写法
       System.out.println("Lambda表达式写法");
       new Random().ints(3)
               .map(i->Math.abs(i))
               .forEach(i->System.out.println(i));
       //::方法引用
       System.out.println("::方法引用");
       new Random().ints(3)
               .map(Math::abs)
               .forEach(System.out::println);

       Art art = new Cartoon();//发生一个构造函数的链式反应。

       Employee emp1 = new Employee("lala",222333);
       Employee emp2 = new Employee();
       System.out.println("emp1's ID: "+emp1.id);
       System.out.println("emp2's ID: "+emp2.id);
   }
}

class StringWrapper{
   String s = new String("");
   public void append(String a) {s += a;}
}

class StringPrinter extends StringWrapper{
   public void print(){
       System.out.println("s="+s);
   }
}//给StringWrapper增加了一个新的print方法，extends的含义很明显，给原来的类写拓展。

class Figure{
   double dim1;
   double dim2;
   Figure(double a, double b){
       dim1=a;
       dim2=b;
   }
   Double area(){
       System.out.println("Area for figure");
       return(dim1*dim2);
   }
}

class Rectangle extends Figure{
   Rectangle(double a, double b){
       super(a,b);
   }
   Double area(){
       System.out.println("Area for rectangle");
       return(dim1*dim2);
   }
}

class Art{
   public Art(){
       System.out.println("Art constructor");
   }
}

class Drawing extends Art{
   public Drawing(){
       System.out.println("Drawing constructor");
   }
}

class Cartoon extends Drawing{
   public Cartoon(){
       System.out.println("Cartoon constructor");
   }
}

class Employee{
   public Employee(String n, double s){
       name = n;
       salary=s;
   }

   public Employee(){
       name = "";
       salary = 0;
   }

   //对象初始化块
   {
       id = nextid;
       nextid++;
   }
   private String name;
   private double salary;
   public int id;
   private static int nextid=888;//静态static的任何东西，只在虚拟机被装载的最开始初始化一遍（优先程度很高）。之后，一直调用同一个东西。
}

D:\SoftwareSet\Java\JDK19\jdk-19.0.2\bin\java.exe -javaagent:C:\Users\guhz\AppData\Local\JetBrains\IdeaIC2022.3\testAgent\intellij-coverage-agent-1.0.682.jar=C:\Users\guhz\AppData\Local\Temp\coverageargs -Didea.new.sampling.coverage=true -Dcoverage.ignore.private.constructor.util.class=true "-javaagent:D:\SoftwareSet\Java\javaIDE(jetbrains)\installPath\IntelliJ IDEA Community Edition 2022.3.2\lib\idea_rt.jar=13836:D:\SoftwareSet\Java\javaIDE(jetbrains)\installPath\IntelliJ IDEA Community Edition 2022.3.2\bin" -Dfile.encoding=UTF-8 -Dsun.stdout.encoding=UTF-8 -Dsun.stderr.encoding=UTF-8 -classpath D:\AllData\mess\2023_Java_lecture\上课抄代码\2023年3月23日\untitled\out\production\untitled Main

---- IntelliJ IDEA coverage runner ---- 

sampling ...

include patterns:

exclude annotations patterns:

.*Generated.*

s=Hello there

Area for figure

Area is 9.0

Area for rectangle

Area is 60.0

Lambda表达式写法

2001558292

1937687782

528340522

::方法引用

805472154

10093593

911256880

Art constructor

Drawing constructor

Cartoon constructor

emp1's ID: 888

emp2's ID: 889

Class transformation time: 0.0140461s for 125 classes or 1.1236880000000001E-4s per class

Process finished with exit code 0

笔记部分

/*
Java不支持多重继承，但是它支持接口。接口使得Java获得了多重继承的优点，且摒弃了相应的缺点。
Java只支持继承一个父类（单继承）。
接口：implements 接口名称列表。

立体化编程，分层，子类和父类，部分和整体。扁平化的编程意思是，把所有的功能平铺开来，没有很好地被归类。
Object类，Java中所有类的根。所有类都是Object类的子类。
Runtime类，Java程序的运行环境。可以访问运行环境的比如内存，垃圾回收，处理器。

方法继承、覆盖与重载
Inheritance（继承父类的方法）
Overriding（子类定义同名方法覆盖父类的方法，多态技术的一个实现。）

在子类中覆写父类的方法，会影响父类的对象。子类中添加同名的字段（变量名），会直接替换父类的字段，产生影响。

方法覆盖的情形：
1 父类要求子类写（抽象类）；
2 方法不适合子类，需要重写。

方法重载(overloading)：
相同函数名，但是输入参数不同，那么被判定为方法重载。

Java 8允许使用“::”关键字访问类的构造方法、对象方法、静态方法。
方法调用栈（应用情形，递归Recursion）
before看到return or last line or throw error->堆栈
after that, 弹出栈。

控制符和修饰符(比如public static final)
访问控制符：public, defaut(无关键字), protected, private.
设定了客户端程序员可以使用和不可以使用的界限。public class是公共访问，protected是保护访问。private protected是私有保护访问。private是私有访问。
defaut的类，则具有缺省的访问控制特性。只能被同一个包的类访问调用，而不能被其他包使用。

类的修饰符：abstract, final
abstract: 在定义抽象类，接口的时候大量使用。

用private修饰的属性或方法不能被继承。是父类私有的。

构造函数（构造方法）->完成类的初始化的函数，返回自身。
比如new的时候，调用了一个构造函数。

很多时候，我们在写类的时候，有的时候并没有定义构造函数，这个时候系统会自动为它生成一个默认的构造函数。这个构造函数与类的名称相同，但是不完成任何操作。
构造函数只运行一次。
翻译问题，构造函数也称为构造器。
1 要避免在类的构造器中初始化其他类；
2 避免在构造器中对静态变量赋值；
3 不要在构造器中创建类的实例；
4 访问权限修饰符对构造方法的重载不影响。

初始化块（代码块）首先被执行，然后构造函数的主体部分被执行。初始化块是构造器的补充。
静态初始化块，使用static定义。这种块只在虚拟机装载的时候被运行一次，之后沿用第一遍运行的成果。

多态性(Polymorphism)->简单工厂模式。多态提高了程序的可扩充性。
构造出来的类的对象，可以关联到其他类的方法(excute)，这些类可被关联的条件是，这些类有继承关系。

上溯造型(Upcasting)和下溯造型(Downcasting)
上溯：派生类到基类的上传总是安全的，因为只是把一个具体类型转换为更加一般的类型。具体所包含的东西往往更加具体，是一般所不具有的。
下溯：把新写的代码继承过来，实现多态地扩充功能。

比如，Vehicle 底下有 Car 和 Truck，要给Car补充功能的时候，遵循上一级传递的原则，把Vehicle传递出去，给Vehicle写新的功能，这样Car和Truck就都可以用了。这是一个多态性的基本思想。

*/