12、面向对象进阶（多态、内部类、常用API）

最新推荐文章于 2024-07-04 09:24:51 发布
最新推荐文章于 2024-07-04 09:24:51 发布
阅读量171 收藏 2
点赞数 1
分类专栏： Java基础笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45519865/article/details/124176769
版权

目录

面向对象三大特征之三：多态

多态的概述，多态的形式

多态的优势

多态下引用数据类型的类型转换

总结

多态的案例

内部类

内部类概述

内部类之一：静态内部类[了解]

 静态内部类的访问拓展：

 总结

内部类之二：成员内部类[了解]

成员内部类的访问拓展： 

 总结

内部类之三：局部内部类[了解]

内部类之四：匿名内部类概述[重点]

匿名内部类常见使用形式

匿名内部类在开发中的真实使用场景演示

常用API

Object

总结

equals方法

 总结

Objects

​

总结

StringBuilder

StringBuilder常用方法

​ 总结

案例

Math类

System

BigDecimal

总结

面向对象三大特征之三：多态

多态的概述，多态的形式

package com.itheima.d1_polymorphic;

/**
 * 父类
 */
public class Animal {
    public String name = "动物名称";

    public void run() {
        System.out.println("动物可以跑~~");
    }
}

package com.itheima.d1_polymorphic;

public class Dog extends Animal{
    public String name = "狗名称";
    @Override
    public void run() {
        System.out.println("🐕跑的贼溜~~~~~");
    }

}

package com.itheima.d1_polymorphic;

public class Tortoise extends Animal {
    public String name = "乌龟名称";
    @Override
    public void run() {
        System.out.println("🐢跑的非常慢~~~");
    }


}

package com.itheima.d1_polymorphic;

public class Test {
    public static void main(String[] args) {
        // 目标：先认识多态的形式
        // 父类  对象名称 = new 子类构造器();
        Animal a = new Dog();
        a.run(); // 方法调用：编译看左，运行看右
        System.out.println(a.name); // 动物名称

        Animal b =new Tortoise();
        b.run();
        System.out.println(b.name);
    }
}

多态的优势

package com.itheima.d2_polymorphic_advantage;

public class Test {
    public static void main(String[] args) {
        Animal d = new Dog();
        go(d);
        //d.lookDoor();  //多肽下不能访问子类独有功能

        Animal t = new Tortoise();
        go(t);

    }

    /**
     * 希望这个方法可以接收一切子类动物对象
     * @param a
     */
    public static void go(Animal a) {
        System.out.println("预备~~~");
        a.run();
        System.out.println("结束~~~~");
    }
}

多态下引用数据类型的类型转换

package com.itheima.d3_polymorphic_convert;

/**
 * 父类
 */
public class Animal {
    public String name = "动物名称";

    public void run() {
        System.out.println("动物可以跑~~");
    }
}


package com.itheima.d3_polymorphic_convert;

public class Dog extends Animal {
    public String name = "狗名称";

    @Override
    public void run() {
        System.out.println("🐕跑的贼溜~~~~~");
    }

    /**
     * 独有功能
     */
    public void lookDoor() {
        System.out.println("🐕在看🚪！！！");
    }
}

package com.itheima.d3_polymorphic_convert;

public class Tortoise extends Animal {
    public String name = "乌龟名称";

    @Override
    public void run() {
        System.out.println("🐢跑的非常慢~~~");
    }

    /**
     * 独有功能
     */
    public void layEggs() {
        System.out.println("🐢在下蛋~~~");
    }
}


package com.itheima.d3_polymorphic_convert;

/**
 目标：学习多态形式下的类中转换机制。
 */
public class Test {
    public static void main(String[] args) {
        // 自动类型转换
        Animal a = new Dog();
        a.run();
//        a.lookDoor(); // 多态下无法调用子类独有功能

        // 强制类型转换:可以实现调用子类独有功能的
        Dog d = (Dog) a;
        d.lookDoor();

        // 注意：多态下直接强制类型转换，可能出现类型转换异常
        // 规定：有继承或者实现关系的2个类型就可以强制类型转换，运行时可能出现问题。
        // Tortoise t1 = (Tortoise) a;
        // 建议强制转换前，先判断变量指向对象的真实类型，再强制类型转换。
        if(a instanceof Tortoise){
            Tortoise t = (Tortoise) a;
            t.layEggs();
        }else if(a instanceof Dog){
            Dog d1 = (Dog) a;
            d1.lookDoor();
        }

        System.out.println("---------------------");
        Animal a1 = new Tortoise();
        go(a1);
    }

    public static void go(Animal a){
        System.out.println("预备~~~");
        a.run();
        // 独有功能
        if(a instanceof Tortoise){
            Tortoise t = (Tortoise) a;
            t.layEggs();
        }else if(a instanceof Dog){
            Dog d1 = (Dog) a;
            d1.lookDoor();
        }
        System.out.println("结束~~~~");
    }
}

总结

多态的案例

package com.itheima.d4_polymorphic_test;

public interface USB {
    void connect();
    void unconnect();
}


package com.itheima.d4_polymorphic_test;

/**
   实现类（子类）
 */
public class KeyBoard implements USB{
    private String name;

    public KeyBoard(String name) {
        this.name = name;
    }

    @Override
    public void connect() {
        System.out.println(name + "成功的接入了设备了~~~");
    }

    @Override
    public void unconnect() {
        System.out.println(name + "成功的从设备弹出了~~~");
    }

    /**
      独有功能
     */
    public void keyDown(){
        System.out.println(name + "写下了：老铁，6666，下次再来哦，老弟~~~~");
    }

    public String getName() {
        return name;
    }

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

package com.itheima.d4_polymorphic_test;

/**
   实现类（子类）
 */
public class Mouse implements USB{
    private String name;

    public Mouse(String name) {
        this.name = name;
    }

    @Override
    public void connect() {
        System.out.println(name + "成功的接入了设备了~~~");
    }

    @Override
    public void unconnect() {
        System.out.println(name + "成功的从设备弹出了~~~");
    }

    /**
      独有功能
     */
    public void click(){
        System.out.println(name + "双击点亮小红心~~~~");
    }

    public String getName() {
        return name;
    }

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

package com.itheima.d4_polymorphic_test;

public class Computer {
    /**
       提供一个安装的入口：行为。
     */
    public void installUSB(USB u){
        u.connect();

        // 独有功能
        if(u instanceof Mouse){
            Mouse m = (Mouse) u;
            m.click();
        }else if(u instanceof KeyBoard) {
            KeyBoard k = (KeyBoard) u;
            k.keyDown();
        }

        u.unconnect();
    }
}

package com.itheima.d4_polymorphic_test;

/**
    目标：USB设备模拟
    1、定义USB接口：接入 拔出
    2、定义2个USB的实现类：鼠标、键盘。
    3、创建一个电脑对象，创建USB设备对象，安装启动。
 */
public class Test {
    public static void main(String[] args) {
        // a、创建电脑对象
        Computer c = new Computer();
        // b、创建USB设备对象
        USB u = new Mouse("罗技鼠标");
        c.installUSB(u);

        USB k = new KeyBoard("双飞燕键盘");
        c.installUSB(k);
    }

}

内部类

内部类概述

内部类之一：静态内部类[了解]

 静态内部类的访问拓展：

 总结

 

内部类之二：成员内部类[了解]

成员内部类的访问拓展： 

 

 总结

内部类之三：局部内部类[了解]

内部类之四：匿名内部类概述[重点]

package com.itheima.d8_innerclass_anonymous;

/**
 目标：学习匿名内部类的形式和特点。
 */
public class Test {
    public static void main(String[] args) {
        Animal a = new Animal(){
            @Override
            public void run() {
                System.out.println("老虎跑的块~~~");
            }
        };
        a.run();
    }
}

//class Tiger extends Animal{
//    @Override
//    public void run() {
//        System.out.println("老虎跑的块~~~");
//    }
//}

abstract class Animal{
    public abstract void run();
}

匿名内部类常见使用形式

 对象回调

匿名内部类在开发中的真实使用场景演示

常用API

Object

toString方法

package com.itheima.d9_api_object;


public class Student {
    private String name;
    private String sex;
    private int age;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                '}';
    }

    public Student() {
    }

    public Student(String name, String sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public String getName() {//extends Object
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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


}


package com.itheima.d9_api_object;

public class Test {
    public static void main(String[] args) {
       // Student s = new Student();
       // System.out.println(s.toString());

        Student s = new Student("周雄", "男", 19);

        // 直接输出对象变量，默认可以省略toString调用不写的
        System.out.println(s);
    }
}

总结

object是祖宗类，默认继承

equals方法

package com.itheima.d9_api_object;

import java.util.Objects;

public class Student { //extends Object{
    private String name;
    private char sex;
    private int age;

    public Student() {
    }

    public Student(String name, char sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

    /**
     定制相等规则。
     两个对象的内容一样就认为是相等的
     s1.equals(s2)
     比较者：s1 == this
     被比较者： s2 ==> o
     */
    @Override
    public boolean equals(Object o) {
        // 1、判断是否是同一个对象比较，如果是返回true。
        if (this == o) return true;
        // 2、如果o是null返回false  如果o不是学生类型返回false  ...Student !=  ..Pig
        if (o == null || this.getClass() != o.getClass()) return false;
        // 3、说明o一定是学生类型而且不为null
        Student student = (Student) o;
        return sex == student.sex && age == student.age && Objects.equals(name, student.name);
    }


    /**
     自己重写equals，自己定制相等规则。
     两个对象的内容一样就认为是相等的
     s1.equals(s2)
     比较者：s1 == this
     被比较者： s2 ==> o
     */
 /*   @Override
    public boolean equals(Object o){
        // 1、判断o是不是学生类型
        if(o instanceof Student){
            Student s2 = (Student) o;
            // 2、判断2个对象的内容是否一样。
//            if(this.name.equals(s2.name) &&
//                 this.age == s2.age && this.sex == s2.sex){
//                return true;
//            }else {
//                return false;
//            }
            return this.name.equals(s2.name) && this.age == s2.age
                    && this.sex == s2.sex ;

        }else {
            // 学生只能和学生比较，否则结果一定是false
            return false;
        }
    }*/


    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                ", age=" + age +
                '}';
    }
}

package com.itheima.d9_api_object;

import java.util.Objects;

/**
 目标：掌握Object类中equals方法的使用。
 */
public class Test2 {
    public static void main(String[] args) {
        Student s1 = new Student("周雄", '男', 19);
        Student s2 = new Student("周雄", '男', 19);
        // equals默认是比较2个对象的地址是否相同，子类重写后会调用子类重写的来比较内容是否相同。
        System.out.println(s1.equals(s2));
        System.out.println(s1 == s2);

        System.out.println(Objects.equals(s1, s2));
    }
}

 总结

Objects

总结

 

StringBuilder

StringBuilder常用方法

总结

 

案例

 

package com.itheima.d11_api_stringbuilder;

public class StringBuilderTest2 {
    public static void main(String[] args) {
        int[] arr1 = null;
        System.out.println(toString(arr1));

        int[] arr2 = {10, 88, 99};
        System.out.println(toString(arr2));

        int[] arr3 = {};
        System.out.println(toString(arr3));
    }

    public static String toString(int[] arr) {
        if (arr != null) {
            StringBuilder sb = new StringBuilder("[");
            for (int i = 0; i < arr.length; i++) {
                sb.append(arr[i]).append(i == arr.length - 1 ? "" : ",");
            }//for
            sb.append("]");
            return sb.toString();
        } else {
            return null;
        }

    }
}

 

Math类

package com.itheima.d12_math;

/**
 目标：Math类的使用。
 Math用于做数学运算。
 Math类中的方法全部是静态方法，直接用类名调用即可。
 方法：
 方法名                                          说明
 public static int abs(int a)                   获取参数a的绝对值：
 public static double ceil(double a)            向上取整
 public static double floor(double a)           向下取整
 public static double pow(double a, double b)   获取a的b次幂
 public static long round(double a)             四舍五入取整
 小结：
 记住。
 */
public class MathDemo {
    public static void main(String[] args) {
        // 1.取绝对值:返回正数
        System.out.println(Math.abs(10)); // 10
        System.out.println(Math.abs(-10.3)); // 10.3

        // 2.向上取整: 5
        System.out.println(Math.ceil(4.00000001)); // 5.0
        System.out.println(Math.ceil(4.0)); // 4.0
        // 3.向下取整：4
        System.out.println(Math.floor(4.99999999)); // 4.0
        System.out.println(Math.floor(4.0)); // 4.0

        // 4.求指数次方
        System.out.println(Math.pow(2 , 3)); // 2^3 = 8.0
        // 5.四舍五入 10
        System.out.println(Math.round(4.49999)); // 4
        System.out.println(Math.round(4.500001)); // 5

        System.out.println(Math.random());  // 0.0 - 1.0 （包前不包后）

        // 拓展： 3 - 9 之间的随机数  （0 - 6） + 3
        //  [0 - 6] + 3
        int data =  (int)(Math.random() * 7) + 3;
        System.out.println(data);


    }
}

System

 

BigDecimal

总结

宁my
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python零基础速成班-第9讲-Python面向对象编程(上)，对象和类、初始化、继承、重写、多态、类方法、组合.ipynb
05-25
本教程设置3级标题，对知识点进行分类，内容上由基础+进阶的方式呈现，练习题也设置了必做和挑战项目，分别适用于初学者和进阶学习者。 整个教程大概有80个学时，同时也引入图像识别基础、算法基础、小游戏、爬虫、...
深入PHP-面向对象、模式与实践
08-14
通过面向对象编程，开发者可以创建类和对象，实现封装、继承和多态等概念，提高代码的组织性和可扩展性。书中的章节可能包括类和对象的基础知识，以及更高级的主题如抽象类、接口、访问修饰符、魔术方法等。 设计...
day13-面向对象进阶（多态、内部类、常用API）
wjl200212的博客
12-23 668
13、面向对象进阶（多态、内部类、常用API）面向对象三大特征之三：多态多态的优势多态的案例内部类内部类概述内部类之一：静态内部类[了解]内部类之二：成员内部类[了解]内部类之三：局部内部类[了解]内部类之四：匿名内部类概述[重点]匿名内部类常见使用形式 面向对象三大特征之三：多态 package com.itheima.d1_polymorphic; /** 父类 */ public class Animal { public String name = "动物名称"; pu
JavaSE基础笔记——Javaoo（面向对象进阶：多态、内部类、常用API）
weixin_62993347的博客
07-30 288
JavaSE基础笔记——Javaoo（面向对象进阶：多态、内部类、常用API）
面向对象进阶9---多态、内部类、常用API
peihj的博客
02-11 395
面向对象进阶9—多态、内部类、常用API 多态的概述 什么是多态
Java SE基础知识详解第[9]期—面向对象进阶（多态、内部类、常用API）
zhuafeng222的博客
04-20 752
Java SE基础知识详解第[9]期—面向对象进阶（多态、内部类、常用API）
20天深度复习JavaSE的详细笔记(十)——面向对象进阶（多态、内部类、常用API）
maxiangyu_的博客
07-29 296
1.内部类就是定义在一个类里面的类当一个事物的内部,还有一个部分需要一个完整的结构进行描述,而这个内部的完整的结构又只为外部事物提供服务,那么整个内部的完整结构可以选择使用内部类来设计内部类通常可以直接访问外部类的成员,包括私有成员内部类相比外部类提供了更好的封装性,内部类本身就可以用privateprotected等修饰,封装性可以做更多控制外部类的上一层单元是包，对于外部类来说，只有两个作用域同包或者任何位置，因此只需要两种控制权限静态内部类[了解]...
Java进阶1（面向对象进阶+常用API）
delighted_qian的博客
04-08 687
包括Java面向对象进阶+java常用API 的知识点总结
mapengpeng1999@163.com java面向对象进阶之多态
ma1782072的博客
08-29 211
面向对象 接口 java有3种引用数据类型：数组，类，接口。接口在Java中使用interface关键字声明，不需要使用class，它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。 接口中只有抽象方法和常量，如果一个抽象类是高度抽象化的（只有抽象方法和常量），就可以使用接口来表示。接口和抽象类的作用是一致的，但是接口更加的灵活。 接口的声明： interface 接口名{ 常量; 抽象方法;//抽象方法没有方法体，该方法供实现类重写使用。 } 声明常量：public st
Java进阶：多态、内部类，常用API
Swl0114的博客
11-19 25
• Java规定，有继承/实现关系的类就可以强制转换，编译阶段不会报错。• 外部类.内部类名 对象名 = new 外部类名.内部类构造器;• 匿名内部类是一个没有名字的局部内部类，本身也是一个所谓的子类对象。• 匿名内部类这个对象的类型，相当于是当前new的这个类型的子类类型。• 2、静态内部类中是否可以直接访问外部类的实例成员？• 1、静态内部类可以直接访问外部类的静态成员吗？• 无static修饰，属于外部类的对象的。• 报错的。
Java基础-面向对象进阶-多态&包&final&权限修饰符&代码块
爪蛙毁一生的博客
12-03 301
多态： 是指同一行为，具有多个不同表现形式。从上面案例可以看出，Cat和Dog都是动物，都是吃这一行为，但是出现的效果（表现形式）是不一样的。前提【重点】有继承或者实现关系方法的重写【意义体现：不重写，无意义】父类引用指向子类对象【格式体现】父类类型：指子类对象继承的父类类型，或者实现的父接口类型。​ 学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。如果有一个方法我不想别人去改写里面内容，该怎么办呢？Java提供了final关键字，表示修饰的内容不可变。final。
Java面向对象程序设计
05-27
在学习Java面向对象程序设计时，不仅需要掌握语言基础，包括类、对象、接口、包、继承、多态等概念，还需要熟悉开发工具的使用，如Eclipse、IntelliJ IDEA等，以及理解Java的运行环境配置，如设置JDK路径和环境变量...
C++面向对象的简单考试系统.zip
01-20
- 面向对象编程基础：了解类、对象、封装、继承、多态等概念。 - 内存管理：深拷贝与浅拷贝的区别，智能指针的使用，动态内存分配和释放。 - 构造函数与析构函数：理解它们的作用，以及何时使用拷贝构造函数和...
《基于java的面向对象程序设计》学习资源
07-19
8. **面向对象进阶**：包括抽象类、接口、内部类、匿名类、访问权限控制等，这些都是编写复杂Java应用程序的关键。 9. **多线程**：学习如何创建和管理线程，理解同步和互斥的概念，以实现并发编程。 10. **异常...
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 515
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
java 程序、进程 、线程，cpu，并行、并发、启动线程两种方式
gu2022_3_5_21_23的博客
07-02 326
Thread 方式 线程间不可以共享数据，除非变量加 static 变为 静态变量 （每次创建实例，会有一个新的副本）。条件二： 重写 Thread 父类方法 后创建实例调用 start 方法 （创建匿名子类的匿名对象）条件一： 将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。2、将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。最后调用的都是 Thread 的start 的方法。创建的线程对象，都是Thread类或其子类的实例。
ShardingSphere
最新发布
Casual_Lei的博客
07-04 639
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
如何使用缓存提升SpringBoot性能（EhCache和Redis方式）
三两肉的博客
07-03 1036
缓存是指将文件或数据的副本存储在缓存或临时存储位置中，以便未来对该数据的请求可以更快地提供服务。当从存储中检索数据时，会在缓存中创建该数据的副本。如果再次需要该数据，可以从缓存中比从主存储器中更快地检索到该数据，主存储器可能涉及复杂的计算或较慢的访问速度。如何使用缓存提升SpringBoot性能（EhCache和Redis方式）
java程序设计-时钟.doc
06-10
- 掌握面向对象编程的核心概念，如类、对象、封装、继承和多态，以及Java语言的基础特性，如关键字、标识符、数据类型、常量和变量等。 - 学习和应用Java的关键编程元素，如main方法和public访问修饰符，理解其在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值