protect，接口、lambda

访问父类的private域、访问父类的构造函数

父类

package v1ch05.inheritance;

import java.time.*;

public class Employee
{
   private String name;
   private double salary;
   private LocalDate hireDay;

   public Employee(String name, double salary, int year, int month, int day)
   {
      this.name = name;
      this.salary = salary;
      hireDay = LocalDate.of(year, month, day);
   }

   public String getName()
   {
      return name;
   }

   public double getSalary()
   {
      return salary;
   }

   public LocalDate getHireDay()
   {
      return hireDay;
   }

   public void raiseSalary(double byPercent)
   {
      double raise = salary * byPercent / 100;
      salary += raise;
   }
}

子类

package v1ch05.inheritance;

public class Manager extends Employee
{
   private double bonus;

   /**
    * @param name the employee's name
    * @param salary the salary
    * @param year the hire year
    * @param month the hire month
    * @param day the hire day
    */
   public Manager(String name, double salary, int year, int month, int day)
   {
   //使用super 调用构造器的语句必须是子类构造器的第一条语句
      super(name, salary, year, month, day);
      bonus = 0;
   }

   public double getSalary()
   {
      double baseSalary = super.getSalary();//访问父类的私有域
      return baseSalary + bonus;
   }

   public void setBonus(double b)
   {
      bonus = b;
   }
}

测试类|多态，动态绑定看对象

通俗理解就是，子类是一种父类，所以用父类的引用可以指向子类。
但是动态绑定，只能处理子类和父类共有的方法。
不能是
父类 a=子类对象;
a.子类的特有方法;

package v1ch05.inheritance;

/**
 * This program demonstrates inheritance.
 * @version 1.21 2004-02-21
 * @author Cay Horstmann
 */
public class ManagerTest
{
   public static void main(String[] args)
   {
      // construct a Manager object
      Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
      boss.setBonus(5000);

      Employee[] staff = new Employee[3];

      // fill the staff array with Manager and Employee objects

      staff[0] = boss;//多态，动态绑定看对象
      staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
      staff[2] = new Employee("Tommy Tester", 40000, 1990, 3, 15);

      // print out information about all Employee objects
      for (Employee e : staff)
         System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());
   }
}

静态绑定

private 方法|static 方法|final 方法|构造器：静态绑定（ static binding )

在将超类转换成子类之前，应该使用 instanceof进行检查

protect

子类就可以访问父类的protect域。

equals

Object 类中的 equals 方法用于检测一个对象是否等于另外一个对象。在 Object 类中，这个方法将判断两个对象是否具有相同的引用。

如果重新定义 equals方法，就必须重新定义 hashCode 方法， 以便用户可以将对象插人到散列表中。

动态数组

ArrayList

第六章 接口、lambda

接口

接口是要求，可以被扩展（继承）。

有些方法有效的前提是，传递的对象实现了要求的接口。

接口中，所有方法是public
字段都是public static final

接口和抽象类的区别？

java接口类似c++的多重继承，但语法简单。

默认方法的作用

浅拷贝和深拷贝

浅拷贝不拷贝对象指向的资源。

深拷贝的实现：

实现implements Cloneable接口
重写clone方法

函数式接口

就是函数类型，
lambda表达式

方法引用

有时可以转换为lambda

总结：lambda和方法引用，函数式接口

lambda和方法引用都不能独立存在，要转化为函数式接口的实例。

构造器引用

new