• JavaOOP-封装、继承、多态、接口

    目录

    封装

    封装的实现

    访问权限级别

    构造方法

    重载

    static关键字

    继承

    继承概述

    继承的特性

    子类如何使用父类

    重写

     重写的特性

    抽象类

     final

     final的特性

    多态

    多态存在的三个必要条件

    多态之类型转换

    接口

    1.接口概述

    Java中的接口

    类和类之间的关系

     接口与接口之间的关系

     接口和类之间的关系

    2.接口与抽象类

    接口和抽象类的异同点

    3.接口应用

    封装

     封装是面向对象的核心思想，将对象的属性和行为封装起来，不需要让外界知道具体实现细节，这就是封装思想

    封装的实现

    1.封装是指在定义一个类时，将类中的属性私有化，即使用private关键字来修饰。

    2.私有属性只能在它所在类中被访问，如果外界想要访问私有属性，需要提供一些使用public修饰的公有方法。

    访问权限级别

    构造方法

     说明：

    1.利用构造方法的重载可以实用多个构造方法

    2.没有写构造方法，java虚拟机默认会生成一个没有任何参数的公共的构造方法。

    3.相同的名称的普通方法也可以有多个，这些方法的参数列表必须不一样。

    重载

    在同一个类中，多个方法中拥有相同的名字，但方法的参数列表不同（参数个数不同，顺序不同、类型不同）

    1. package oop.entity;
    2.  
    3. /**
    4.  *企鹅类
    5.  * @author zyt
    6.  */
    7. public class Penguin {
    8.  
    9.     private String name;//昵称
    10.     private int health;//健康值
    11.     private String sex;//性别
    12.     public Penguin() {
    13.     }
    14.  
    15.     public Penguin(String name, int health) {
    16.         this.name = name;
    17.         this.health = health;
    18.     }
    19.  
    20.     /**
    21.      *构造方法--带三个参数
    22.      * @param name
    23.      * @param health
    24.      * @param sex
    25.      */
    26.     public Penguin(String name, int health, String sex) {
    27.         this.name = name;
    28.         this.health = health;
    29.         this.sex = sex;
    30.     }
    31.  
    32.  
    33.  
    34.     public String getName() {
    35.         return name;
    36.     }
    37.  
    38.     public void setName(String name) {
    39.         this.name = name;
    40.     }
    41.  
    42.     public int getHealth() {
    43.         return health;
    44.     }
    45.  
    46.     public void setHealth(int health) {
    47.         this.health = health;
    48.     }
    49.  
    50.     public String getSex() {
    51.         return sex;
    52.     }
    53.  
    54.     public void setSex(String sex) {
    55.         this.sex = sex;
    56.     }
    57. }
    1. package oop.entity;
    2.  
    3. public class PenguinText {
    4.     public static void main(String[] args) {
    5.         //通过构造方法，将对象的属性值初始化
    6.         Penguin penguin = new Penguin("Q仔",100,"男");
    7. //        penguin.setName("Q仔");
    8. //        penguin.setHealth(100);
    9. //        penguin.setSex("男");
    10.  
    11.  
    12.         System.out.println(penguin.getName()+","+ penguin.getHealth()+","+ penguin.getSex());
    13.     }
    14. }

    static关键字

     说明：

    static表示“静态”的意思，用来修饰成员变量和成员方法，也可以形参静态 static代码块等

    1. package oop.entity;
    2.  
    3. public class Person {
    4.     String name;
    5.     static String classes;
    6.  
    7.  
    8.     public static void print(){
    9.         System.out.println("班级" +classes +"的同学");
    10.     }
    11.     public void show(){
    12.         System.out.println(name);
    13.     }
    14.     public void show(String str){
    15.         System.out.println(name + "");
    16.     }
    17.     //return 不能作为重载依据
    18.  
    19.     public static void main(String[] args) {
    20.         Person p1 = new Person();
    21.         p1.name= "张三";
    22. //        p1.classes="1001";
    23.         Person.classes="1001";
    24.  
    25.         Person p2= new Person();
    26.         p2.name= "李四";
    27. //        p2.classes="1001";
    28.  
    29.         Person p3= new Person();
    30.         p3.name= "王五";
    31. //        p3.classes="1001";
    32.  
    33.         p1.print();
    34.         p2.print();
    35.         p3.print();
    36.     }
    37. }

    不管创建多少个对象，这个static修饰的变量，它只占一块内存

    注:如果是一个静态的方法，那么它只能访问静态的属性。

    继承

    继承概述

     格式 ：

    class 子类 extends 父类{

      ....

    }

    1.  
    2. public class Animal {
    3.     private String name;
    4.     private int id;
    5.  
    6.     public Animal(String name, int id) {
    7.         this.name = name;
    8.         this.id = id;
    9.     }
    10.     public void eat(){
    11.         System.out.println(name+"正在吃");
    12.     }
    13.     public void sleep(){
    14.         System.out.println(name+"正在睡");
    15.     }
    16.     public void introduction(){
    17.         System.out.println("大家好！我是" + id +"号"+ name);
    18.     }
    19. }
    1. package oop.entity;
    2.  
    3. public class Mouse extends Animal{
    4.     public Mouse(String myName,int myId){
    5.         super(myName,myId);
    6.     }
    7. }

    继承的特性

     单继承指一个子类只能继承一个父类，多继承指的是B类继承A类，A类是B的父类；C类继承B类，B类是C类的父类。

    子类如何使用父类

     

     父类：

    1. package oop.entity;
    2.  
    3. public class Fu {
    4.     private int num = 4;
    5.     public int getNum(){
    6.         return this.num;
    7.     }
    8. }

     子类：

    1. package oop.entity;
    2.  
    3. import java.sql.SQLOutput;
    4.  
    5. public class Zi extends Fu{
    6.     private int num= 5;
    7.  
    8.     public void show(){
    9.         System.out.println(this.num+"...."+super.getNum());
    10.     }
    11. }

    测试类：

    1. package oop;
    2.  
    3. import oop.entity.Zi;
    4.  
    5. public class ZiText {
    6.     public static void main(String[] args) {
    7.         Zi z = new Zi();
    8.         z.show();
    9.     }
    10. }

    重写

     

     重写的特性

    Animal类：（父类）

    1. package oop.entity;
    2.  
    3. public class Animal {
    4.     private String name;
    5.     private int id;
    6.  
    7.     public Animal(String name, int id) {
    8.         this.name = name;
    9.         this.id = id;
    10.     }
    11.     public void eat(){
    12.         System.out.println(name+"正在吃");
    13.     }
    14.     public void sleep(){
    15.         System.out.println(name+"正在睡");
    16.     }
    17.     public void introduction(){
    18.         System.out.println("大家好！我是" + id +"号"+ name);
    19.     }
    20. }

    Mouth类：

    1. package oop.entity;
    2.  
    3. public class Mouse extends Animal{
    4.     public Mouse(String myName,int myId){
    5.         super(myName,myId);
    6.     }
    7.  
    8.     public void eat(){
    9.         System.out.println("老鼠正在吃粮食");
    10.     }
    11. }

    测试类：

    1. package oop;
    2.  
    3. import oop.entity.Mouse;
    4.  
    5. public class MouseText {
    6.     public static void main(String[] args) {
    7.         Mouse m = new Mouse("Jerry",01);
    8.         m.eat();
    9.  
    10.     }
    11. }

    抽象类

    格式

    1. //抽象类
    2. 修饰符 abstract class 类名{
    3.     //抽象方法
    4.     修饰符 abstract 返回值类型 方法名([参数列表]);
    5. }

    说明：

    abstract修饰方法，称为抽象方法，只有方法的定义，没有方法体并且只能定义在抽象类中；abstract 修饰类，称为抽象类，抽象类，抽象类不能直接实例化，需要借助子类重写类中全部的抽象方法，通过子类创建对象。

    父类：（抽象类）

    1. package oop.entity;
    2.  
    3. public abstract class Animal01 {
    4.  
    5.     private String name;
    6.  
    7.     public abstract void eat();
    8.  
    9. }

    子类：

    1. package oop.entity;
    2.  
    3. public class Mouse01 extends Animal01{
    4.  
    5.     @Override
    6.     public void eat() {
    7.         System.out.println("老鼠在吃粮食");
    8.     }
    9. }
    1. package oop.entity;
    2.  
    3. public class Penguin01 extends Animal01{
    4.  
    5.     @Override
    6.     public void eat() {
    7.         System.out.println("企鹅正在吃鱼虾");
    8.     }
    9. }

    常见问题一:

     常见问题二：

     目的：不让这个类去创建对象

    常见问题3：

    常见问题4：

     final

     final的特性

    1. package oop.entity;
    2.  
    3. /**
    4.  * final 修饰类不能被继承
    5.  */
    6. public final class Msg {
    7.  
    8.     //定义常量（final+static 修饰属性）
    9.     public static final String TITLE ="java";
    10.  
    11.     public final void show(){
    12.         System.out.println(TITLE);
    13.     }
    14.  
    15.  
    16. }
    1. package oop;
    2.  
    3. import oop.entity.Msg;
    4.  
    5. public class MsgText {
    6.     public static void main(String[] args) {
    7.  
    8.  
    9.         Msg m = new Msg();
    10. //        m.TITLE; 会报错
    11.         m.show();
    12.  
    13.     }
    14. }

    多态

    概念

    多态指允许不同类的对象对同一消息做出相应。

    即同一消息可以根据发生对象的不同而采取不同的行为方式 

     抽象类

    1. package oop.ob;
    2.  
    3. public abstract class Animal {
    4.     abstract void eat();
    5. }

    子类1：

    1. package oop.ob;
    2.  
    3. public class Cat extends Animal {
    4.  
    5.     public void eat(){
    6.         System.out.println("吃鱼");
    7.     }
    8.  
    9.     public void catchMouse(){
    10.         System.out.println("抓老鼠");
    11.     }
    12. }

    子类2：

    1. package oop.ob;
    2.  
    3. import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;
    4.  
    5. public class Dog extends Animal{
    6.  
    7.         @Override
    8.         public void eat() {
    9.             System.out.println("啃骨头");
    10.         }
    11.         public void lookHome(){
    12.             System.out.println("看家");
    13.         }
    14.     }
    15.  
    1. package oop.ob;
    2.  
    3. public class PolymorphicDemo {
    4.  
    5.  
    6.     /**
    7.      * 使用父类作为方法的参数实现多态
    8.      * @param a
    9.      */
    10.     public static void method(Animal a){
    11.         a.eat();
    12.     }
    13.  
    14.     /**
    15.      * 使用父类作为方法的返回值实现多态
    16.      * @return
    17.      */
    18.     public static Animal get()
    19.     {
    20.         return new Dog();
    21.     }
    22.  
    23.     public static void main(String[] args) {
    24.  
    25. //        //调用
    26. //        Cat c = new Cat();
    27. //        method(c);
    28. //        method(new Dog());//Dog d = new Dog;
    29.  
    30.         //使用父类的引用指向子类对象
    31.         Animal c = new Cat();
    32. //        Animal d = new Dog();
    33.         method(c);
    34.         method(new Dog());
    35.     }
    36. }
    37.

    多态存在的三个必要条件

    1.继承

    2.重写

    3.父类引用指向子类对象[Animal c = new Cat()]

    当使用多态方法调用方式时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有再去调用子类同名方法。

    多态之类型转换

     向上转型例：Animal a = new （Cat）;

    向下转型例：Cat c = （Cat）a; c.__();

    1. package oop.ob;
    2.  
    3. public class PolymorphicDemo {
    4.  
    5.  
    6.     /**
    7.      * 使用父类作为方法的参数实现多态
    8.      * @param a
    9.      */
    10.     public static void method(Animal a){
    11.         //调用eat()方法
    12.         a.eat();
    13.  
    14.         //instanceof 判断对象的具体方法
    15.         //原先的 a.__是找不到子类特有的方法 先判断，接着向下转型 就可以调用子类特有的方法了
    16.         if(a instanceof Cat){
    17.             Cat c =(Cat)  a;
    18.             c.catchMouse();
    19.         }else if(a instanceof Dog){
    20.             Dog d =(Dog) a;
    21.             d.lookHome();
    22.         }
    23.     }

    接口

    1.接口概述

    接口的特点
    特点：统一标准，让大家知道是做什么的，但是不知道具体怎么做。

    Java中的接口

     接口中的属性默认是使用 public static final修饰的 修饰的是常量

    接口中的默认方法是使用 public abstract 修饰的

    类和类之间的关系

     接口与接口之间的关系

     use 3.0继承了 usb2.0b并拓展了

     

     注：多继承

     接口和类之间的关系

     

     注：多实现

    2.接口与抽象类

    接口和抽象类的异同点

    3.接口应用

    接口1：

    1. package oop.service;
    2.  
    3. /**
    4.  * 接口：提供一种公共的功能
    5.  */
    6. public interface MathService01 {
    7.  
    8.     public int sum(int a,int b);//+
    9.  
    10.     public int sub(int a,int b);//-
    11.  
    12. }

    接口2：

    1. package oop.service;
    2.  
    3. /**
    4.  * 接口：提供一种公共的功能
    5.  */
    6. public interface MathService02 {
    7.     public int mul(int a,int b);//*
    8.  
    9.     public int div(int a,int b);// /
    10. }

     实现：

    1. package oop.service.impl;
    2.  
    3. import oop.service.MathService01;
    4. import oop.service.MathService02;
    5.  
    6. public class MathServiceImpl implements MathService01, MathService02 {
    7.  
    8.     @Override
    9.     public int sub(int a, int b) {
    10.         return a-b;
    11.     }
    12.  
    13.     @Override
    14.     public int sum(int a, int b) {
    15.         return a+b;
    16.     }
    17.  
    18.     @Override
    19.     public int div(int a, int b) {
    20.         return a/b;
    21.     }
    22.  
    23.     @Override
    24.     public int mul(int a, int b) {
    25.         return a*b;
    26.     }
    27. }

    测试类：

    1. package oop.service;
    2.  
    3.  
    4. import oop.service.impl.MathServiceImpl;
    5.  
    6. public class MathText {
    7.     public static void main(String[] args) {
    8.  
    9.         MathService01 ms1 = new MathServiceImpl();
    10.         ms1.sub(10,10);
    11.         ms1.sum(10,10);
    12.  
    13.         MathService02 ms2 = new MathServiceImpl();
    14.        ms2.div(10,10);
    15.        ms2.mul(10,10);
    16.  
    17.  
    18.  
    19.     }
    20. }

  • 相关阅读:
    第6讲 SQL语言之概述
    如何利用Flutter框架开发运行小程序
    开源模型 Zephyr-7B 发布——跨越三大洲的合作
    22-9-18学习笔记-MySQL和Redis
    sql server 设置字段自增
    在一张 24 GB 的消费级显卡上用 RLHF 微调 20B LLMs
    Node.js第一节：初识Node.js与内置模块(fs文件系统模板、path路径模板、http模板)
    在autodl搭建stable-diffusion-webui+sadTalker
    SpringBoot集成jjwt和使用
    分布式爬虫
  • 原文地址：https://blog.csdn.net/m0_64005381/article/details/127133406