概念清单

类 对象 方法 实例变量
多态 继承 封装
抽象
重载 重写

面向对象知识

1. 修饰符

访问修饰符

• default (即缺省，什么也不写）: 在同一包内可见，不使用任何修饰符。
• private : 在同一类内可见。
• public : 对所有类可见。
• protected : 对同一包内的类和所有子类可见。

非访问修饰符

• static 静态变量 静态方法
• final 类不能被继承，数据和函数不可被修改
• abstract

2. 继承

类

class 父类 {
}
 
class 子类 extends 父类 {
}

接口

public interface B {
    public void show();
}
 
public class C implements B {
}

• 构造函数
• this
• super
• 抽象类

3. 多态

• 重写 Override
  不可重写父类的private方法
  子类中调用父类的被重写方法时，要使用super关键字

• 重载 Overload

  
  

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

4. 封装

没啥说的