【JavaSE】Java面向对象(上)

前言：

推荐免费Java基础入门视频：【狂神说Java】Java零基础学习视频通俗易懂_哔哩哔哩_bilibili

什么是面向对象

• 面向过程思想：

  • 步骤清晰简单，第一步，第二布…
  • 面对过程适合处理一些较为简单的问题。

• 面向对象思想：

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

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

• 面向对象编程(Object-Oriented Programming,OOP)

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

• 抽象

• 三大特性：

  • 封装
  • 继承
  • 多态

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

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

回顾方法的定义

• 方法的定义：

  • 修饰符
  • 返回类型
  • break和return的区别
  • 方法名
  • 参数列表
  • 异常抛出

  //main方法
    public static void main(String[] args) {
    }
    /*
      修饰符 返回值类型 方法名(...)
     */
    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 {
    
    }

回顾方法的调用

• 方法的调用：

  • 静态方法
  • 非静态方法
  • 形参和实参
  • 值传递和引用传递
  • this关键字

  package com.jokerdig.oop;
  
  /**
   * @author Joker大雄
   * @data 2021/8/14 - 18:01
   **/
  public class Demo02 {
      //静态方法 static
      //非静态
      public static void main(String[] args) {
  
       //  Student student = new Student();
       //  student.say();
        int a= add(1,2);
        System.out.println(a);
        //值传递
        int b = 1;
        System.out.println(b);//1
        Demo02.change(b);
        System.out.println(b);//1
  
        //引用传递
          Person person = new Person();
          System.out.println(person.name);//null
          Demo02.change(person);
          System.out.println(person.name);//引用传递值
      }
      //static和类一起加载
      public static void a(){
          //b();
      }
      //类实例化之后才存在
      public void b(){
      }
      //形参
      public static int add(int a,int b){
          return a+b;
      }
      //传递值,返回值为空
      public static void change(int b){
          b=10;
      }
  
      public static void change(Person person){
          //person是一个对象，修改类Person类里的全局变量name
          person.name="引用传递值";
      }
  }
  //定义了一个Person类，有一个属性 name
  class Person{
      String name;//null
  }

类与对象的创建

类与对象的关系：

• 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
  • 动物、植物、手机、电脑…
  • Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为。
• 对象是抽象概念的具体实例
  • 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。
  • 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

创建与初始化对象：

• 使用new关键字创建对象

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

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

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

• 构造器必须要掌握

  //Application类
  
  //一个项目应该只存在一个main方法
  public class Application {
      public static void main(String[] args) {
          //类：抽象的，实例化new
          Student student = new Student();
          Student student1 = new Student();
  
          student.name="小明";
          student.age=10;
  
          System.out.println(student.name);
          System.out.println(student.age);
  
          student1.name="小红";
          student1.age=9;
          System.out.println(student1.name);
          System.out.println(student1.age);
  
      }
  }

  //Student类
  public class Student {
  
      //属性：字段
      String name;
      int age;
  
      //方法
      public void study(){
          System.out.println(this.name+"在学习");
      }
  
      //方法
      public void say(){
          System.out.println("学生上课偷偷说话");
      }
  }

构造器详解

• 构造器

  • 和类名相同
  • 没有返回值

• 作用：

  • new 本质在调用构造方法
  • 初始画对象的值

• 注意：

  • 定义有参构造后，如果想用无参，显示的定义一个无参构造

• 实例化初始值：

  • 使用new关键字，本质是在调用构造器
  • 用来初始化值
  • alt+ins(insert) 生成构造器快捷键

  //一个类即使什么都不写，也会存在一个方法，为构造器
      String name;
      //实例化初始值
  
      //无参构造
      public Persons(){
         // this.name = "构造器测试名字";
      }
  
      //有参构造  一旦定义有参构造，无参构造就必须显示定义
      public Persons(String name){
          this.name = name;
      }
  
  //main
   public static void main(String[] args) {
          //实例化对象
         // Persons person = new Persons();
          Persons person = new Persons("有参构造");
          System.out.println(person.name);
      }

创建对象内存分析

• 创建对象内存简单分析

  

  //pet类
  public class Pet {
      String name;
      int age;
  
      public void shout(){
          System.out.println("叫了一声");
      }
  }
  //main
   public static void main(String[] args) {
          Pet dog = new Pet();
          dog.name="二狗";
          dog.age = 3;
          dog.shout();
      }

简单小结类与对象

• 类与对象：
  • 类是一个模板：抽象，对象是一个具体的实例。
• 方法：
  • 定义，调用
• 对应的引用：
  • 引用类型：基本类型
  • 对象是通过引用来操作的：栈 -> 堆
• 属性：字段Field 成员变量
  • 默认初始化：
    • 数字：0 0.0
    • char：u0000
    • boolean：false
    • 引用：null
  • 修饰符：属性类型 属性名 =属性值
• 对象的创建和使用
  • 必须使用new关键字创建对象，构造器
  • 对象的属性
  • 对象的方法
• 类：
  • 静态的属性
  • 动态的方法

封装详解

• 该露的露，该藏的藏

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

• 封装（数据的隐藏）

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

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

    //private 私有
      /*
       封装的优势：
       1. 提高程序的安全性，保护数据
       2. 隐藏代码的实现细节
       3. 同意接口
       4. 系统可维护性增加
       */
  
      private String name; //名字
      private int id;    //学号
      private char set;  //性别
  
      //get/set方法
      //get获取这个数据
      public String getName() {
          return this.name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  //main
  public static void main(String[] args) {
          Students st = new Students();
          st.setName("通过set赋值name");
          System.out.println(st.getName());
  
      }

什么是继承

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

• extands的意思是"扩展"。子类是父类的扩展。

• Java中类只有单继承，没有多继承！

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

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

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

• object类(每个类都默认继承)

  //继承
       Person01 per = new Person01();
       //name是persons中定义的
       // 当person01继承persons时也可使用其中公共的方法等
       per.name="222";
       System.out.println(per.name);
       //Java中所有的类都默认继承Object

super详解

• super

  • super调用父类的构造方法，必须在构造方法的第一个。
  • super必须出现在子类的方法或构造方法中。
  • super和this不能同时调用构造方法。

• this

  • 代表的对象不同，this调用本对象，super调用父类的应用。
  • this没有继承也可以用，super只能在继承条件才可以使用。
  • this();本类的构造，super();父类的构造。

  //继承
  public class Person01 extends Persons{
      private String name1="子类super";
  
      public void test(String name1){
          System.out.println(name1);//传输的值
          System.out.println(this.name1);//当前类的值
          System.out.println(super.name1);//父类的值
      }
      public void print(){
          System.out.println("子类print方法");
      }
      //方法也可访问
      public void test1(){
          print();
          this.print();
          super.print();
      }
      
      public Person01() {
         //隐藏代码：调用了父类的无参构造
          super();//这里默认隐藏了，必须在第一行
          System.out.println("person01");
      }
  }
  //main
    public static void main(String[] args) {
          //super
          Person01 per = new Person01();
          per.test("main测试super");
      }

方法的重写

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

• 重写要求：

  • 方法名必须相同。
  • 参数列表必须相同
  • 修饰服：范围可扩大但不能缩小。(public>protected>default>private)
  • 抛出的异常：范围可以被缩小但不能扩大。

• 重写子类的方法必须和父类一致，方法体不同。

• 重写原因：

  • 父类的功能，子类不一定需要或不能满足子类需求。
  • Alt+Ins ：override

  //A类
  public class A extends B{
      //重写
  
      @Override
      public void test() {
          System.out.println("A->test");
      }
  }
  
  //B类
  public class B {
      //重写都是方法的重写
      public  void test(){
          System.out.println("B->test");
      }
  }
  //main
  public static void main(String[] args) {
        //方法重写
          A a = new A();
          a.test();
          //有继承关系后，父类的引用指向了子类
          B b = new A();
          b.test();
      }
  }