java 面向对象基本知识

1.继承

　　使用extends实现继承 只有单继承

　　子类继承父类，可以得到父类的全部属性和方法 (除了父类的构造方法)，但不见得可以直接访问(比如，父类私有的属性和方法)。

　　 instanceof是二元运算符，左边是对象，右边是类；当对象是右面类或子类所创建对象时，返回true；否则，返回false。

　　

 public class Test{
     public static void main(String[] args) {
         Student s = new Student("张三",007,"Java");
         System.out.println(s instanceof Student);
     }
 }

2.方法的重写

　　子类通过重写父类的方法，可以用自身的行为替换父类的行为。方法的重写是实现多态的必要条件。

　   方法的重写需要符合下面的三个要点：

(1).“==”： 方法名、形参列表相同。

(2).“≤”：返回值类型和声明异常类型，子类小于等于父类。

(3).“≥”： 访问权限，子类大于等于父类。

 class Vehicle { // 交通工具类
     public void run() {
         System.out.println("跑....");
     }
 }
 class Horse extends Vehicle { // 马也是交通工具
     public void run() { // 重写父类方法
         System.out.println("四蹄翻飞，嘚嘚嘚...");
     }
 }

3.==和equals

　　“==”代表比较双方是否相同。如果是基本类型则表示值相等，如果是引用类型则表示地址相等即是同一个对象。

　　Object类中定义有：public boolean equals(Object obj)方法，提供定义“对象内容相等”的逻辑。

　　Object 的 equals 方法默认就是比较两个对象的hashcode，是同一个对象的引用(内存地址相同)时返回 true 否则返回 false。但是，我们可以根据我们自己的要求重写equals方法。

　　

 public boolean equals(Object obj) {
         if(obj == null){ //为空没有比较的必要
             return false;
         }else {
             if(obj instanceof Person) {
                 Person c = (Person)obj;
                 if(c.id==this.id) {
                     return true;
                 }
             }
         }
         return false;
     }

4.super

　　super是直接父类对象的引用。可以通过super来访问父类中被子类覆盖的方法或属性。

　　若是构造方法的第一行代码没有显式的调用super(...)或者this(...);那么Java默认都会调用super(),含义是调用父类的无参数构造方法。这里的super()可以省略。

5.封装

　　

　　

　　类的属性的处理:

1. 一般使用private访问权限。

2.  提供相应的get/set方法来访问相关属性，这些方法通常是public修饰的，以提供对属性的赋值与读取操作

　  3. 一些只用于本类的辅助性方法可以用private修饰，希望其他类调用的方法用public修饰。

6.多态　　

　  (1). 多态是方法的多态，不是属性的多态(多态与属性无关)。

(2). 多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象。

(3). 父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

 class Animal {
     public void shout() {
         System.out.println("叫了一声！");
     }
 }

 class Dog extends Animal {
     public void shout() {
         System.out.println("旺旺旺！");
     }
     public void seeDoor() {
         System.out.println("看门中....");
     }
 }
 class Cat extends Animal {
     public void shout() {
         System.out.println("喵喵喵喵！");
     }
 }

 public class TestPolym {
     public static void main(String[] args) {
         Animal a1 = new Cat(); // 向上可以自动转型
         //传的具体是哪一个类就调用哪一个类的方法。大大提高了程序的可扩展性。
         animalCry(a1);
         Animal a2 = new Dog();
         animalCry(a2);//a2为编译类型，Dog对象才是运行时类型。

         //编写程序时，如果想调用运行时类型的方法，只能进行强制类型转换。
         // 否则通不过编译器的检查。
         Dog dog = (Dog)a2;//向下需要强制类型转换
         dog.seeDoor();
     }

     // 有了多态，只需要让增加的这个类继承Animal类就可以了。
     static void animalCry(Animal a) {
         a.shout();
     }

     /* 如果没有多态，我们这里需要写很多重载的方法。
      * 每增加一种动物，就需要重载一种动物的喊叫方法。非常麻烦。
     static void animalCry(Dog d) {
         d.shout();
     }
     static void animalCry(Cat c) {
         c.shout();
     }*/
 }

7.final关键字

　　(1). 修饰变量: 被他修饰的变量不可改变。一旦赋了初值，就不能被重新赋值。

final  int   MAX_SPEED = 120;

　　(2). 修饰方法：该方法不可被子类重写。但是可以被重载!

final  void  study(){}

　　(3). 修饰类: 修饰的类不能被继承。比如：Math、String等。

final   class  A {}