Java基础之继承

1，利用继承，人们可以基于已存在的类构造一个新类。继承已存在的类就是复用（继承）这些类的方法和域。在此基础上添加一些新的方法和域，以满足新的需求（is-a）。

2，反射是指程序运行期间发现更多的类及其属性的能力。

3，overload重载，override覆盖

4，super关键字与this关键字区别：

1）this关键字相当于对象的引用；

2）super不是引用，不能将super赋给一个对象变量，它只是一个指示编译器调用超类方法的特殊关键字；

3）this一是引用隐式参数，二是调用该类的其它构造器；

4）super一是调用超类方法，二是调用超类的构造器。

5，子类中可以增加数据域、方法，或覆盖父类的方法，但是不能删了继续的数据域或方法；

6，子类构造器可以使用super()显示调用父类的构造器，如果子类不显示调用，则子类会默认调用父类的无参构造器；

如果子类没有显示的调用父类的构造，但父类又没有默认、无参构造，则编译器会报错。

7，一个对象变量（如e）可以指示多种实际类型的现象被称为多态，在运行时能够自己动地选择调用哪个方法的现象称为动态绑定。

public class Test {
public static void main(String[] args) {
Manager boss = new Manager("test", 8000, new Date());
boss.setBonus(5000);

Employee[] staff = new Employee[3];
staff[0] = boss;
staff[1] = new Employee("test1", 7000, new Date());
staff[2] = new Employee("test2", 6000, new Date());

for (Employee e : staff) {
System.out.println(e.getName() + "  " + e.getSalary());
}
}
}

public class Employee {

private String name;

private double salary;

private Date hireDay;

public Employee() {

}

public Employee(String name, double salary, Date hireDay) {
this.name = name;
this.salary = salary;
this.hireDay = hireDay;
}

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;
}

public Date getHireDay() {
return hireDay;
}

public void setHireDay(Date hireDay) {
this.hireDay = hireDay;
}
}

public class Manager extends Employee {

private double bonus;

public Manager() {

}

public Manager(String name, double salary, Date hireDay) {
//初始化父类的构造，必须放在第一句
super(name, salary, hireDay);
this.bonus = 0;
}

public double getBonus() {
return bonus;
}

public void setBonus(double bonus) {
this.bonus = bonus;
}

public double getSalary() {
//super.getSalary() 调用父类的方法，只有Employee中的方法才能够访问其数据域
return bonus + super.getSalary();
}
}

8，对象变量是多态的，每个对象变量都属于一个类型；

9，动态绑定：

1）x.f(param)，x为C类的对象，首先编译器会获得所有C类对象（即C类的父类、子类）所有public修饰的f()方法；

2）编译器查看调用方法的参数类型，如String类型参数，hello('test')，如果在父类或子类中存在多个类型相同的方法，编译器会报错，至此编译器与获得所有方法名和参数类型；

3）如果是static,private,final方法，编译器准确的知道调用哪个方法，这叫“静态绑定”；与之相对的是动态绑定；

4）程序运行时JVM一定调用与x所引用对象类型最合适的那类的方法，假设x的实际类型是D，D是C的子类，所以JVM会调用D的f()方法；

5）JVM每次运行时去会进行搜索，时间开销相当大，所以会建以一个方法表，需要时从方法表中读取。

10，子类覆盖父类方法时，访问权限不能低于父类的访问权限，如父类是public，子类也必须是public；反之编辑器会把它解释为试图降低访问权限；

11，阻止继承，final类、方法；

1）final类不允许被继承；如果类被声明为final，其类中的方法自动的转为final方法（不允许类继承，所以方法也是不能继承的），例如：String是final类，不允许继续；其作用主要是确保子类不会改变其语义。

2）final方法，子类不允许覆盖；

3）fina域，构造初始化对象过后不再允许更改它的值。

12，早期java中使用final关键字来避免动态绑定，如果一个方法较短并且没有被覆盖，编译器就会对其进行内联优化，例如：e.getNmae()将被优化成e.name；目前JVM的即时编译器比传统编译器处理能力强得多，可以对那些较短的方法，调用频率高的类进行自动优化，如果后期继承的子类对优化的方法有覆盖，优化器将取消内联优化，这个过程很慢，但很少发生。

13，类型转换，使用is-a原则，子类可以强制转换为基类，反之不行；ClassCastException

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

14，包含一个或多个抽象方法的类必须被声明为抽象类；抽象类同时包括具体数据和具体的方法；

abstract class Person{
private String name;

public abstract String getDescription();

public Person(String name){
this.name = name;
}

public String getName(){
return name;
}
}

15，类不包含抽象方法也可以声明为抽象，抽象类不可以被实例化。但可以定义抽象类的对象变量：

class Student extends Person{
}

//Pserson为抽象类，student为实现的子类
Person p = new Student("test", "test");

public abstract class Person {
private String name;

public abstract String getDescription();

public Person(String name) {
System.out.println("Person构造");
this.name = name;
}

public String getName() {
return name;
}

}

public class Student extends Person {

private String major;

//父类中存在有参构造，子类一定要先调用父类构造，如果是默认的，可以不调用super
public Student(String name, String major) {
super(name);
System.out.println("Student构造");
this.major = major;
}

@Override
public String getDescription() {
return "a student major in " + major;
}

}

public class Employee extends Person {

private double salary;
private Date   hireDay;

public Employee(String name, double salary, Date hireDay) {
super(name);
System.out.println("Employee构造");
this.salary = salary;
this.hireDay = hireDay;
}

@Override
public String getDescription() {
return String.format("an example with a salary of $%.2f", salary);
}

public double getSalary() {
return salary;
}

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

public static void main(String[] args) {
Person[] persons = new Person[2];
persons[0] = new Student("student", "class");
persons[1] = new Employee("emplyee", 9000, new Date());
for (Person person : persons) {
System.out.println(person.getName() + ", " + person.getDescription());
}
}

输出结果：
Person构造
Student构造
Person构造
Employee构造
student, a student major in class
emplyee, an example with a salary of $9000.00

16，子类同样无法访问父类的private域；

17，protected方法比protected域更有实际意义，可以让子类调用父类的方法，其它包外的类不允许；

18，protected与defalut的区别：

1）protected，子类、包内访问权限，但这里有一点需要注意：如果子类在包外，也是可以访问的；


2）default，包内访问权限，没有子类这种定义，相当于只能在包内才能访问，只要在包外都不可以访问；

19，访问权限从大到小的顺序：

public->protected->default->private

20，Object类是java所有类的超类，java中的每个类都是由object类扩展而来，如果没有明确指出超类，Object就是这个类的超类；

//object只能持有引用，不能对内容进行操作
Object obj = new Employee("", "");

21，在java中只有基本类型不是对对象，例如：数值，字符，布尔型的值都不是对象，8种基本数据类型；

22，Object的equals比较的是两个对象引用是否相等；

23，==比较基本数据类型， equals比较对象域（数据），如果都相等，则返回true；

24，hashcode，散列码，是由对象导出的一个整型值，两个对象的.hashCode()基本不会相同；

25，由于hashCode方法定义在Object类中，因此每个对象都有一个默认的hashcode，其值为对象的存储地址；

26，

String s = "OK";
StringBuilder sb = new StringBuilder(s);
System.out.println(s.hashCode() + " " + sb.hashCode());
String t = new String("OK");
StringBuilder tb = new StringBuilder(t);
System.out.println(t.hashCode() + " " + tb.hashCode());

结果：
2524 14576877
2524 12677476

为什么s、t的散列码相同？因为String重写了Object的hashcode，导出内容的散列码；

然而sb、tb的散列码不同？因为StringBuilder没有重写Object的hashcode，采用了Object的默认方法，导出的是对象的存储地址。

27，equals与hashCode的定义必须一致：如果x.equals(y)返回true，那个x.hashCode()必须与y.hashCode()具有相同的值（存储地址）；

Arrays.hashCode();

hashCode(null) = 0，hashcode可以为正数或负数；

28，toString（对对象来说x.toString()与""+x是等价的，但如果x是基本类型则会直接执行）

@Override
public String toString() {
return super.toString() + "Employee[name=" + super.getName() + ", salary=" + salary
+ ", hireDay=" + hireDay + "]";
}

29，toString打印数组

int[] array = {1,2,3,4,5,6};
System.out.println(Arrays.toString(array));
//打印多维数组
Arrays.deepToString();

30，ArrayList动态数组，在数组已满的情况下，会重新创建一个更大的数组，然后将较小的数组copy到较大的数组中；

1）数组列表管理着对象引用的一个内部数组；

2）JAVA7中，如果确定一个数组列表容量，可以提前分配数组的列表容量arraylist.ensureCapacity(100)；同时也可以采用以下方式：

List<String> arrayList = new ArrayList<String>(100);

3）数组列表容量与数组大小有区别(new Employee[100])，分100个空间，说明数组有100个空位置可用；100个列表容量表示只是拥有保存100个元素的潜力，实际上，重新分配空间的话会超过100；

31，ArrayList与数组区别：

1）数组，固定长度，效率较ArrayList高；

2）ArrayList，动态数组，可变长度，无初始化数组长度，底层当然是用数组来实现；

3）ArrayList由于增加了灵活性，所以较数组效率低；

List<String> arrayList = new ArrayList<String>(100);
for (int i = 0; i < 20; i++) {
arrayList.add(String.valueOf(i));
}
//数组
String[] arrays = new String[arrayList.size()];
//转换为数组
arrayList.toArray(arrays);
System.out.println(Arrays.toString(arrays));
输出结果：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

32，每个基本数据类型都有一个包装器类，如：Integer,Long,Float,Double,Short,Byte,Void,Boolean，其中前6个派生于公共的超类Number。

1）Integer.valueOf(int)，自动装箱

2）list.get(i).intValue()，自动拆箱

3）装箱和拆箱是编译器认可的，不是JVM

33，继承设计：

1）将公共操作、域放在超类；

2）不要使用受保护的域；protected，破坏封装，无限子类可以访问；同一个包中可以访问导致不是子类也可以访问；但需要在子类中重新定义的可以使用；

3）使用继承实现“is-a”关系，继承很容易达到节省代码的目的；

4）除非所有的继承方法都有意义，否则不要继承；

5）在覆盖方法时，不要改变预期的行为；置换原则不仅应用于语法，而且也可以应用于行为；

6）使用多态，而非类型信息（根据类型来判断使用哪个方法）；

7）不要过多的使用反射。反射是很脆弱的，编译器很难发现程序中的错误，只有在运行时发现，并导致错误或异常。