JAVA学习笔记-----面向对象

重写equals和hashcode

写类要重写equals和hashcode，在类当作Map中的Key（键）时，一定要重写hashcode，Map中的键需要使用equals方法，该方法中调用了hashcode判断是否相同。

成员变量和局部变量

类中成员变量未手动初始化，虚拟机会自动进行初始化。而局部变量不能自动初始化，提示该变量未初始化。

public class Persion{
    private int age;
    public static void main(String[] arg0){
        int age2;
        System.out.println(age); //等于0
        Sytem.out.println(age2); //编译报错,未初始化
    }
}

栈(Stack)、堆(Heap)、数据区（date segment）

局部变量在栈，形参在栈，返回值在栈，对象的引用在栈；
对象在堆，对象的成员变量也在堆。
静态变量，常量在数据区。

关键字this

• 在类的方法定义中使用的this关键字代表使用该方法的对象的引用。
• 当必须指出当前当前使用方法的对象是谁时要使用this。
• 有时使用this可以处理方法中成员变量和参数重名的情况。

void fun1(int i){
    this.i=i;
}

1. this可以看作是一个变量，它的值是当前对象的引用。

关键字static

1. 在类中，用static声明的成员变量为静态成员变量，它为该类的共有变量，在第一次使用时被初始化，对于该类的所有对象来说，static成员变量只有一份。
2. 用static声明的方法为静态方法，在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员。
   
   • 静态方法不再是针对于某个对象调用，所以不能访问非静态成员。
3. 可以通过对象引用或类名（不需要实例化）访问静态成员。

访问控制

PS：重写方法不能比父类的权限严格。

继承中的构造方法

1. 子类的构造的过程中必须调用其基类的构造方法。
2. 子类可以在自己的构造方法中使用super（argument）_list）调用基类的构造方法。
   ps：如果调用super，必须写在子类构造方法的第一行。
3. 如果子类的构造方法中没有显式地调用基类的构造方法，则系统默认调用基类无参数的构造方法。

public class SuperClass {
  private int i;
  SuperClass(){
    System.out.println("SuperClass 无参构造");
  }
  SuperClass(int i){
    System.out.println("SuperClass 有参构造");
  }
  public static void main(String[] args) {
    SuperClass s=new SubClass(1);
  }
}
class SubClass extends SuperClass{
  SubClass(){
    System.out.println("SubClass 无参构造");
  }
  SubClass(int i){
    System.out.println("SubClass 有参构造");
  }
}
/*结果：
SuperClass 无参构造
SubClass 有参构造*/

1. 如果子类构造方法中既没有显式的调用基类的构造方法，而基类中又没有无参的构造方法（子类没调用父类的构造方法，父类没有无参的构造方法），则编译出错。

public class SuperClass {
  private int i;
  SuperClass(int i){
    System.out.println("SuperClass 有参构造");
  }
  public static void main(String[] args) {
    SuperClass s=new SubClass(1);
  }
}
class SubClass extends SuperClass{
  SubClass(){
    System.out.println("SubClass 无参构造");
  }
  SubClass(int i){
    System.out.println("SubClass 有参构造");
  }
}
/*结果：出错,父类没有无参构造方法*/

动态绑定(迟绑定)

面向对象的核心。

class Person{
    Animal pet;
    Person(Animal pet){
        this.pet=pet;
    }
    public void myPetCry(){
        pet.cry();
    }
}
-----------------------------------
Cat a=new Cat();
Person p=new Person(a);
p.myPetCry();

此处调用子类Cat()中的cry方法，而不是基类Animal的cry方法。
多态：
1. 要有继承
2. 要有重写
3. 父类引用指向子类对象

关键字final

public void fun1(final int i){
    i=2;//不能改变,编译错误
}
class T{
    public final void fun2(){
    }
}
class TT extends T{
    public void fun2(){} //不能重写,编译错误
}
final class TTT{}
class TTTT extends TTT{} //不能被继承,编译错误

接口

• 接口是抽象方法和常量值的定义的集合。
• 从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。
  举例如下：

public interface Runner{
    public static final int id=1;//public static final可写可不写,都是默认的
    public void start();
    public void run();
    public void stop();
}

接口特性

1. 接口可以多重实现；
2. 接口中声明的属性默认为public static final的；也只能是public static final的；
3. 接口中只能定义抽象方法，而且这些方法默认为public的、也只能是public的；
4. 接口可以继承其他接口，并添加新的属性和抽象方法。
   举例如下：

class Teacher implements Painter,Singger{}
//Teacher实现了两个接口

Painter p=new Teacher();
p.paint();p.sleep();    //只能访问Painter中的方法
Sinngger s=(Singger)p;
s.sing();s.eat();   //只能访问Sinnger中的方法

总结