Java基础学习笔记5——面向对象

Java基础学习笔记5——面向对象

面向过程与面向对象

• 面向过程思想

  • 步骤清晰记得，第一步做什么，第二步做什么。。。

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

• 面向对象思想

  • 分类的思维模式，先考虑如何分类，再对分类进行单独思考，进一步细化

  • 面向对象适合复杂的问题，适合处理需要多人协作的问题

• 对于复杂的事物，为了从宏观上把握，从整体上合理分析，就需要要面向对象的思维去分析整个系统，而到了具体的微观操作，仍然要用面向过程的思路去处理

• 什么是面向对象

  • 面向对象编程（OOP）

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

  • 抽象：把一类相似的问题抽象出一个共性作为类

  • 三大特性

    • 封装：把数据封装保护起来

    • 继承：子承父方法

    • 多态：龙生九子各有不同，每个类具体的对象是不同的

  • 从认知的角度来说是先有对象后有类，对象是具体的事物，类是抽象的，是对象的抽象

  • 从代码的角度是先有类后有对象，类是对象的模板

 

方法加深

• 静态方法

  • 使用static关键字修饰的方法

  • 静态方法与类一起加载，在调用时直接使用类名.方法名调用

• 非静态方法

  • 没有使用static关键字修饰的方法

  • 非静态方法只有在类实例化后加载，调用时要有一个实例化的具体对象来调用

  • 实例化：类名 对象名 = new 类名();

• 静态方法不能访问非静态方法

• 值传递与引用传递

  • 值传递的本质是：我把值复制一份给你，你把它改成什么样与我无关

  • 引用传递的本质是：我把值放在哪里告诉你，更改后就全部更改

 

类与对象的关系、创建

1. 类与对象的关系

   • 类是一种抽象的数据类型，它是对一类事物的描述，但它不代表某一个具体的事物

     • 例如人类，植物，动物

   • 对象是抽象概念的具体实例，能够体现出特点，展现出具体功能的实例，而不是一个抽象的概念

     • 例如张三是一个具体的人，张三的狗旺财

2. 创建与初始化对象

   • 创建对象使用new关键字创建

   • 使用new关键字创建时，系统会给对象分配具体的内存空间，对对象进行默认初始化和调用类中的构造器

 

构造器

• 构造器也称构造方法，是在创建对象时必须调用的方法

  • 构造器名必须与类名相同

  • 没有返回值，不写void

  • 在定义类时系统自动帮你隐式生成一个无参构造器，而在自己定义了有参构造器之后就必须自己显式定义一个无参构造器

• 使用new关键字时本质就是在调用构造器

• 构造器的主要作用就是进行参数的初始化

 

封装

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

• 封装就是把自己的数据藏起来，用户只能通过我们定义的接口（方法）才能访问

• 把属性私有化，只能通过get/set方法访问

  • 使用private关键字进行私有化操作：private 数据类型 变量名

  • 然后使用get/set方法进行数据的设置与获取

  • 可以在set方法内设置条件，阻挡错误信息

  private int age;
  ​
  public void setAge(int age){
      if(age<150 || age>0 ){
          this.age = age;
     }else{
          System.out.println("年龄错误");
     }
      
  }
  ​
  public int getAge(){
      return age;
  }

   

• 封装的主要作用

  • 提高程序的安全性，保护数据安全

  • 隐藏代码实现细节

  • 统一操作接口

  • 系统的可维护性增加

 

继承

• 继承的本质就是对一部分类的抽象，从而更好的对世界建模，例如学生类与老师类上有人类这个大类

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

• 继承是一种类与类之间的关系，除此之外还有依赖、组合、聚合

• 继承关系的两个类，一个是子类（派生类）一个是父类（基类）。子类继承父类，使用extends表示

public class Student extends Person{
    //学生类继承了Person类
}

• 继承是继承所有的公共的属性和方法

• java中的类是单继承，没有多继承。就是一个儿子只能有一个爸爸，一个爸爸可以有多个儿子

• object类

  • 所有类默认继承object类

  • object类是所有类的父类

• super与this

  • super调用父类的构造方法，必须写在子类构造方法的第一行，不写隐式生成

  • 使用super可以调用父类的方法

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

  • super和this不能同时出现在子类构造方法

  • this与super的不同

    • this表示所写的这个对象 super本身父类的对象

    • this没有继承也可以使用 super 只有在继承了类的条件下才可以使用

• 重写

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

  • 为什么：父类的功能子类不一定需要或不能满足使用

  • 规范

    • 方法名必须相同

    • 参数列表必须相同

    • 修饰符范围可以扩大不能缩小 public>protected>default>private

    • 抛出的异常类型可以缩小不可以扩大 SqlException

 

多态

• 即一个方法可以根据发送对象的不同而采取多种不同的行为方式

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

public class Student extends Person{
    //学生类继承了Person类
}
​
//一个对象的类型是确定的
new Student;
​
//但是可以指向对象的引用的类型很多
//student能调用的方法都是自己和父类的
Student s1 = new Student;
//可以指向子类，但是不能调用子类独有的方法，对象有哪些方法 主要看引用类型
Person s2 = new Student;
Object s3 = new Student;
​
    
    

• 存在条件

  • 有继承关系

  • 子类重写父类方法

  • 父类引用指向子类对象

• 类型转换

  • instanceof

    • 用于判断两个类之间是否存在继承关系

    • X类 instanceof Y类 两个类如果存在继承关系就返回true，反之false

  • 类型转换与基本类型的转换差不多

  • 把子类转换为父类，向上转型，会丢失子类的方法

  • 把父类转换为子类，向下转型，需要强制转型

  public class Student extends Person{
      //学生类继承了Person类
      public void go(){
          System.out.println("go")
     }
  }
  Person p = new Student();
  ((Student)p).go();//父类调用子类方法需要强制转型为子类
  ​
  ​

static详解

• static静态的

• 使用static修饰的变量和方法在类加载时就运行了

• static修饰的变量可以直接使用类名.变量名调用，而不用实例化对象，静态变量由这个类的所有东西共享

• static修饰的方法与变量相同直接使用类名.方法名调用

• 非静态方法会静态方法可以调用静态方法，但静态方法不能调用非静态方法

• 代码块

  • 代码中直接写在一对大括号之间的代码

  • 静态代码块在大括号之前使用static修饰，在所有方法之前加载，静态代码块只有在第一次加载类时加载

  • 匿名代码块无任何修饰就是一对大括号，在静态代码块之后，构造方法之前加载，常用于初始化变量

  {
      //匿名代码块
  }
  static{
      //静态代码块
  }

   

• 静态导入包

//这样导入就可以直接使用random方法
import static java.lang.Math.random;

 

 

抽象类

• 使用abstract修饰的类和方法就是抽象类和抽象方法

• 抽象类不能使用new关键字实例化，必须由子类去继承实现

• 抽象类中可以有普通方法

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

• 继承了抽象类就必须重写它的抽象方法

public abstract class Ab{
    //抽象方法只用定义方法名
    public abstract Hello();
}

 

接口

• 普通类，抽象类与接口

  • 普通类只用具体的实现

  • 抽象类具体实现和规范（抽象方法）都有

  • 接口只用规范

• 接口就是规范，一系列的规则，体现世界中“如果你是...，则必须能...”的思想，如果你是鸟，则必须能飞。如果你是汽车，则必须能跑

• 接口的本质是契约，制定好后大家都有遵守

• OO的精髓就是对对象的抽象，最能体现这一点的就是接口

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

• 使用implements关键字实现接口，实现接口需要重写接口中的所有方法，可以同时实现多个接口（伪多继承）

public interface UserService{
    //接口中定义方法默认是公共的抽象的 public abstract 所以可以省略
    void add(String name);
}
public class User implements UserService{
    public void add(String name){
        
   }
}
    

 

内部类

• 内部类就是在一个类类名再定义一个类，比如在A类中定义B类，A就是B的外部类，B就是A的内部类

• 内部类可以调用外部类的私有变量

• 内部类的实例为 外部类名.内部类名 内部类对象名 = 外部类对象.new 内部类名（A.B b = a.new B()）

• 不同的内部类

  • 成员内部类：类中的类

  • 静态内部类：使用static修饰的内部类

  • 局部内部类：定义在方法中的内部类

  • 匿名内部类：实例时没有对象名的内部类