Java基础学习（五）-面向对象

面向对象编程（OOP） - java的核心思想

1、初识面向对象

面向对象和面向过程

• 面向过程思想

• • 步骤清晰简单，第一步做什么，第二步做什么......

  • 面向过程适合处理一些较为简单的问题

• 面向对象思想

• • 物以类聚，分类的思维方式，思考问题首先解决需要哪些分类，然后对这些分类进行单独思考。最后才对分类下的细节进行面向过程的思索

  • 适合处理复杂的问题，适合处理多人协作的问题

对于描述复杂的事务，从宏观上把握，需要面向对象的思想来分析整个系统

但是具体到微观操作，仍然需要面向过程的思路去处理

什么是面向对象

• 本质：以类的方式组织代码，以对象的组织（封装）数据。

• 抽象

• 三大特性：封装、继承、多态

2、方法回顾和加深

方法的定义

• 修饰符

• 返回类型

• break:跳出switch，结束循环 和 return的区别

• 方法名：注意规范就OK，见名知意

• 参数列表：（参数类型，参数名）

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

方法的调用

• 静态方法：static修饰，其他类可以直接使用类.方法，和类一起加载

• 非静态方法：先用new实例化,可以调用，类实例化的时候加载

• 形参和实参：形式参数只是参数名字，实际参数是实际的值

• 值传递和引用传递：Java是值传递，只是传递值，没有传递地址。调用同类中的方法改变的是形参的值，不是实参

• this关键字

3、对象的创建分析

使用new关键字创建对象

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

• 类中的构造器也叫构造方法，是在创建对象时必须调用的。构造器有两个特点：

  • 必须和类的名字相同

  • 必须没有返回类型，也不能写void

构造器必须要掌握

• 创建一个类后什么都不写，也会存在一个方法 ：public 类名(){}

• new的本质是在调用构造器

• 定义有参构造之后，如果想使用无参构造，必须定义一个显示的无参构造方法

• 有多个构造方法时，比如有参和无参，会根据new的传参类型自动选择

• 生成有参构造器快捷键：alt+insert : 选择consturater

• 生成无参构造器快捷键：alt+insert : 选择下方select None

4、面向对象三大特征

封装

• 该露的露，该藏的藏

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

• 封装

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

  一般是封装属性，方法封装不太多，private关键字修饰

• 属性private修饰 - 私有，定义public修饰的set/get方法访问

继承

• extends的意思是扩展 ，子类是父类的扩展

• Java中类只有单继承，不支持多继承

• object类

  • 快捷键：Ctrl + h 查看继承关系

  • Java中所有的类都直接或者间接继承 Object类

• super

  • 私有的东西无法被继承

  • super调用父类的属性或者方法

  • super调用父类的构造方法，必须在构造方法中的第一个

  • super只能出现在子类的方法或者构造方法中

  • this()是调用本类的构造方法，super()是调用父类的构造方法

• 方法重写

  • 快捷键 alt +insert，选中 override

    A extends B
    B b = new A();
    //此时父类B的引用指向了A，b中的属性此时为父类中的值

  • 方法名必须相同

  • 参数列表必须相同

  • 修饰符：范围可以扩大，不能缩小

  • 范围：public > protected > default > private

  • 抛出的异常：只能被缩小，不能被扩大：比如 ClassNotFountException -> Exception 是不被允许的

多态

• Person extends Object
  Student extends Person
  Student s1 = new Student();
  Person s2 = new Student();
  Object s3 = new Student();

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

• 没联系的会爆ClassCastException! 类型转换异常

• 存在条件：继承关系，方法需要重写，父类引用指向子类对象

• final 和 private关键字修饰的部分修饰的都不能被重写

• instance关键字和类型转换

  • 判断是否满足父子关系：x instance y

  • x 指向的类型是不是 y 的子类型

    Object object = new Student();
    Student student = new Student();
    object instance Student; //true
    object instance Person; //true
    object instance Object; //true
    object instance AAAA; //false
    student instance Student; //true
    student instance Person; //true
    student instance Object; //true
    student instance AAAA; //false

  • 父类的引用指向子类

  • 父类想要用子类的方法，类型属于高转底，需要强制类型转换。例：

    Object obj = new Student();
    ((Student) obj) .子类方法();

一个比一个抽象，就是java的编程思想

static关键字

• 静态变量被类中的所有实例共享

• 推荐使用 类名.方法；当然类中直接使用 方法也可以

• 静态代码块，执行顺序：静态代码块>匿名代码块>构造方法

  public class Test{
      {
          //匿名代码块
      }
      static{
          //静态代码块，类加载就执行，且只执行一次，一次
      }
      public Test(){
          //构造方法
      }
  }
  ​

5、抽象类和接口

抽象类

• Java是单继承 ，但是接口可以多继承

• abstract 修饰类为抽象类

• abstract修饰可以只定义方法不去实现

• 不能new这个抽象类，只能靠子类去实现它

• 抽象方法必须写在抽象类中

接口

• 只有规范，自己无法写方法 ~ 专业的约束！约束和实现分离：面向接口编程

• 接口就是规范，定义的一组规则。例：如果你是...则必须...；如果你是汽车，就必须能跑

• 接口的本质是契约，就像法律一样，指=制定好了大家都遵守

• 声明接口的关键字是interface

• 接口中的所有定义都是抽象的，默认都是public interface .....();

  public interface UserService{
      //默认都是public interface
      void add(String name);
      void delete(String id);
  }

• 接口都必须有实现类

  public class UserServiceImpl implents UserService{
      @overload
      public void add(String name){
          
      }
       public void delete(String name){
          
      }
      //方法实现完才不报错
  }

• implents可以实现多个接口

  public class UserServiceImpl implents UserService,TestService

• 接口不是类，没有构造方法

6、内部类和OOP实战

成员内部类

成员内部类就是在内中再创一个类，内部类可以获得外部类的属性或私有属性，方法也可以

静态内部类

一个Java类中可以有多个class类，但只能有一个 public class类

局部内部类

在类的方法中定义的类

匿名内部类

类中一个class、一个public class类，直接new 类名().“方法”（），不用将实例保存到变量中