java核心技术卷-读书笔记(一)

继承

• 定义子类
  extends关键字

public class Manager extends Employee
{
}

• 覆盖方法

public class Manager extneds Employee
{
           public double getSalary()
           {
                   return salary + bonus;//wont work
           }
}
不能运行，manager类的getSalary方法不能直接访问超类的私有域，
，也就是说 ：尽管每个manager对象拥有一个salary的域。
但在manager类的getsalary方法不能访问salary，
只有employee类能访问，如果子类一定要访问必须借助超类公有的端口，关键字super

public double getSalary()
{
    double baseSalary = super.getSalary();
    return baseSalary + bonus;
}

• 子类构造器

public Manager(String name, double salary, int  year, int month,int day)
{
     super(name,salary,year,month,day);
     bonus = 0;
}
由于manager类的构造器不能访问employee类的私有域
得通过超类的构造器对这部分私有域进行初始化super(.....)
super调用构造器的语句必须是子类构造器的第一条语句
如果子类的构造器没有显示的调用超类的构造器，则将自动地调用超类默认的构造器（没有参数）

多态

一个Employee变量既可以引用一个employee类对象
也可以引用一个Employee类的任何一个子类的对象

Manager boss = new Manager(..);
Employee[] staff = new Employee[3];
staff[0] = boss;

但是，不能将一个超类的引用赋给子类变量
方法调用
1.查看对象的声明类型和方法名
2.重载解析
3.如果是private,static,final方法，编译器将可以准确地知道调用哪个方法（静态绑定）

• 阻止继承：final类和方法

public final class Executive extends Manager
{
}
不能定义子类
public class Employee
{
      .....
      public final String getName()
      {
          return name;
      }
} 
子类不能覆盖方法

• 只能在继承层次内进行类型转化
• 在将超类转化成子类之前，应该使用instanceof进行检查

if( staff[1] instanceof Manager)
{
     boss = (Manager) staff[1];
}

抽象类

abstract关键字

为了提高代码的清晰度，有抽象方法的类必须定义成抽象类
public abstract class Person
{
     ....
     public abstract String getDescription();
}

抽象类可以包含具体的方法和参数(和纯虚函数不一样)

public abstract class person
{
        private String name;
        public person(String name)
        {
             this.name =name;
        }
        public abstract String getDescription();
        public String getName()
        {
        return name;
        }
         
} 

(抽象类不能实例化)

Person[] people = new Person[2];
people[0] = new Employee(...);
people[1]  = new Students(..);
for(Person p : people)
System.out.println(p.getName() + "," + p.getDescription());

由于不能构造抽象类的对象p不会引用person，而是引用子类的具体方法

object:所有类的超类

• equals方法
  如果子类能拥有自己的相等概念，则对称性将强制采用getclasss进行检测。
  如果由超类决定 instanceof
  编写equals方法的建议

public boolean equals(Object otherObject )
{
   if( this == otherObject) return true;//比较引用
   if(getClass() != otherObject.getClass()) return false;
   if(!(otherObject instanceof ClassName)) return false;
   className other = (ClassName) otherObject
   return field1 == other.fileld1
   && Objects.equals(field2,other.field2)
   && ...;
   子类super.equals(other)
}

 - hashCode方法
 

```java
public int hashCode()
{
     return Object.hash(name,salary,hireDay);
}

• toString(没啥内容)

• 泛式数组
  ArrayList
  add(n,e)//可以中间插入，也可末尾
  size()
  set(i,harry)
  remove()

## 对象包装器与自动装箱
有时，需要将int这样的基本类型转化成对象,：Integer,Long,Float,Double,Short,Byte,Character,Void,Boolean
自动装箱
## 参数数量可变的方法
...是java代码的一部分。表示可以接受任意数量的对象

```java
public static double max(double... values)
{
      double largest = Double.NEGATIVE_INFINTY;
      for(double v : values) if(v > largest) largest = v;
      return largest;
      
}