JAVA面向对象学习心得

JAVA面向对象学习心得

​ Java是面向对象编程的语言，在学习完Java基础语法后，下一个内容就是面向对象的内容了。那么什么是面向对象呢？下面就简单解释一下。

面向过程编程和面向对象编程

​ 提到面向对象编程就不得不先提到面向过程编程（POP），POP是一种基本的是一种基本的编程思想，是将一件事情按流程逐步实现。

​ 这种思想强调事情完成的过程，分析步骤写出相应的代码，如一个人走路，POP需要将走路的每一个步骤都用代码描述出来——先迈左脚还是 右脚，没一步的距离等，都是需要考虑到的。

​ 而面向过程编程思想（OOP），则不需要理会那么多繁琐的步骤，直接创建一个人的对象，赋予其走的行为就可以了。

​ 所以面向对象编程的思想更致力于将计算机中的世界描述的和现实当中一致，，将解决问题的所有参与对象创建出来，赋予对象对应的行为和属性让这些对象互相配合完成，实现最终效果。

例子：洗衣服：

如果用POP：得到衣服、得到搓衣板、得到洗衣服、得到水、搓洗。。。

如果用OOP：创建一个能洗衣服的工具：洗衣机，让洗衣机拥有洗衣服的行为，调用该行为即可。

类和对象

​ 具有相同的属性和行为的对象的集合，称为"一类"。类也可以称为模板。

​ 属性：描述对象的特征，在程序中，通过定义变量的形式表现属性。

​ 行为：描述对象的动作，在程序中，通过定义方法的形式表现行为。

在程序中，通过定义一个class去定义一个类。在类中定义变量描述属性，定义方法描述行为。

​ 定义类

​ [修饰符] class类名{

​ 属性(变量)

​ 行为(方法)

​ }

//用户类
public class User{
    //用户属性
    String name;
    int id;
    //用户方法
    void consumption(){
        System.out.println("我是用户的消费方法！");
    }
}

​ 定义对象

​ 类名 对象名=new 构造方法(参数);

public class Test{
    public static void main(String[] args){
        //创建用户对象
        User user = new User;
        //给对象属性赋值
        user.name = "小明";
        //通过对象调用方法
        user.consumption;
    }
}

类和对象的关系

​ 对象是类的具体表现，类是对象的合集(模板)。

​ 如包饺子时的模具就是一个类，每次用模具包出来的饺子都是一个个对象。

​ 先定义模板类，才能通过类创建出对象。

成员变量和局部变量

​ 成员变量：定义在类中的变量，称为成员变量，拥有默认值。

​ 局部变量：定义在方法中的变量，称为局部变量，没有默认值，赋值后才能使用。

成员变量和局部变量的区别以及生命周期

• 成员变量定义在类中，有默认值

• 局部变量定义在方法中，没有默认值

• 成员变量的生命周期：随着类创建对象，成员变量初始化，该对象回收，成员变量销毁

• 局部变量的生命周期：随着方法调用，局部变量初始化，方法调用结束，局部变量销毁

构造方法

​ 概念：是一个特殊的方法，没有返回值，方法名和类名一致。每个类在定义时，都有一个默认隐藏的无参数的构造方法，在创建对象时自动调用，通常用于初始化成员变量。

​ 特点：

• 没有返回值(没有返回值，并不是void)，方法名和类名必须相同
• 每个类默认有一个无参数的构造方法，方法体中没有内容
• 构造方法不能通过.操作符调用，在创建对象时自动调用，所以通常用于初始化成员变量
• 如果自己写了有参的构造方法，默认无参的构造方法就会失效，如果想要使用无参的构造方法，需要再写出来才能使用
• 构造方法可以限制创建对象时的参数
• 可以同时存在多个不同参数的构造方法，这称为构造方法的重载

面向对象三大特性

封装

​ 简述：使用private关键字对属性进行修饰，可以防止除自身类之外的地方对该属性进行访问。

​ 这样可以保护关键属性，隐藏类内部的实现细节，再对外提供一组公开的get/set方法用于对该属性的赋值和读取。

步骤

• 创建类，编写成员变量(属性)，给成员变量添加private修饰符

  public class Person{ 
      private String name; 
      private int age; 
  }
  

• 给成员变量写一个公开的set方法

  public void setName(String name){ 
      this.name=name;
  }
  public void setAge(int age){
      this.age=age; 
  }
  

• 给成员变量写一个公开的get方法

public String getName(){ 
    return this.name; 
}
public int getAge(){
    return this.age;
}

• 访问时不能通过.访问，只能通过set和get访问

public class Main(){
    public static void main(String[] args){ 
        Person p = new Person(); 
        p.setName("小明")；
        Sustem.out.println(p.getNmae());
    }
}

继承

类A可以通过extends关键字继承类B。

语法：class 类 A extends **类 ** B

类A称为子类、派生类、衍生类

类B称为父类、基类、超类

继承后，子类可以访问父类中非私有的属性和方法。

不同的子类中相同的代码，都可以定义在父类中，减少子类中的代码冗余。

如小孩类和老人类都有姓名、年龄等属性，都有吃、睡等方法，那么就可以定义一个人类，将这些属性

和方法写在里面，让小孩类和老人类继承人类。

继承的特点

• 如果多个类之中有相同或类似的代码，可以将这些代码提出来定义在一个公共的类中，这个类就是父类。再让那些类去继承这个父类，这样就能减少子类的重复代码

• 子类对象可以直接访问父类中非私有的属性和方法

• 子类可以对父类中的方法进行拓展或覆盖，这称为方法重写，重写后，子类对象再调用该方法时，执行的是重写后的内容

• java中是单继承，一个子类只能有一个父类，一个父类可以有多个子类。

• java中可以多重继承，类A可以继承类B，类B也可以继承类C，这时类A可以访问类B和类C中非私有的成员。

• 任何类都是Object类的子类。

• 在创建子类对象时，先执行父类中相应的构造方法。

方法重写override

​ 简述：当子类继承父类后，可以对父类中非私有的方法进行拓展。这个行为称为方法重写。重写用于子类拓展父类的某个方法。

重写要求

• 方法名、参数列表、返回值必须和父类一致
• 访问权限不能比父类更严格(访问修饰符的范围要么相同要么更大)
• 不能抛出比父类更大的异常

方法重载overload

​ 简述：在一个类中，如果多个方法的方法名相同，参数列表不同(参数类型不同或参数数量不同)时，这些方法称为重载的方法。同名不同参。

重载用于在一个类中，某个方法在不同的条件下，执行不同的内容。

重载要求

• 方法名相同
• 参数列表不同

this和super

​ this：表示当前对象或者构造方法，两种不同用法的区别是：

​ this.属性。表示当前类的对象，只能在方法当中使用，通常用于在方法中区分成员变量和参数。

​ this():此时的this()表示，当前类的一个构造对应的构造方法。当this被当作构造方法使用时，它只能写在构造方法的第一行。

​ **super：**可以表示父类的对象或者构造方法。

​ super.属性：表示当前类的父类的对象，用法和this相似

​ super():表示调用父类的一个构造方法，用法和this相似

继承时的特点

​ 如果父类中重载了构造方法，默认无参构造方法就会失效，同时子类也会报错。这时需要在子类的某个构造方法中，再调用父类的那个重载的构造方法即可。

多态

​ 多态是面向对象语言的一种特性，通常在代码中用于：需要使用一个父类对象时，实际传递的是一个子类对象，这时可以将子类对象当做父类对象使用。这种特性称为多态。

​ 在不使用多态特性的情况下，假如要调用计算图形面积的方法，参数为圆时，输出圆的面积，参数为正方形时，输出正方形的面积。如果有新的图形出现，就要再重载这个计算面积的方法。

​ 如果使用多态，就可以不用重载那些方法，只需要定义一个参数为所有图形的父类，调用该父类对象的计算方法。具体计算方法交给子类重写。这样就免去了重载的过程，只定义一个参数为父类对象的方法，实际传递子类对象，调用方法时执行的是子类重写后的内容。

实现多态特性的前提

• 必须在继承关系中
• 子类的对象保存在父类的变量中（也称为向上转型）

抽象类和抽象方法

抽象方法： 访问修饰符 abstract 返回值 方法名 ( 参数列表 );

​ 如果某个父类中的方法在定义时无法决定要做什么，而是由其子类负责实现时，该方法可以定义为抽象方法。这里的方法不能有方法体(大括号)。这时该抽象方法所在的类，也必须用abstract修饰，让其成为一个抽象类。

特点：

• 抽象方法没有方法体
• 抽象方法只能定义在抽象类或接口中
• 抽象方法通常需要子类重写
• abstract不能修饰构造方法和静态方法

抽象类： 访问修饰符 abstract class 类名 {}

​ 如果一个类当中有抽象方法，该类必定得是抽象类。

特点：

• 抽象类不能实例化(不能创建抽象类的对象)
• 抽象类中可以有抽象方法，也可以有普通方法、构造方法(除抽象方法外和普通类一样)
• 抽象类的构造方法在创建其子类对象时自动执行，但不会创建抽象类的对象
• 某个类如果继承了抽象类，那么这个类要么也是抽象类，否则就要重写抽象类中的所有抽象方法
• 通常抽象类都需要子类继承后重写其中的抽象方法

接口interface

​ 在java中，数据类型分为原始类型和引用类型。

​ 引用类型分为：数组、类和接口。所以接口是一种数据类型，类似于类。类使用class定义，接口使用interface定义。

​ 如果一个抽象类中的所有方法都是抽象方法，那么就可以将这个抽象类定义为接口。

定义接口

访问修饰符 interface 接口名 {

}

简述

​ 由于java是单继承，如果类A想要继承多个"父类"中的内容时，就不能使用extends，但可以使用implements实现多个接口而达到多继承的目的。

​ 接口是一个完全抽象类，其中的方法都是被public abstract修饰的公开抽象方法，其中的属性，都是被public static final修饰的公开的静态常量，需要在定义时赋值才能使用。

​ 接口和抽象类一样，通常需要子类继承，但继承接口，称为"实现接口"。使用implements关键字实现。

特点

• 接口不能实例化
• 接口中的抽象方法默认使用public abstract修饰，属性默认使用public static final修饰接口中没有构造方法和普通方法
• jdk1.8后，接口中允许定义"default 修饰的默认方法"和"static修饰的静态方法"
• 接口的实现类，必须重写接口中的抽象方法

接口和抽象类的异同

相同点

• 接口和抽象类都不能实例化
• 子类继承抽象类或实现接口后，都要重写其中所有的抽象方法

不同点

• 接口中没有构造方法，抽象类中有构造方法
• 接口中的抽象方法默认被public abstract修饰，可以不写，抽象类中的抽象方法需要写出abstract关键字
• 接口中可以存在default方法，抽象类中不能存在default方法
• 接口中的属性都是被public static final修饰的静态常量，抽象类中的属性可以自定义
• 一个类可以实现多个接口，但只能继承一个类

关键字static

​ static 可以修饰属性、方法、代码块 ({}) ，被 static 修饰的内容，称为静态成员。

​ 静态成员在类加载时就保存到内存中，所以可以脱离对象存在。在访问时，直接通过类名访问即可。

​ Java中的Math类中大量使用了static修饰属性和方法，所以直接使用Math进行调用。

特点：

• 被static修饰的属性、方法或代码块称为静态成员，随着类加载而加载到内存中，只加载一次
• 静态成员无需对象参与，通过类名即可访问，也可以使用对象访问。
• 静态方法中不能使用非静态成员，可以在静态方法中定义局部变量
• 静态代码块随着类加载而执行一次，优先于构造方法执行

结语：

	在面向对象这一部分内容当中，有不少关键字和语法是需要我们去学习和记忆的。
	所以，多练习才是能更快掌握这部分知识的最好的方法。