小滴课堂-学习笔记：（6）Java 面向对象编程OOP

77 阅读 0 评论 51 点赞

我是靠谱客的博主温婉服饰，最近开发中收集的这篇文章主要介绍小滴课堂-学习笔记：（6）Java 面向对象编程OOP，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

logo 愿景："让编程不再难学，让技术与生活更加有趣"

更多架构课程请访问 xdclass.net

第1集什么是面向对象对象编程OOP

第2集 Java面向对象的中的构造函数和封装

第3集 Java面向对象核心关键字this讲解

第4集 Java面向对象编程之继承

第5集 Java面向对象编程之继承的super关键词

第6集 Java面向对象编程之抽象

第7集 Java面向对象编程之接口

第8集 Java面向对象编程之InstanceOf关键词和多态

第9集本章课程作业练习题之简单计算器编写

第10集本章课程作业常见问题和答案解析

干货文档

第1集什么是面向对象对象编程OOP

简介：讲解什么是面向对象编程

类
- 就是模板，用来定义一类对象的方法和属性，比如人、学生、猫，万物都是有模板，都是可以定义为类。 (类名首字母大写)
```
class Student{
    
}

class Person{
    
}

class Cat{
    
}
```
对象
- 类的实例化，比如学生这个类实例化，就是 XX同学
```
Student student = new Student();
Cat cat1 = new Cat();
new Persion();
```
方法
- 方法是语句的集合，在一起完成一个功能
- 方法包含于类或对象中，即普通方法或者类方法
```
修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}
```
继承
- 子类继承父类的特征和行为，使得子类对象具有父类的方法和属性
- 父类也叫基类，具有公共的方法和属性
  - 动物<-猫
  - 动物<-狗
多态
- 同一个行为具有多个不同表现形式的能力
- 优点：减少耦合、灵活可拓展
- 一般是继承类或者重写方法实现
抽象
- 关键词abstract声明的类叫作抽象类，abstract声明的方法叫抽象方法
- 一个类里包含了一个或多个抽象方法，类就必须指定成抽象类
- 抽象方法属于一种特殊方法，只含有一个声明，没有方法体

第2集 Java面向对象的中的构造函数和封装

简介: 面向对象构造函数的使用和方法的封装

什么是构造函数
- 一种特殊的方法
- 创建对象时用来初始化对象，每次使用new 创建对象的时候，就会使用构造函数
- 与类具有相同的名称，但是没有返回值
- Java会自动为每个类提供一个默认构造函数
- 如果自己定义了构造函数，就不再使用默认构造函数，如果没有显示的写出默认构造函数，则会消失
- ```
注意点：如果构造函数之间互相调用，务必写在方法第一行
```

构造函数种类

默认构造函数
```
public 类名(){

}
```

无参构造函数

public 类名(){
//写自定义的语句
}

有参构造函数

public 类名(参数类型1  参数名1，参数类型2 参数名2...){
//自定义方法体
}

构造函数的修饰符
- public 用的最多，用来创建对象
- private 私有化构造函数，不给外部创建对象，比如工具类，或者单例设计模式
- default 默认的话，只能在当前包里面使用new 创建对象，几乎不用
什么是封装
- 封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口即方法
- 在java中通过关键字private，protected和public实现封装。
- 什么是封装？封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。适当的封装可以让代码更容易理解和维护，也加强了代码的安全性
- 类封装
- 方法封装

overload（重载，过载）
- 在一个类里面，方法名字相同，而参数不同，和返回类型无关
override（重写，覆盖）
- 子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变
  - 返回值类型，方法名，参数类型以及个数
- 子类能够根据需要实现父类的方法

第3集 Java面向对象核心关键字this讲解

简介：讲解java核心关键词this的用法和指向

this关键字
- 当一个对象创建后，JVM会给这个对象分配一个引用自身的指针，这个指针的名字就是 this
- 只能用于非静态方法体内，静态方法和代码块不能出现this
- this就是指向当前对象本身

使用场景
- this(参数类型1 参数名，...) 表示当前类对应的构造函数
- 方法形参和对象的属性重名，用this来区分
```
public void setAge(int age){
    this.age = age;
}
```

第4集 Java面向对象编程之继承

简介：讲解对象继承的概念和使用

继承
- 子类继承父类的特征和行为，使得子类对象具有父类的方法和属性
- 父类也叫基类，具有公共的方法和属性，生活中的例子
  - 动物<-猫
  - 动物<-狗
- java中的继承，减少重复代码
  - 使用前
  - 使用后

格式，通过extends关键字

class 父类名称{
    
}

class 子类名称 extends 父类名称{
    
}

特点
- 子类拥有父类的非private的属性和方法
- 子类可以用自己的方式实现父类的方法 override(重写，覆盖)
- 实现了代码的复用
- 重写从父类那里继承来的方法的，当调用方法时候会优先调用子类的方法（默认就近原则）
注意：
- 不支持多继承，支持多重继承，多重继承提高了耦合性，组合优于继承
- 所有的类都是继承于 java.lang.Object
- final关键字
  - 修饰的类，则这个类不可以被继承
  - 修饰方法，则这个方法不允许被覆盖（重写）

第5集 Java面向对象编程之继承的super关键词

简介:讲解 java继承里面的super关键字

super关键字
- 一个引用变量，用于引用父类对象
- 父类和子类都具有相同的命名方法，要调用父类方法时使用
- 父类和子类都具有相同的命名属性，要调用父类中的属性时使用
- super也是父类的构造函数，格式 super(参数)
  - 注意点调用super() 必须是类构造函数中的第一条语句，否则编译不通过

注意

每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错

public class Father {
    public Father(){
        System.out.println("father 无参构造函数");
    }
}
public class Children extends Father{
    public Children(){
        //默认存在，写和不写都行
        super();
        System.out.println("Child无参构造函数");
    }
}

this()和super()都指的是对象，均不可以在static环境中使用
- 包括：static变量,static方法，static语句块。

构造函数 super和this
- this 和super在构造函数中只能有一个，且都必须是构造函数当中的第一行
- 当父类的构造函数是无参构造函数时，在子类的构造函数中，不用显式super()去调用父类的构造函数,
- 当父类的构造函数是有参构造函数时，如果子类的构造函数中不写super()进行调用父类的构造函数，编译器会报错

java继承后类的初始化顺序
- 问题：静态代码块、非静态代码、父类/子类无参构造方法、父类/子类的一般方法

public class Father {

    static {
        System.out.println("父类静态代码块");
    }

    public Father(){
        System.out.println("father 无参构造函数");
    }

    public Father(int age){
        System.out.println("father 有参构造函数");
    }

    public void sleep(){
        System.out.println("father sleep方法");
    }

}

public class Children extends Father{

    static {
        System.out.println("Child静态代码块");
    }

    public Children(){
        //super();
        System.out.println("Child无参构造函数");
        super.sleep();
    }

    public void sleep(){
        System.out.println("Child sleep方法");
    }
}

public static void main(String[] args) {
        new Children().sleep();
 }

第6集 Java面向对象编程之抽象

简介:讲解抽象的好处，抽象类和抽象方法

什么是抽象

需求
- 动物都有年龄和名称，但是吃的不一样，羊吃草，老虎吃肉，但是都是闭着眼睛睡觉的
- 车，都有名称和价格，也有跑的方法，但是最高速度或者动力来源不一样
当父类的某些方法不确定时，可以用abstract关键字来修饰该方法，即抽象方法，用abstract来修饰该类，即抽象类
抽象类将事物的共性的东西提取出来，由子类继承去实现，代码易扩展、易维护
java中的抽象类和抽象方法

//抽象类
abstract class 类名{
}
//抽象方法，不能有方法主体
abstract 返回类型 方法名();
public abstract class Vehicle {
    
    public abstract void run();

    public void stop(){
        System.out.println("停在路上");
    }
}

class Bicycle extends Vehicle{
    @Override
    public void run() {
        System.out.println("人工驱动");
    }   
}

class Automobile extends Vehicle{
    @Override
    public void run() {
        System.out.println("汽油驱动");
    }
}

抽象特点：
- 抽象类的特点
  - 抽象类不能被实例化，因为抽象类中方法未具体化，这是一种不完整的类，所以不能直接实例化，编译无法通过
  - 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类
  - 如果一个抽象类中可以没有抽象方法，这样做的目的是为了此类不能被实例化。
  - 抽象类的子类必须给出抽象类中的抽象方法的具体实现，否则子类也是抽象类，需要用abstract声明
  - 抽象类不能使用final关键字修饰，因为final修饰的类是无法被继承
- 抽象方法的特点
  - 抽象类中的抽象方法只是声明，不包含方法体
  - 抽象方法不能用private修饰，因为抽象方法必须被子类实现（覆写），而private权限对于子类来说是不能访问的
  - 一个类继承了一个抽象类，那么它必须全部覆写抽象类中的抽象方法，当然也可以不全部覆写，如果不覆写全部抽象方法则这个子类也必须是抽象类
- 构造方法，类方法（即static 修饰的方法）不能声明为抽象方法

第7集 Java面向对象编程之接口

简介：讲解Java里面的接口interface

什么是接口

是抽象方法的集合，接口通常以interface来声明，一个类通过继承接口的方式，从而来继承接口的抽象方法

语法

interface 名称 [extends 其他的接口名] {
        // 声明变量
        // 抽象方法
       int getMoney(); 
}
    
    

* 接口的特点
  * 接口的方法都是抽象方法，默认都是  public abstract，其他修饰符都会报错
  * 接口中可以含有变量，但是接口中的变量会被隐式的指定为 **public static final**
  * 类描述对象的属性和方法，而接口则包含类要实现的方法
  * 接口无法被实例化，需要被实现才行
  * 一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类
* 接口和类的区别
  * 接口没有构造函数
  * 接口里可以有静态方法和方法体
  * 接口中所有的方法必须是抽象方法（JDK8之后就不是）
  * 接口不是被类继承了，而是要被类实现
  * 接口支持多继承, 类不支持多个类继承



* 接口的实现implements

  * 当类实现接口的时候，类要实现接口中所有的方法，不然类必须声明为抽象的类，使用implements关键字实现所有接口

  * 语法

class 类名 implements 接口名称[, 其他接口名称, 其他接口名称]{
    //要实现的方法
}

```

注意
- 一个类只能继承一个类，但是能实现多个接口
- 接口能继承另一个接口，接口的继承使用extends关键字，和类继承一样
JDK8新特性
- interface中可以有static方法，但必须有方法实现体，该方法只属于该接口，接口名直接调用该方法
- 接口中新增default关键字修饰的方法，default方法只能定义在接口中，可以在子类或子接口中被重写
  
  default定义的方法必须有方法体
- 父接口的default方法如果在子接口或子类被重写，那么子接口实现对象、子类对象，调用该方法，以重写为准
- 本类、接口如果没有重写父类（即接口）的default方法，则在调用default方法时，使用父类定义的default方法逻辑

public interface IPay{  

    // static修饰符定义静态方法  
    static void staticMethod() {  
        System.out.println("接口中的静态方法");  
    }  
  
    // default修饰符定义默认方法 ,默认方法不是抽象方法，可以不重写也可以重写 
    default void defaultMethod() {  
        System.out.println("接口中的默认方法");  
    }  
}  
// static方法必须通过接口类调用  
 IPay.staticMethod();  
  
 //default方法必须通过实现类的对象调用  
 new IPay().defaultMethod();

第8集 Java面向对象编程之InstanceOf关键词和多态

简介：讲解 InstanceOf关键词使用，什么是多态

InstanceOf 关键词

是Java的一个二元操作符（运算符）,也是Java的保留关键字

作用

判断一个类是否实现了某个接口，或者判断一个实例对象是否属于一个类
语法

//如果该object 是该class的一个实例，那么返回true。如果该object 不是该class的一个实例，或者object是null，则返回false

boolean result = object instanceof class
参数：
　　result ：boolean类型。
　　object ：必选项。任意对象表达式。
　　class：必选项。任意已定义的对象类。

对象类型强制转换前的判断

Person p1 = new Student();
//判断对象p是否为Student类的实例
if(1p instanceof Student)
{
   //向下转型
   Student s = (Student)p1;
}

方法重写和重载
- 方法重写 overriede
  - 子类对父类的允许访问的方法的实现过程进行重新编写,
  - 注意点
    - 返回值和形参都不能改变
    - 父类的成员方法只能被它的子类重写
    - final 和 static的方法不能被重写
    - 构造方法不能被重写
    - 访问权限不能比父类中被重写的方法的访问权限更低
- 方法重载 overload
  - 一个类里面，方法名字相同但参数不同，返回类型可以相同也可以不同
  - 比如构造函数重载

注意核心区分

override是在不同类之间的行为，overload是在同一个类中的行为
总结：Java多态
- 同一个行为具有多个不同表现形式或形态的能力
- 常见的方式
  - 继承方法重写
  - 同类方法重载
  - 抽象方法
  - 接口

第9集本章课程作业练习题之简单计算器编写

简介: 根据本章知识点布置课程作业

写个计算器，能完成加减乘除运算
- 定义接口做参数
- 加减乘除定义4个类
- 定义一个静态工具类，把下面的接口作为其中一个形参对象，传递具体的运算符类完成计算
```
interface ICompute{
    int computer(int num1, int num2);
}
```

第10集本章课程作业常见问题和答案解析

简介: 讲解课程作业常见问题和答案解析

写个计算器，能完成加减乘除运算

定义接口做参数
加减乘除定义4个类
定义一个静态工具类，把下面的接口作为其中一个形参对象，传递具体的运算符类完成计算

interface ICompute{
    int computer(int num1, int num2);
}

public class AddOper implements ICompute {
    @Override
    public int computer(int num1, int num2) {
        return num1 + num2;
    }
}


public class SubOper implements ICompute {

    @Override
    public int computer(int num1, int num2) {
        return num1 - num2;
    }
}


public class MulOper implements ICompute {

    @Override
    public int computer(int num1, int num2) {
        return num1*num2;
    }
}

public class DivideOper implements ICompute {

    @Override
    public int computer(int num1, int num2) {

        try {
            return num1/num2;
        }catch (Exception e){
            e.printStackTrace();
        }
        return -1;
    }
}



public class UseCompute {

    public static void compute(ICompute compute, int num1, int num2){

        int result = compute.computer(num1,num2);
        System.out.println(result);
    }


//    public static void add(AddOper compute, int num1, int num2){
//
//        int result = compute.computer(num1,num2);
//        System.out.println(result);
//    }
//
//    public static void sub(SubOper compute, int num1, int num2){
//
//        int result = compute.computer(num1,num2);
//        System.out.println(result);
//    }


    public static void main(String [] args){
        UseCompute.compute(new AddOper(),25,5);
        UseCompute.compute(new SubOper(),25,5);
        UseCompute.compute(new MulOper(),25,5);
        UseCompute.compute(new DivideOper(),25,0);
    }

}