欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

小滴课堂-学习笔记:(6)Java 面向对象编程OOP

程序员文章站 2022-03-10 18:22:02
愿景:"让编程不再难学,让技术与生活更加有趣"更多架构课程请访问 xdclass.net目录第1集 什么是面向对象对象编程OOP第2集 Java面向对象的中的构造函数和封装第3集 Java面向对象核心关键字this讲解第4集 Java面向对象编程之继承第5集 Java面向对象编程之继承的super关键词第6集 Java面向对象编程之抽象第7集 Java面向对象编程之接口第8集 Java面向对象编程之InstanceOf关键词和多态第9集 本章课程作业练习题.....

小滴课堂-学习笔记:(6)Java 面向对象编程OOP 愿景:"让编程不再难学,让技术与生活更加有趣"


更多架构课程请访问 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);
        }
    ​
    }
    ​
    ​
    
    

     

干货文档

小滴课堂-学习笔记:(6)Java 面向对象编程OOP

小滴课堂-学习笔记:(6)Java 面向对象编程OOP

小滴课堂-学习笔记:(6)Java 面向对象编程OOP

小滴课堂-学习笔记:(6)Java 面向对象编程OOP

                                                        关注公众号发送:“CSDN干货文档”  即可领取

小滴课堂-学习笔记:(6)Java 面向对象编程OOP

本文地址:https://blog.csdn.net/dev666/article/details/111628341