Java新手小白入门篇 Java面向对象（四）

最新推荐文章于 2025-12-02 15:55:42 发布
原创 最新推荐文章于 2025-12-02 15:55:42 发布 · 249 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言 #jvm

本文详细介绍了Java中的向上造型概念，包括超类型引用指向派生类对象及其方法调用规则。同时，讲解了方法的重写，强调了重写时的签名匹配原则和调用规则。此外，还探讨了Java中的访问控制修饰符、static关键字的使用场景，以及静态变量和静态方法的特性。最后，通过实例解析了静态变量在多个对象间的共享行为，并给出了相关练习题以巩固知识。

一、向上造型（下） 
1. 超类型的引用指向派生类的对象 
public class Test{
    public static void main(String[] args) {
        //超类型(父类)    引用    指向      对象(派生类)子类
        Aoo             o         =             new Boo();
    }
}
class Aoo{} //超类
class Boo extends Aoo{} //派生类
 
2. 能点出来什么，看引用的类型 
public class Test{
    public static void main(String[] args) {
        //超类型(父类)    引用    指向     对象(派生类)子类
        Aoo             o         =             new Boo();
        o.sayHi(); // Aoo的sayHi方法
        // o.sayHello(); // 报错，引用只能调用Aoo的方法
    }
}
class Aoo{ // 超类
    void sayHi() {
        System.out.println("Aoo的sayHi方法");
    }
}
class Boo extends Aoo{ // 派生类
    void sayHello() {
        System.out.println("Boo的sayHello方法");
    }
} 

3. 如果父类的方法被子类所重写，调用的就是子类的方法（看对象的类型） 
 

如不了解 方法的重写，请先参考学习下面重写的知识点 
public class Test{
    public static void main(String[] args) {
        //超类型(父类)    引用    指向     对象(派生类)子类
        Aoo             o         =             new Boo();
        // 由于sayHi方法被子类重写，实际调用的就是子类的方法
        o.sayHi(); // Boo的重写后的sayHi方法
        // o.sayHello(); // 报错，引用只能调用Aoo的方法
    }
}
class Aoo{ // 超类
    void sayHi() {
        System.out.println("Aoo的sayHi方法");
    }
}
class Boo extends Aoo{ // 派生类
    // 方法的重写
    void sayHi() {
        System.out.println("Boo的重写后的sayHi方法");
    }
    void sayHello() {
        System.out.println("Boo的sayHello方法");
    }
} 

二、方法的重写（Override） 
1. 定义 
 
 重写(覆盖)：父子类中，子类方法与父类方法的名称相同，参数列表也相同我们称之为方法的重写 方法的签名 = 方法名称 + 参数列表 我们又称：父子类中，子类与父类方法的签名相同的方法叫方法的重写 当父类提供的方法不能满足你的业务需求时，需要重写 
 在这里插入图片描述
 
三、访问控制修饰符 

类的访问控制权限只能是 public 和 默认的

类中成员的访问权限四种都可以使用 


四、static 关键字 
 
 static 是Java中的一个关键字，表示静态的意思。表示全局唯一的，一经改变，都进行改变 
 
1. staitc 使用场景 
1.1 修饰变量：静态变量 
静态变量，又称类变量，由static修饰属于类，存储的方法区中，只有一份常常通过类名点的方式来调用何时用：所有对象所共享的数据（图片、音频、视频）static不能修饰局部变量 
public  class Animal { //动物
    public int age = 1;
    public static double weight = 100; //体重
    public void sayHi() {
        this.age = age + 1;
        System.out.println(age);
        this.weight = weight + 5;
        System.out.println(weight);
        System.out.println(age + "/" + weight);
    }
    public static void main(String[] args) {
        Animal a = new Animal();
        a.sayHi();// 2/105.0
        Animal a1 = new Animal();
        a1.sayHi();// 2/110.0
        Animal a2 = new Animal();
        a2.sayHi();// 2/115.0
    }    
}
 在这里插入图片描述
1.2 修饰方法：静态方法 
由static修饰属于类，存储的方法区中，只有一份常常通过类名点的方式来调用静态方法中没有隐式的this传递，静态方法中不能直接访问实例成员何时用：方法的操作与对象无关----方法中不需要访问对象的属性或行为 
public class Animal{
    public static String name;//静态变量
    int age;
    public void sayHi() {
        this.name = "动物";
        this.age = 2;
        sayHello(); // 在sayHi这个普通方法中能直接调用sayHello这种实例成员
    }
    public void sayHello() {
    }
    public static void say() {
        Animal.name = " ";
        Animal a = new Animal();
        // age = 18; // 报错,在say这个静态方法中不能直接访问实例成员,需要通过new对象打点的方式访问
        a.age = 5;
        // sayHello(); // 报错,在say这个静态方法中不能直接访问实例成员,需要通过new对象打点的方式访问
        a.sayHello();
    }
}

1.3 修饰代码块：静态代码块 
由static修饰属于类，在类被加载期间自动执行，类只被加载一次，所以静态块也只执行一次何时用:加载/初始化静态资源(图片、音频、视频等) 
public class Animal{
    static {
        System.out.println("静态代码块1");
    }
    static {
        System.out.println("静态代码块2");
    }
    {
        System.out.println("构造代码块");
    }
    Animal(){
        System.out.println("无参构造");
    }
    
    public static void main(String[] args) {//有输出结果吗?//是什么?    
        // 静态代码块1 -> 静态代码块2 -> 构造代码块 -> 无参构造
        Animal a1 = new Animal();
        // 构造代码块 -> 无参构造
        Animal a2 = new Animal();
    }
}
五、拓展 
1. 重载和重写的区别 
1.1 概念 
重载（overload） 
  发生在同一个类中，方法名相同，参数列表不同，方法体不同与返回值类型无关编译期绑定 重写（override） 
  发生在父子类中，方法名称相同，参数列表相同（方法名称+参数列表=方法的签名）方法体不同重写遵循两同两小一大 
    1）两同：方法名相同，参数列表相同（方法的签名）2）两小：（返回值类型、异常、访问权限） 
      A. 子类方法的返回值小于等于父类方法的返回值 
        a. void/基本类型返回值必须相同b. 引用类型的返回值小于等于父类的返回值 B. 子类方法抛出的异常小于或等于超类的方法抛出的异常 3）一大：子类方法的访问权限大于或等于父类方法的 运行期绑定  
1.2 案例 
重写： 
 两小 
  子类方法的返回值小于等于父类方法的返回值 
     void/基本类型返回值必须相同 
       void class Aoo{//超类
    void sayHi() {}    
}
class Boo extends Aoo{//派生类
    void sayHi() {}
}
123456  基本类型 class Aoo{//超类
    int sayHi() {return 1;}    
}
class Boo extends Aoo{//派生类
    int sayH() {return 2;}//是重写
}class Aoo{//超类
    int sayHi() {return 1;}    
}
class Boo extends Aoo{//派生类
    double sayHi(){return 4.0;}//不是重写
}
123456   引用类型的返回值小于等于父类的返回值 
       小于指的是父类方法类型的子类，或者子类的子类，等于是指和父类方法类型相同 public class Father {}
public class Son extends Father{}

 

public class Aoo {
    Father getObject() {
        System.out.println("Aoo");
        return new Father();
    }
}
public class Boo extends Aoo{
    Father getObject() {
        System.out.println("Boo");
        return new Father();
    }
}
public class Coo extends Aoo{
    Son getObject() {
        System.out.println("Coo");
        return new Son();
    }
}

public class Demo {
    public static void main(String[] args) {
        Aoo o1 = new Boo();
        o1.getObject(); // Boo
        Aoo o2 = new Coo();
        o2.getObject(); // Coo
    }
}
    一大 在这里插入图片描述
  派生类方法的访问权限大于或等于超类方法的   

 


注意：构造方法不能重写，声明为 final 的方法不能被重写，声明为 static 的方法不能被重写，但是可以被再次声明 
2. 变量的划分 
 
 变量按照作用域来划分：a.成员变量 b.局部变量 
 
 在这里插入图片描述
 成员变量 
  实例变量 
    没有static修饰，属于对象的，存储在堆中，有几个对象就有几份（new），通过对象名点来访问 静态变量（类变量） 
    由static修饰，属于类的，存储在方法区中，只有一份，常常通过类名点来访问 我们常常说实例变量属于对象，静态变量属于类。  

在这里插入图片描述

 

 局部变量 
  形参：方法签名中定义的变量代码块（语句块）：{ }  
六、练习题 
1. 练习题 
1.1 向上造型，重写 
应用知识点： 
能点出来什么，看引用的类型重写的方法被调用时，看对象的类型 
1.1.1 第一题 
public class Test {
    public static void main(String[] args) {
        Aoo o = new Boo();
        o.sayHi();//输出的是什么?为什么?
        o.sayHello("李四");//输出的是什么?为什么?
    }
}
class Aoo{//超类
    String name;
    Aoo(){}
    Aoo(String name){
        this.name = name;
        System.out.println("超类");
    }
    void sayHi() {
        System.out.println("Aoo的方法");
    }
    void sayHello(String name){
        System.out.println("大家好我叫"+name);
    }
}
class Boo extends Aoo{//派生类
    int age;
    Boo(){}
    Boo(String name,int age){
        super(name);
        this.age = age;
        System.out.println("派生类");
    }
    void sayHi() {
        System.out.println("Boo的方法");
    }
    void sayHello(String name,int age){
        System.out.println("大家好我叫"+name + ",今年"+age+"岁了");
    }
}

1.1.2 第二题 
public class Test {
    public static void main(String[] args) {
        Aoo o = new Boo();
        o.sayHi();//输出的是什么?为什么?
        o.sayHello("李四");//输出的是什么?为什么?
    }
}
class Aoo{//超类
    String name;
    Aoo(){}
    Aoo(String name){
        this.name = name;
        System.out.println("超类");
    }
    void sayHi() {
        System.out.println("Aoo的方法");
    }
    void sayHello(String name){
        System.out.println("大家好我叫"+name);
    }
}
class Boo extends Aoo{//派生类
    int age;
    Boo(){}
    Boo(String name,int age){
        super(name);
        this.age = age;
        System.out.println("派生类");
    }
    void sayHi() {
        System.out.println("Boo的方法");
    }
    void sayHello(String name){
        System.out.println("大家好我叫"+name + ",今年"+age+"岁了");
    }
}

1.1.3 第三题 
public class Test {
    public static void main(String[] args) {
        Aoo o = new Boo("张三",15);
        o.sayHi();//输出的是什么?为什么?
        o.sayHello("李四");//输出的是什么?为什么?
    }
}
class Aoo{//超类
    String name;
    Aoo(){}
    Aoo(String name){
        this.name = name;
        System.out.println("超类");
    }
    void sayHi() {
        System.out.println("Aoo的方法");
    }
    void sayHello(String name){
        System.out.println("大家好我叫"+name);
    }
}
class Boo extends Aoo{//派生类
    int age;
    Boo(){}
    Boo(String name,int age){
        super(name);
        this.age = age;
        System.out.println("派生类");
    }
    void sayHi() {
        System.out.println("Boo的方法");
    }
    void sayHello(String name){
        System.out.println("大家好我叫"+name + ",今年"+age+"岁了");
    }
}

1.2 静态static 
应用知识点： 
静态变量属于类实例变量属于对象 
1.2.1 第一题 
创建一个 Student 类 
  变量 money (钱) ，每个学生出门前，兜里揣了100元，（默认值 100 块）变量 water (饮用水)，教室门前有一桶水，默认值 10000 ml创建一个方法 buy，方法目的是买水，每个人花 5 元，买500ml 水main 方法中，创建3个学生对象，分别调用买水方法，观察最终每个学生剩多少钱，水剩多少思考：变量应该是什么变量分析并画出内存结构图  
2. 答案 
2.1 
 未完待续… 
2.2 
2.2.1 
1. 第一种写法 
public class Student {

 

    public double money = 100; // 钱是每个人自己独有的
    public static int water = 10000; // 饮水机里的水是班级里所有学生所共有的

    public static void main(String[] args) {
        Student s1 = new Student();
        s1.buy();
        Student s2 = new Student();
        s2.buy();
        Student s3 = new Student();
        s3.buy();
    }

    void buy() {
        money-=5;
        water-=500;
        System.out.println("money = " + money +" , water = " + water);
    }
}
2. 第二种写法 
public class Student {

    public double money = 100;
    public static int water = 10000;

    public static void main(String[] args) {
        Student[] students = new Student[3];
        for (int i = 0; i < students.length; i++) {
            students[i] = new Student();
            students[i].buy();
        }
    }

    void buy() {
        money-=5;
        water-=500;
        System.out.println("money = " + money +" , water = " + water);
    }
}在这里插入图片描述

 

Java小白入门200例88之Java多态
编程界明世隐的博客
10-05 492
作者简介 作者名：编程界明世隐 简介：优快云博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 概述 多态性是面向对象编程的又一个重要特征，它是指在父类中定义的属性和方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为，这使得同一个属性或方法在父类及其各个子类中具有不同的含义。 Java 实现多态有 3 个必要条件：继承、重写和向上转型。只有满足这
Java小白入门200例80之Java继承（extends）
编程界明世隐的博客
10-01 868
作者简介 作者名：编程界明世隐 简介：优快云博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 引言 很多Java初学者问我，新手明明很用心、很努力学习的Java知识，转头又忘记了，很让人犯愁，小白如何能够快速成长、成为大牛呢？ 其实要成为大神的技巧只有一个：“多学多练”，于是明哥就整理了比较典型的练习实例，通过练习能够快速提升编码技巧和熟练度，让你在成为大
Java中常见的对象类型简述(DO、BO、DTO、VO、AO、PO)
weixin_30814223的博客
07-05 629
菜鸟一枚，进公司看见一堆这个O那个O，一脸懵，然后搜索了下，在此记录下 概念及理解这些概念用于描述对象的类型；由于java是面向对象的语言；程序的世界就是各个对象之间的“交互”；在交互的工程中会存在多个层次，每个层次中所拥有（关注）的内容都是不一样的； PO(Persistant Object) 持久对象 用于表示数据库中的一条记录映射成的 java 对象。PO 仅仅用于表示...
继承：Extends
JaVastudyy的博客
04-18 445
package exstend; public class ex { /* 继承： - 作用：代码复用 - 通过extends来实现继承 - 超类/父类：共有的属性和行为 派生类/子类：特有的属性和行为 - 派生类既能访问自己的，也能访问超类，但是超类不能访问派生类的 - 一个超类可以有多个派生类，一个派生类只能有一个超类---------单一继承 - 具有传递性 派生类与超类的演示 package ooday03; //此类为超类 public class Aoo { .
JAVA面向对象四
m0_64691190的博客
01-13 1861
1 方法的重写(override /overriding): 重新 覆盖 = 发生在父子类中, 方法名相同, 参数列表相同 =重写方法被调用时, 看对象的类型-------这是规定 当派生类觉超类的行为不够好时或者是不满足派生类的时候, 可以用重写 我继承了一个中餐馆 class Aoo{ void do(){ 做中餐 } } A:我还是想做中餐------------不需要重写 class Boo extends Aoo{ ...
阿里巴巴Java开发手册中的DO、DTO、BO、AO、VO、POJO定义
Code Writers
12-08 1114
BO对内，为了进行业务计算需要辅助数据，或者是一个业务有多个对外的接口，BO可能会含有很多接口对外所不需要的数据，因此DTO需要在BO的基础上，只要自己需要的数据，然后对外提供。为什么BO也画成横跨两层呢？BO是一个业务对象，一类业务就会对应一个BO，数量上没有限制，而且BO会有很多业务操作，也就是说除了get，set方法以外，BO会有很多针对自身数据进行计算的方法。复杂点儿的例子PO1是交易记录，PO2是登录记录，PO3是商品浏览记录，PO4是添加购物车记录，PO5是搜索记录，BO是个人网站行为对象。
Java新手小白入门篇 Java面向对象（一）
weixin_68893669的博客
12-06 385
面向对象
01Java入门篇（D1_Java入门前的认知）
思维码途
08-08 1693
编程就是让计算机为解决某个问题而使用某种程序设计语言编写程序代码，并最终得到相应结果的过程。编程就是写那些指令的过程，我们使用一种编程语言来实现这些指令的编写，这些指令被翻译成计算机能够读懂的格式，最后由计算机执行指令。计算机编程语言包括C语言、C++语言 Java语言、Python语言、数据库开发语言、其他编程语言。计算机编程语言是程序设计的最重要的工具，它是指计算机能够接受和处理的、具有一定语法规则的语言。很多人觉得编程是门高深莫测的学问, 担心自己学不来。
Java小白从入门到精通，Java零基础入门看这一篇就够了
qq_51082517的博客
10-08 8586
作为刚刚接触java的小白，今天这篇文章的目的是帮助大家快速入门java，少走弯路 如何快速入门Java？ 一、作为刚接触Java的新手，先了解Java的基础。 Java 基本语法、Java 平台应用、Java的核心概念：JVM、JDK、JRE以及Java面向对象思想，同时要会学到如何在系统中搭建Java开发环境，以及如何利用第三方工具进行Java程序的开发。 还有记住学习Java语言最重要的是两点： 学习步骤/方法 学习资源 找到适合自己的学习方式，找到适合自己现阶段的学习资料，学习的过程中最好记笔记，.
关于Java中(PO,DO,DTO,DAO,POJO)几种对象的介绍
小小渔夫
06-11 2765
PO PO即persistant object—持久对象。在O/R映射的时候出现的概念，如果没有O/R映射，没有这个概念存在了。通常对应数据模型 (数据库), 本身还有部分业务逻辑的处理。可以看成是与数据库中的表相映射的 java 对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。 PO中应该不包含任何对数据库的操作。 DO DO即Domain Object—领...
关于Java中的对象类型 ---- DO、BO、DTO、VO、AO、PO
Biu_Destiny的博客
08-10 873
关于Java中的对象类型 ---- DO、BO、DTO、VO、AO、PO   对象名 全称 介绍 PO Persistant Object 用于表示数据库中一条记录映射而成的java对象，仅用于表示数据 DAO Data Access Object 用于表示数据访问对象，包含CRUD操作。一般在持久层，向下封装数据库操作，向上暴露方法 VO Value Object 用于表示一个与前端交互的java对象 DTO Data Transfer Object 用于表示一个数据
java函数ao活动对象_[AO] AO全面介绍
weixin_29054195的博客
02-27 484
活动对象：一．同步函数被调用时，它会将服务执行完成，然后才返回到其调用处。异步函数则会在函数调用中提交一个请求，然后马上返回到调用处，但该请求会迟些才会完成。在请求完成之前，调用者可以继续执行其它的处理，在请求完成时，调用者会接受到一个表明请求成功或失败的通知信号。这个通知信号就是一个事件，而这种方式就是事件驱动的。虽然所有活动对象事件处理(RunL)都是非抢占的，但在多数情况下，可以在活动对象的...
深入理解javascript中的AO对象
Limitless1113的专栏
05-12 4282
1.主要理解一点，里面的scope属性就先保存了所有父级环境的AO对象，这个scope属性是静态的，除非函数被销毁，否则从函数创建时就已经存在。 2.函数运行时会创建变量，将在scope属性中加入自身AO对象。 3.有一个特例，var x = 10; function foo() { var y = 20; function barFD() { // 函数声明 al
Java-对象数组
AOLILILILIAO的博客
05-20 425
对象数组实际上是引用变量构成的数组。 所以调用circleArray[1].getArea()就包含两个层次的引用，如下图所示。 circleArray引用整个数组。circleArray[1]引用一个Circle对象。 例题：汇总圆的面积 编写程序，将一个Circle数组的面积相加。 程序创建由5个Circle对象组成的数组 然后以随机数初始化圆的半径 显示数组中所有圆的总面积 public class CircleWithPrivateDataFields { private double rad
Java中的DO、DTO、BO、AO、VO、POJO定义
鱼小鱼的博客
04-11 4445
参考： 1、阿里巴巴Java开发手册中的DO、DTO、BO、AO、VO、POJO定义：https://www.cnblogs.com/EasonJim/p/7967999.html 2、Java中 VO、 PO、DO、DTO、 BO、 QO、DAO、POJO的概念： https://www.hollischuang.com/archives/553 3、阿里巴巴开发手册： http://www....
Java编程输出你的年龄和姓名
m0_65725268的博客
01-05 9450
答案： package project2; import java.util.Scanner; public class 姓名年龄 { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Scanner in=new Scanner(System.in); System.out...
Java 泛型详解：类型参数的力量
ZHE|张恒的博客
11-28 1148
本文系统讲解了Java泛型的概念与使用方式。泛型通过在类或方法中引入类型参数，提高了代码的类型安全性和复用性。主要内容包括：1）泛型的基本语法，如定义泛型类和接口；2）泛型方法及其类型推断；3）三种通配符（?、? extends T、? super T）的使用场景；4）边界限制和多重限制；5）泛型的优缺点，如类型安全与类型擦除的影响；6）常见陷阱，如静态上下文和instanceof的限制。泛型是现代Java编程的重要特性，能显著减少类型转换和运行时错误。
TensorRT笔记（5）：研究timingCache
最新发布
ouliten的博客
12-02 400
在里出现了大量的timingCache，但是当时没有取研究这是干啥的，本文就来解析一下。样例都基于上面的文章。
Java面向对象编程：深入理解英雄类设计
标题“java-面向对象的英雄类”暗示了本文件包含了关于Java语言在面向对象编程（OOP）范式中的应用，特别是与“英雄”相关的类设计。面向对象编程是一种编程范式，它使用“对象”来设计软件。对象可以包含数据，以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值