面向对象小结

面向对象编程OOP

本质：以类的方式组织代码，以对象的方式组织数据
在java中是以类为单位，一个类包括成员变量、成员方法和构造方法
构造方法：创建对象的时候，由jvm自动调用，其中的作用是给成员变量赋值；不能用static关键字来修饰构造方法。
面向对象三大特性：封装，继承，多态

1. 封装

1.1 封装的目的就是隐藏；特征是高内聚，低耦合

高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；
低耦合是仅仅暴露少量的方法给外部使用

1.2 把成员变量隐藏起来，通过设置get，set来对数据进行设置和读取：

public class Person {   //可以使用快捷键Alt+Enter
    private String name;
    private int age;
     
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

2. 继承——>extends

继承：子类继承父类的非私有的成员（成员变量和成员方法），注意：构造方法是不能被继承的。

2.1 继承与接口比较

类的继承只能是单一继承：也就是说一个子类只可以同时继承一个父类；
接口可以进行多重继承：一个接口可以同时继承多个接口
类可以进行多重继承：也就是说父类可以再继承其他的类

2.2 方法重写

使用的场景：父类的方法不能满足子类的需求的时候，需要进行方法重写
子类和父类的方法一样时，当执行的时候，调用的是子类的方法，这就叫做重写
只有一般的方法才能重写，构造方法是不能被重写的
重写格式：

• 方法名和参数列表必须相同
• 返回值一般要求相同，或者子类的返回值类型是父类方法返回值类型的子类
• 父类的方法有static修饰的时候，子类方法也必须用static修饰
• 子类方法的权限不能比父类方法的权限低，修饰符范围可以扩大：public>protected>private
• 抛出的异常范围可以被缩小，不能扩大

注意：重写(Override)与重载(Overload)

重写 是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！
重载 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。最常用的地方就是构造器的重载。

2.3 super&&this

• 子类中有与父类同名的成员变量和方法时，可以使用super来调用父类的成员
• 在子类的构造方法中可以使用super(参数)来调用父类的构造方法；如果不写默认会调用父类的无参数构造方法。
• this代表当前调用的对象，所有的非静态成员方法和变量调用都需要依赖对象
• this和super调用构造方法时，不能同时存在****，因为两个都必须放在第一行
• super只能出现在子类的方法或者构造方法中，只能在继承条件下才能用

3. 多态——>提高了程序的扩展性，代码的复用性

3.1 多态

父类的引用指向子类的对象；Parent p = new Child();
或者是接口的引用指向实现类的对象

3.2 多态实现条件

• 继承：在多态中必须存在有继承关系的子类和父类。
• 重写：子类对父类中某些方法进行重新定义
• 向上转型：在多态中需要将子类的引用赋给父类对象

3.3 多态编译运行

多态编译时，全部看父类;多态运行时，除了存在重写的非静态方法，运行子类重写的方法，其他全部运行父类的成员

3.4 多态的实现方式

• 重写
• 接口
• 抽象类和抽象方法

3.5 类型转换

向上自动转型：多态就属于自动向上转型
强制向下转型：可以先使用instanceof判断然后再进行强制转换，否则容易出现类型转换异常

3.6 代码演示

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. 接口——>implements

4.1 接口中只有成员变量和成员方法

• 成员变量默认的是：public static final
• 成员方法默认的是: public abstract

4.2 类与接口

• 一个接口可以同时继承多个接口
• 一个类可以同时实现多个接口

4.3 接口和抽象类的使用场景

• 抽象类：两个类存在继承关系
• 两个事物不存在继承关系，主要用来定义规则，增加功能

4.4 注意

不管是一个类实现多个接口，还是接口继承多个接口时，不能出现方法名和参数名相同，返回值类型不同的方法

5. final

• final修饰类：该类不能被继承
• final修饰方法：该方法不能被重写
• final修饰变量：基本数据类型，成为了常量，不能被改变
• final不能修饰构造方法

6. 匿名对象

使用匿名对象的使用场景：就是这个对象只用一次，这样的场景非常方便。

public class Demo{
    public void test(){}
}
// 利用匿名对象来调用Demo类
public class TestDemo{
   public static void main(String args[]){
      New Demo().test();
   }
}