面向对象编程

初识面向对象

面向对象的思想

• 物以类聚，分类的思想，思考解决问题需要分哪些类，然后对分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
• 面向对象适合处理复杂的问题，适合处理需要多人协作的问题。
• 对于描述复杂的事物，为了宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，任然需要面向过程的思路去处理。

面向对象编程的本质就是：以类的方式组织代码，以对象的方式组织数据

三大特性

1. 封装
2. 继承
3. 多态

值得注意的是

• 从认识角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的概念。
• 从代码运行角度考虑是现有类后有对象。类是对象的模板。

---

方法回顾和加深

方法的定义

修饰符 返回值类型 方法名（）{
    方法体
    return 返回值；
}

public String sayHello(){
        return "Hello!";
    }

• break：跳出swithc、结束循环
• return：结束方法，返回一个结果

方法的调用

• 方法分为静态方法和非静态方法
  

有static修饰的方法，是和类一起加载的，而没有static修饰的方法是在类实例化之后才存在。所以，在一个类中，如果两个方法都有或都没有static修饰，则它们之间可以互相调用；反之，若只有一个方法被static修饰，则不能相互调用。

• 引用传递和值传递
  • 引用传递可以理解为C中的指针传递。
  • 值传递可以理解为C中的形式参数。

---

对象的创建分析

构造器

• 在类中还存在构造器，类中的构造器也被称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点:
  1. 必须和类的名字相同
  2. 必须没有返回类型，也不能写void
• 构造器的特点
  1. 和类名相同
  2. 没有返回值
• 构造器的核心作用
  1. 使用new关键字，本质是在调用构造器
  2. 用来初始化值
• 有参构造和无参构造
  • 可以与方法的重载联系，在new一个对象的时候，会根据参数去调用构造器
  • 注意，一旦定义了有参构造，无参构造就必须要显示定义

小结

1. 类与对象

   类是一个模板，是抽象的；对象是一个具体的实例

2. 方法

   方法的定义和调用

3. 对象的引用

   引用类型

   对象是通过引用来操作的：栈 —> 堆

4. 属性

   字段 成员变量

   默认初始化

5. 方法

   方法的定义和调用

6. 对象的创建和使用

   必须使用new关键字来创造对象，用到了构造器

7. 类

   静态的属性

   动态的行为

---

面向对象的三大特性

封装

• 程序设计要求“高内聚，低耦合”。高内聚就是类的内部数据凑字细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
• 属性私有
  • 用private修饰，使类中的属性在外部无法访问
  • 但要提供一些可以操作这些属性的public方法

public class Application {
    public static void main(String[] args) {

        Student student = new Student();

        System.out.println(student.getName());
        System.out.println(student.getAge());
        System.out.println(student.getSex());

        student.reName("Tom");
        student.reAge(10);
        student.reSex(true);

        System.out.println(student.getName());
        System.out.println(student.getAge());
        System.out.println(student.getSex());
    }
}

//学生类
public class Student {

    private String name;
    private int age;
    private boolean sex;

    public void reName(String str){
        this.name = str;
    }
    public String getName(){
        return this.name;
    }

    public void reAge(int newAge){
        this.age = newAge;
    }
    public int getAge(){
        return this.age;
    }

    public void reSex(boolean newSex){
        this.sex = newSex;
    }
    public boolean getSex(){
        return this.sex;
    }
}

输出

null
0
false
Tom
10
true

继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
• extends的意思是“扩展”。子类是父类的扩展
• Java中类只有单继承，没有多继承。
• 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends。
• 子类和父类之间，从意义上讲，应该具有“is a”的关系。
• 注意私有的属性是无法继承的
• 子类继承了父类就会拥有父类的全部方法
• Java中所有类都直接或间接继承Object类

例如：person类下可以继承teacher类和student类方法如下

public class Person {
    
}

public class Teacher extend Preson {
    
}

public class Student extend Person {
    
}

super注意点

1. super调用父类的构造方法，必须在构造方法的第一个
2. super必须只能出现在子类的方法或者构造方法中
3. super和this不能同时调用构造方法

方法的重写

• 重写的前提：需要有继承关系，子类重写父类的方法
• 静态方法不能重写
• 静态方法的调用只与类型有关

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符范围可以扩大（public > protected > private）
4. 抛出的异常可以被缩小但不能扩大

为什么需要重写？

​ 父类的功能，子类不一定需要，或者不一定满足。

多态

• 多态就，即同一个方法可以根据发送的对象不同而采用多种不同的行为方式
• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

多态的存在条件

1. 有继承关系
2. 子类重写父类方法
3. 父类引用指向子类对象

//一个对象的实际类型是确定的
//可以指向的引用类型就不确定了，父类的引用指向子类
Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();

//其中Student是Person的子类，它们都是Object的子类

instanceof关键字

• 判断是否满足父子关系

object instanceof Student	//true
object instanceof Person	//true

---

抽象类和接口

抽象类

• abstract修饰的类就变成了抽象类
• abstract修饰的方法就变成了抽象方法（只有方法的名字名字，没有方法的实现）
  • 抽象类的所有方法，继承了它的子类，都必须要实现它的方法，除非子类也是抽象方法

特点

1. 不能new这个抽象类，只能靠子类去实现它
2. 抽象类中可以写普通方法
3. 抽象方法必须写在抽象类中

接口

• interface定义一个接口
• 类可以实现接口 implements 接口
• 接口实现了多继承

接口的作用

1. 约束
2. 定义一些方法，让不同的人实现
3. public abstract
4. public static final
5. 接口不能被实例化，接口中没有构造方法
6. implements可以实现多个接口
7. 必须要重写接口中的方法

---

内部类以及OOP实战

• 内部类就是子啊一个类的内部再定义一个类，比如，A中定义一个B类，那么B类相对与A类来说就称为内部类，而A类相对B类来说就是外部类了

public class Outer{
    
    private int id;
    public void out(){
        System.out.printlen("这是外部类的方法");
    }
    
    public class Inner{
        public void in(){
            System.out.printlen("这是内部类的方法");
        }
    }
}

public class Application{
    public static void main(String[] args){
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
    }
}