面向对象编程

面向对象（OOP）

Java的核心思想就是OOP

目录

• 面向对象（OOP）
  • 面向过程 & 面向对象
    • 面向过程试想
    • 面向对象思想
    • 总结
  • 初识面向对象
    • 概念
    • 抽象
    • 三大特性
  • 方法回顾和加深
    • 方法的定义
    • 方法的调用
  • 对象的创建
    • 类与对象的关系
    • 创建与初始化对象
    • 构造器
    • 创建对象时的内存分析
  • 小结
    • 类与对象
    • 方法
    • 对象的引用
    • 属性
    • 对象的创建和使用
    • 类
  • 面向对象编程
    • 封装
    • 继承
      • Object类
      • this 与 super 的对比
    • 方法重写
    • 多态
    • instanceof
    • 类型转换
    • static关键字
      • 静态代码块
      • 静态导入包
  • 抽象类和接口
    • 抽象类
    • 接口
  • 内部类
    • 成员内部类
    • 静态内部类
    • 局部内部类
    • 匿名内部类

面向过程 & 面向对象

面向过程试想

• 步骤清晰简单，第一步做什么，第二步做什么……
• 面向过程适合处理一些较为简单的问题

面向对象思想

• 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
• 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！

总结

对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

初识面向对象

概念

面向对象编程（Object Oriented Programming，OOP）

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

抽象

将多个事物的公共点剥离出来，组成一个类（抽取它们相像的部分）

三大特性

• 封装
• 继承
• 多态

从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象

从代码运行角度考虑是先有类后有对象。类是对象的模板。

方法回顾和加深

方法的定义

• 修饰符

• 返回类型

• break 和 return 的区别

  break：跳出switch，结束整个循环

  return：返回一个结果，结束当前方法

• 方法名：注意使用驼峰命名法，见名知意

• 参数列表：参数类型，参数名；...可变参数

• 异常抛出：疑问，后面讲解

代码：

// Demo01 类
public class Demo01 {
    // main 方法
    public static void main(String[] args) {

    }
    /*
    修饰符 返回值类型 方法名(方法参数){
        // 方法体
        return 返回值;
    }
     */
    public String sayHello() {
        return "Hello,World"; // 结束方法，返回一个结果
    }

    public int max(int a, int b) {
        return a > b ? a : b; // 三元运算符
    }
    
    public void readFile(String file) throws IOException {

    }
}

方法的调用

• 静态方法

• 非静态方法

  public class Student {
      // 非静态方法
      public void say() {
          System.out.println("学生说话了！");
      }
  }
  public class Demo02 {
      public static void main(String[] args) {
          // 实例化这个方法 new
          // 对象类型 对象名 = 对象值;
          Student student = new Student();
          student.say();
      }
  
      // 和类一起加载的
      public static void a(){
          //b(); 不能调用b方法
      }
  
      // 类实例化 之后才存在
      public void b(){
          a();
      }
  }
  

• 形参和实参

  public class Demo03 {
      public static void main(String[] args) {
          int add = Demo03.add(1, 2); // 传入实际参数，必须和形式参数一一对应
          System.out.println(add);
      }
  
      public static int add(int a, int b) { // 定义形式参数
          return a + b;
      }
  }
  

• 值传递和引用传递

  值传递：

  public class Demo04 {
      public static void main(String[] args) {
          int a = 1;
          System.out.println(a); // 1
          change(a);
          System.out.println(a); // 1
      }
      // 返回值为空
      public static void change(int a) {
          a = 10;
      }
  }
  

  引用传递：

  // 引用传递:对象，本质还是值传递
  public class Demo05 {
      public static void main(String[] args) {
          Person person = new Person();
          System.out.println(person.name); // null
          change(person);
          System.out.println(person.name); // java学习
  
      }
      public static void change(Person person) {
          // person是一个对象：指向的 ---> Person person = new Person(); 这是一个具体的人，可以改变属性！
          person.name = "java学习";
      }
  }
  // 定义一个Person类，有一个属性name
  class Person {
      String name; // null
  }
  

• this 关键字

• 递归

对象的创建

类与对象的关系

类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物

• 动物、植物、手机、电脑、……
• Person类、Pet类、Car类等，这些类都是用来描述或定义某一类具体的事物应该具备的特点和行为

对象是抽象概念的具体实例

• 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例
• 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念

我们可以将这些思想转化为代码实现！

创建与初始化对象

使用new 关键字创建对象

使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

定义一个Student类：

public class Student {
    // 属性:字段
    String name; // 默认 null
    int age; // 默认 0
    // 方法
    public void study() {
        System.out.println(this.name + "学生在学习");
    }
}

实例化得到Student对象

public static void main(String[] args) {
    // 类：抽象的，实例化
    // 类实例化后会返回一个自己的对象！
    // xiaoMing就是一个Student类的具体实例
    Student xiaoMing = new Student();
    Student xiaoHong = new Student();
    xiaoMing.name = "小明";
    xiaoMing.age = 3;
    System.out.println(xiaoMing.name);
    System.out.println(xiaoMing.age);
    xiaoHong.name = "小红";
    xiaoHong.age = 8;
    System.out.println(xiaoHong.name);
    System.out.println(xiaoHong.age);
}

构造器

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:

1. 必须和类的名字相同
2. 必须没有返回类型，也不能写void

作用：

1. new本质是在调用构造器

2. 初始化一些对象的值

【注意】：定义了有参构造器，如果想使用无参构造器，必须显示定义无参构造器

IDEA使用 alt + insert 选择Constructor快速生成构造器

类构造器必须掌握

代码：

public class Person {
    // 一个类即使什么都不写，它也会存在一个方法
    // 显示定义构造器
    String name;
    int age;
    // 实例化初始值
    // 1、使用new关键字，本质是在调用构造器
    public Person(){
        this.name = "java";
    }
    // 有参构造：一旦定义了有参构造，无参构造就必须显示定义
    public Person(String name) {
        this.name = name;
    }
    //alt + insert 选择Constructor快速生成构造器
}

调用：

public static void main(String[] args) {
    // 使用new 关键词实例化一个对象
    Person person = new Person();
    System.out.println(person.name);
    Person person1 = new Person("java");
}

创建对象时的内存分析

Pet类：

public class Pet {
    public String name;
    public int age;
    public void shout(){
        System.out.println("叫了一声");
    }
}

main方法：

public static void main(String[] args) {
    Pet dog = new Pet();
    dog.name = "旺财";
    dog.age = 16;
    dog.shout();
    System.out.println(dog.name);
    System.out.println(dog.age);
    Pet cat = new Pet();
}

内存分析：

小结

类与对象

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

方法

定义，调用

对象的引用

​ 引用类型：除了8大基本数据类型之外的类型

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

属性

默认会初始化；数字：0，0.0；char：u0000；boolean：false；引用类型：null

对象的创建和使用

• 必须使用new关键字调用构造器创建对象 Person person = new Person();
• 对象的属性 person.name;
• 对象的方法 person.doSomething()；

类

• 静态的属性 属性
• 动态的方法 方法

面向对象编程

封装

• 该露的露，该藏的藏

  • 我们程序设计要追求“高内聚，低耦合”
  • 高内聚：就是类的内部数据操作细节自己完成，不允许外部干涉
  • 低耦合：仅暴露少量的方法给外部使用。

• 封装(数据的隐藏)

  • 通常，应禁止直接访问一个对象中数据的实际表示。
  • 而应通过操作接口来访问，这称为信息隐藏。

记住一句话：属性私有，get/set

IDEA自动生成get/set方法：alt + insert 选择getter/setter 自动生成方法

封装的作用：

1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 提高了系统的可维护性

public class Student {
    private String name; // 姓名
    private int studentNo; // 学号
    private char gender; // 性别
    private int age; //年龄
     /*
     提供public的getter/setter方法
     get：获得属性值
     set：设置属性值
     */
    // 获得这个属性
    public String getName() {
        return name;
    }
    // 设置这个属性
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if (age < 120 && age > 0) {
            this.age = age;
        } else {
            this.age = 0;
        }
    }
}

调用代码

public static void main(String[] args) {
    Student student = new Student();
    String studentName = student.getName();
    student.setName("小明"); // 通过set给姓名赋值
    System.out.println(student.getName()); // 通过get获取name的值输出 小明
    student.setAge(999); // 给年龄赋值
    System.out.println(student.getAge()); // 年龄不合法，程序将其设置为0
}

继承

继承的本质是对某一批类的抽象，从而对现实世界更好的建模。

extands的意思是“扩展”。子类是父类的扩展。

JAVA中类只有单继承，没有多继承！（一个儿子只能有一个爸爸，但是一个爸爸可以有多个儿子）

继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。

继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。

子类和父类之间,从意义上讲应该具有"is a"的关系。

子类能继承父类的所有公开方法及属性

代码：

// 定义了一个Person类，say方法
public class Person {
    public void say() {
        System.out.println("说了一句话");
    }
}
// 学生 is 人 ；派生类，子类
// Student类继承Person类
public class Student extends Person {
}
// 老师 is 人
// Teacher类继承Person类
public class Teacher extends Person {
}

public static void main(String[] args) {
    // 创建一个Student类    
    Student student = new Student();
    student.say(); // Student类可以使用Person类的say方法
}

Object类

在Java中，所有的类，都默认直接或间接继承Object类

super

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

this 与 super 的对比

1. this 与 super 代表的对象不同

   • this：本身调用者这个对象
   • super：代表父类对象的应用

2. 使用条件不同

   • this：没有继承也可以使用
   • super：只能在继承条件下才可以使用

3. 构造方法

   • this()：本类的构造
   • super()：父类的构造

方法重写

重写的前提：需要有继承关系，子类重写父类的方法

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大，但是不能缩小 public > protected > private > default
4. 抛出的异常：范围，可以被缩小，但是不能扩大：Exception > ClassNotFoundException
5. 子类和父类的方法名必须要一致，方法体不同

为什么需要重写？

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

IDEA重写快捷键：Alt + Insert选择override

多态

动态编译：类型根据程序运行时改变

多态：即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

注意事项：

1. 多态是方法的多态，没有属性的多态
2. 父类和子类，有联系 （类型转换异常）ClassCastException
3. 存在的条件：有继承关系，方法需要重写，父类的引用指向子类对象！ Father f1 = new Son();
   • static静态方法属于类，它不属于实例，不能重写
   • final 常量，不能被改变，不能重写
   • private 私有的，不能重写

代码：

public class Person {
    public void run(){
        System.out.println("父类run");
    }
}

public class Student extends Person {
    @Override
    public void run() {
        System.out.println("子类重写sun");
    }
    public void eat(){
     System.out.println("子类的eat");
    }
}

public static void main(String[] args) {
    // 一个对象的实际类型说确定的
    // new Student();
    // new Person();
    // 可以指向的引用类型就不确定了:父类的引用指向子类
    // 能调用的方法都是自己的，或者父类的
    Student s1 = new Student();
    // Person类型，虽然可以指向子类，但是不能使用子类独有的方法
    Person s2 = new Student();
    Object s3 = new Student();
    // 对象能指向的方法，主要看左边的类型，和右边关系不大
    s1.run(); // 子类重写sun
    s1.eat(); // 子类的eat
    s2.run(); // 子类重写sun
}

instanceof

instanceof (类型转换) 引用类型，判断一个对象是什么类型

public static void main(String[] args) {
    // Object > Person > Student
    // Object > Person > Teacher
    Object object = new Student();
    System.out.println(object instanceof Student); // true
    System.out.println(object instanceof Person); // true
    System.out.println(object instanceof Object); // true
    System.out.println(object instanceof Teacher); // false
    System.out.println(object instanceof String); // false
    System.out.println("=====================");
    Person person = new Student();
    System.out.println(person instanceof Student); // true
    System.out.println(person instanceof Person); // true
    System.out.println(person instanceof Object); // true
    System.out.println(person instanceof Teacher); // false
    // System.out.println(person instanceof String); // 编译报错
}

类型转换

public static void main(String[] args) {
    // 类型之间的转换 ：父和子
    // 高 ==> 低
    Person person = new Student();
    // person.go(); 父类无法使用子类对象
    // 将 student这个对象转化为Student类型，就可以使用Student类型的方法了
    System.out.println(person instanceof Student); // true
    ((Student) person).go();// 强制类型转换
}

注意事项：

1. 父类引用指向子类的对象
2. 把子类转化为父类，向上转型：不要强制转换
3. 父类转换为子类，向下转型：需要强制转换；可能会丢失方法
4. 方便方法调用，减少重复的代码！简洁

抽象：封装、继承、多态！ 抽象类，接口

static关键字

静态：随类加载一起加载

注意事项：

1. 使用static修饰的方法或属性，使用 类名.方法名/属性名
2. 也可以创建一个实例，使用实例访问
3. 非静态方法可以调用静态方法
4. 静态方法不能直接调用非静态方法

public class Student {
    private static int age; // 静态变量
    private double score; // 非静态变量
    public void run(){

    }
    public static void go(){

    }

    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(s1.age);
        System.out.println(s1.score);
        System.out.println(Student.age);
        // System.out.println(Student.score); 编译报错
    }
}

静态代码块

public class Person {
    // 第二个执行
    {
        // 匿名代码块
        // 创建对象时在构造器之前创建
        System.out.println("匿名代码块");
    }

    // 第一个执行：只执行一次
    static {
        // 静态代码块，随类加载，只执行一次
        System.out.println("静态代码块");
    }

    // 第三个执行
    public Person() {
        System.out.println("构造器");
    }

    public static void main(String[] args) {
        Person person = new Person();
       	System.out.println("=====");
        Person person2 = new Person();
    }
}

静态导入包

// 静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;

public class Test {
    public static void main(String[] args) {
        System.out.println(random()); // 随机数
        System.out.println(PI); // Π
    }
}

抽象类和接口

抽象类

abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法;如果修饰类,那么该类就是抽象类

• 抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
• 抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。
• 抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
• 子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。

思考

• 抽象类不能new ，存在构造器吗？

  ​ 存在构造器 虽然抽象类不能new ，但是创建其子类时，子类会调用其构造器

• 抽象类存在的意义

  ​ 对代码的维护和重用

  1. 因为抽象类不能实例化对象，所以必须要有子类来实现它之后才能使用。这样就可以把一些具有相同属性和方法的组件进行抽象，这样更有利于代码和程序的维护
  2. 当又有一个具有相似的组件产生时，只需要实现该抽象类就可以获得该抽象类的那些属性和方法

接口

• 普通类:只有具体实现
• 抽象类:具体实现和规范(抽象方法)都有！
• 接口:只有规范！自己无法写方法；专业的约束！ 约束和实现分离：面向接口编程！

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是...则必须能.….”的思想。如果你是天使,则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏人;如果你是坏人，则必须欺负好人

接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。

OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、java、c#等)，就是因为设计模式所研究的，实际上就是如何合理的去抽象。

声明类的关键字是class,声明接口的关键字是interface

// interface 定义关键字，接口都需要实现类
public interface UserService {
    // 接口的属性都是常量 public static final
    int AGE = 99;
    // 接口中的所有方法都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void select(String name);
}

// 抽象类：extends
// 类 可以实现接口 implements 接口
// 实现接口的类，必须重写接口中的所有方法
// 利用接口实现多继承，
public class UserServiceImpl implements UserService,TimeService {
    @Override
    public void add(String name) {
    }
    @Override
    public void delete(String name) {
    }
    @Override
    public void update(String name) {
    }
    @Override
    public void select(String name) {
    }
    @Override
    public void timer() {
    }
}

接口的作用：

1. 接口是一种约束
2. 定义一些方法，让人有不同的实现
3. 接口里的方法都是 public abstract 的
4. 接口里的属性都是 public static final 的
5. 接口不能被实例化，接口中没有构造方法
6. 可以被实现多个，使用 implements 关键字
7. 实现接口的类必须实现接口的所有方法

内部类

内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

成员内部类

public class Outer {
    public Outer() {
        System.out.println("这是外部类的构造器");
    }
    private int id;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    
    public class Inner{
        public Inner() {
            System.out.println("这是内部类的构造器");
        }
        public void in(){
            System.out.println("这是内部类的方法");
        }
        // 获得外部类的私有属性,私有方法
        public void getId(){
            System.out.println(id);
        }
    }
}

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

静态内部类

public class Outer {
    public Outer() {
        System.out.println("这是外部类的构造器");
    }
    private static int id;
    public void out(){
        System.out.println("这是外部类的方法");
    }
	// 定义静态内部类
    public static class Inner{
        public Inner() {
            System.out.println("这是内部类的构造器");
        }
        public void in(){
            System.out.println("这是内部类的方法");
        }
        // 只能获得外部类的静态私有属性,静态私有方法
        public void getId(){
            System.out.println(id);
        }
    }
}

局部内部类

public class Outer {

}

// 一个Java类中可以有多个class类，但是只能有一个 public class
class A {

}

public class Outer {
    // 布局内部类
    public void method(){
        class Inner{
            public void in(){

            }
        }
    }
}

匿名内部类

public class Test {
    public static void main(String[] args) {
        // 没有名字去初始化类，不用将实例保存到变量中
        new Apple().eat();
        UserService userService = new UserService() { // 这就是一个匿名实现类
            @Override
            public void hello() {

            }
        };
    }
}
// 定义一个类
class Apple{
    public  void eat(){
        System.out.println("吃苹果");
    }
}
// 定义一个接口
interface UserService{
    void hello();
}