面向对象编程

1.初识面向对象

面向过程&面向对象

• 面向过程思想

  • 步骤清晰简单，第一步，第二步做什么。。
  • 适合处理较为简单的问题
  • 性能高
  • 线性思维

• 面向对象思想

  • 分类的思维模式，思考问题解决需要哪些分类，然后对这些分类进行单独思考
  • 宏观上把握，整体上合理分析，微观细节，仍需要面向过程的思路处理
  • 易维护，易复用，易拓展

什么是面向对象

• 面向对象编程（Object-Oriented Programming，OOP)

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

• 抽象

• 三大特性：

  • 封装
  • 继承
  • 多态

• 对象：具体的事物。类是抽象的，是对对象的抽象

• 类是对象的模板

类与对象的关系

• 类是一种抽象的数据类型，是对某一类事物的整体描述
• 对象是抽象概念的具体实例

类

• 类中包含

  静态的属性：属性

  动态的行为：方法

2. 方法回顾加深

• 方法的定义

  • 修饰符 ：public /private/protected/default
  • 返回值类型
  • break ：跳出switch,j结束循环，和return 相区别
  • 方法名 ：见名知意，符合规则
  • 参数列表 :参数类型，参数名 … 可变形参
  • 异常抛出

• 方法的调用

  • 静态方法 ：通过类名直接调用，随类一起加载 只能调用静态方法。
  • 非静态方法 ：类实例化对象调用 类实例化后才加载，静态非静态方法都可调用
  • 形参和实参：参数类型要 一 一对应
  • 值传递和引用传递：
    • 值传递：基本数据类型参数，传递的是实际存在的数值
    • 引用传递：对象，传的地址
  • this关键字

3.对象的创建分析

创建与初始化对象

• 使用new关键字创建对象，分配内存空间并给创建好的对象进行默认的初始化以及对类中构造器的调用。

• 类中的构造器(构造方法)，是进行创建对象时必须调用的，构造器有以下俩特点

  1. 必须和类的名字相同

  2. 没有返回值类型，也不能写void

  3. 格式：权限修饰符+类名() { }

  4. 一个类中至少有一个构造器

     class Person{
         //构造器
         public Person(){
          
         }
     }
     

  • 有参构造器
    1. 可与其他形参列表不同的构造器构成重载
    2. 一旦定义了显示的构造器，系统就不再提供默认的空参构造器

对象的使用

• 对象的属性和方法

  Person people=new Person();
  people.say();//调用方法
  people.name; //调用属性
  

4.面向对象三大特性

封装

• 该隐藏的隐藏，该暴露的暴露

• 程序的设计要“高内聚，低耦合”(高内聚：类内部的数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法供外部使用)

• 封装（数据的隐藏）

  • 属性私有，get()/set() 方法对其操作

    class Person{
        private int age;
        private String name;
        public int getAge(){
            return this.age;
        }
        public void setAge(int age){
            this.age=age;
        }
    }
    

• 优点

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

继承

• 继承的本质是对某一批类的抽象；

• extends “扩展”，子类是父类的扩展 使用此关键字来实现继承

• java中只有单继承，没有多继承

• 继承是类和类之间 的关系

• 子类与父类的关系，从意义上来讲具有“ is a” 的关系。

• object类: Java中所有的类，都默认直接或间接继承object

• super :

  • 调用父类的属性和方法 super；调用父类的构造方法
  • 隐式的调用了父类的无参构造器，只能出现在子类方法或构造方法中
  • super和this不能同时调用构造方法

• VS this

  • 代表的对象不同

    • this 本身调用者这个对象
    • super 父类对象的引用

  • 前提

    • this :没有继承也可以使用
    • super 只能在继承中使用

  • 构造方法：

    • this() :本类的构造器
    • super() :父类构造器

• final

  • final修饰变量：此变量为一个常量
  • final修饰的类不可被继承（断子绝孙）
  • final修饰的方法 :不能被重写
  • final修饰局部变量，一旦赋值，只能使用，不可改变。

  方法重写

  • 前提条件：有继承关系，子类重写父类的方法

  • 规则（子类的方法和父类方法必须一致，方法体不同）

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

  • 非静态方法的重写

  • 私有方法 static 修饰的方法 ，final 修饰的方法 不能被重写

  • 私有的属性和方法不能被继承

  • 为什么要重写：

    ​ 1. 父类的功能，子类不一定需要，或不一定满足；

    ​ 2. @override

多态

• 一种事物的多种形态

• 继承是多态的前提，类型转换异常

• 何为多态性

  父类的引用指向子类的对象（子类的对象赋给父类的引用）

• 子类重写父类的方法，执行子类的方法

• 编译看左，运行看右

• 方法的多态，属性没有多态

instanceof

• a instanceof A :判断对象a是否是类A的实例
• 使用：避免向下转型时出现class Cast Exception 的异常，在转型之前进行 instanceof 的判断
  • 向下转型： 父类转为子类（强制转换）
  • 向上转型：子类转为父类
    • 方便方法的调用，减少重复的代码

5. static（随类加载）

• static 修饰变量

  • 静态变量 ：在类内存中只有一个，能被类中所有实例所共享
  • 非静态变量 ：成员变量和全局变量

• static 修饰方法：

  • 静态方法：只能调用静态方法和静态变量（生命周期不相同）工具类方法
  • 非静态方法：可调用静态和非静态的方法

• 可通过类名 .方法 类名 .属性 调用

• 修饰代码块：初始化变量 ，只执行一次

• 静态导入包

  import static java.lang.Math.random;
  
  class Person{
      public static void main(String[] args){
          System.out.print(random());
      }
  }
  

6.抽象类和接口

抽象类

• abstract 修饰

  修饰方法：抽象方法

  修饰类：抽象类

• 抽象类中可以没有抽象方法，但有抽象方法的类一定是抽象类

• 抽象类不能创建实例对象，用来让子类继承

• 抽象方法：只有方法的声明，没有方法体，子类来重写实现

• 子类继承抽象类，则该子类必须重写抽象类中的抽象方法，不然，该子类也要声明为抽象类

• 存在构造器

接口

• 只有规范：一组规则，实现类来遵守
• 声明使用interface 关键字
• 可以实现多继承，易扩展
• 实现类实现接口使用关键字 implements
• 接口中的方法都是抽象的，不同的实现类需要对接口中的所有方法重写
• 接口中定义的属性都是常量 public static final
• 接口不能被实例化，接口中没有构造方法

7.内部类及opp实战

内部类

• 定义：就是在类内部定义一个类

  public class Outer{
      public void out(){
          System.out.print("外部类方法");
      }
      class Inner{
          public void in(){
              System.out.print("内部类方法");
          }
      }
  }
  

• 分类

  1. 成员内部类
  2. 静态内部类
  3. 局部内部类
  4. 匿名内部类