面向对象(oop)

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

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

• 类与对象的关系：类是对象的模板

类与对象的创建

• 类创建

  public class Demo01 {
      String name;//类属性
      //类方法
      public void study(){
          System.out.println("OK!");
      }
  }
  

• 对象的创建

  public static void main(String[] args) {
          //类实例化后会返回自己的一个对象
          //demo01就是Demo01类的具体实例
          //创建demo01实例化Demo01类
          Demo01 demo01 = new Demo01();
      }
  

构造器

• 一个类即使为空，也会存在一个无参数构造方法

  • 方法名和类名一致，没有返回值，public，没有参数
  • 用来实例化初始值

  public class Demo01 {
      //无参数构造方法
      public Demo01() {
      }
      String name;//类属性
      //类方法
      public void study(){
          System.out.println("OK!");
      }
  }
  

• new关键字本质为调用构造器

• 一旦定义了有参数构造方法，无参就必须显示定义

• alt+insert生成构造器

创建对象内存分析

封装

• 特点：

  • 高内聚，低耦合

  • 属性私有（private）其他类无法调用；若要调用需要通过get/set方法进行调用

• 作用：

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

  • 隐藏代码的实现细节

  • 统一接口

  • 提高系统的可维护性

  private String name;
      private int id;
      //get set 方法
      public String getName() {
          return name;
      }
      public void setName(String name) {
          this.name = name;
      }
      public int getId() {
          return id;
      }
      public void setId(int id) {
          this.id = id;
      }
  

继承

• 定义

  //子类Students继承父类Person
  public class Student extends Person{
      //属性私有
      private int grade;
      //get set 方法
      public int getGrade() {
          return grade;
      }
      public void setGrade(int grade) {
          this.grade = grade;
      }
  }
  

• 关键字：extends（扩展，子类是父类的扩展）

• 特点：

  • 所有类都继承自Object类

  • java只有单继承，没有多继承（只能有一个父类）

  • 子类拥有父类的全部方法和属性（前提是public方法和属性）

  • private无法继承

  • java中所有的类间接或直接继承自object类

  • final修饰后不能继承

• ctrl+H：调出继承族谱

super

• 作用：

  • 可以调用父类的属性与方法；继承条件下可以使用

  //父类
  public class Person {
      protected String name = "Person";//若修饰为private，则super也无法调用
      private int age;
  }
  //子类
  public class Student extends Person{
      private String name="Student";
      private int grade;
      public void test(String name){
          System.out.println(name);
          System.out.println(this.name);
          System.out.println(super.name);
      }
  }
  //main
  public class Application {
      public static void main(String[] args) {
          String name="main";
          Student student = new Student();
          student.test(name);
      }
  }
  //输出
  main
  Student
  Person
  

• 特点：

  • 子类无参构造默认super调用父类的构造方法
  • super调用父类的构造方法，必须在构造方法的第一句
  • super必须在子类的方法或者构造方法中
  • super和this不能同时调用构造方法
    • this指本类，super指父类

方法的重写

• 定义

  //父类
  public class Person {
      public static void test1(){
          System.out.println("Person");
      }
  }
  //子类
  public class Student extends Person{
      //子类重写了父类的test1（）方法
      public static void test1(){
          System.out.println("Student");
      }
  }
  

• 特点：

  • 重写是方法的重写，属性没有重写
  • 重写需要有继承关系，子类重写父类的方法
  • 方法名相同，参数列表想同
  • 修饰符：范围可以扩大不能缩小
  • 非静态的，私有的方法不能重写
  • 抛出的异常：可以被缩小，但不能扩大
  • 方法名一致，方法体不同

• 作用

  • 父类的功能，子类不一定适用

多态

• 特点：

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

• 存在条件：

  • 继承关系，方法需要重写，父类的引用指向子类的对象

   public class Application {
      public static void main(String[] args) {
          //子类引用指向子类对象
          Student student = new Student();
          //父类引用指向子类对象；不能调用子类独有的方法(多态)
          Person student1 = new Student();
          Object student2 = new Student();
      }
  }
  

instanceof

• A instanceof B ；

  //类关系
  //Objec》D
  //Objec》B》c
  //Objec》B》A
  Object Objec= new A();
  System.out.println(Object instanceof A);//True
  System.out.println(Object instanceof B);//True B被A继承
  System.out.println(Object instanceof Objec);//True Objec被A间接继承
  System.out.println(Object instanceof C);//C和A无间接或直接继承关系
  System.out.println(Object instanceof D);//D和A无间接或直接继承关系
  B b= new A();
  System.out.println(B instanceof D);//编译报错 B和D无间接或直接继承关系
  

类转换

• 父类的引用指向子类的对象

  //向下强制转型（父类转子类）
  //Objec》B》A
  B a = new A();
  B b = (A)a;
  

  //向上自动转型（子类转父类）--可能丢失子类自己本来的方法
  A a = new A();
  B b = a;
  

static

• 特点

  • 与类一起加载
  • 只执行一次

• 静态导入包：import static，可以直接导入方法或者属性

• 静态代码块：static{}，用来赋予初始值

抽象类

• abstract修饰的类为抽象类
• abstract修饰的方法为抽象方法，只有方法名字，没有方法的实现
• 接口可以多继承，抽象为单继承
• 特点：
  • 不能new抽象类，只能靠子类继承来实现
  • 抽象类中可以写普通方法，抽象方法必须存在抽象类中
  • 抽象类的所有方法，继承了他的子类，都必须要实现他的方法（重写），除非子类也抽象

接口

• 特点：
  • 只有规范，无法写普通方法
  • 专业的约束：约束和实现分离
  • 接口都需要实现类，实现类通过implements实现接口，并且必须重写其所有方法
• 接口的本质是契约
  • interface关键字
• 接口里的方法默认public abstract，默认常量public static final
• implements可以实现多个接口

内部类

• 可以通过外部类来实例化内部类
• 可以获得外部类的私有属性
• 一个Java类中可以有多个类，但只能有一个public类
• 类的多种写法

面向对象的简单概括

原文：https://www.cnblogs.com/mr0fly/p/14143282.html