Java SE:面向对象(下)

这篇具有很好参考价值的文章主要介绍了Java SE:面向对象(下)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

1. static关键字

静态区的特点:静态区里面的每一样东西都是唯一有且仅有一个的,如此时str1 = "abc"即此时静态区里面已经创建了字符串abc并将abc地址赋给str1,后面在进行赋值也不会在静态区开辟一串新的"abc"

Java SE:面向对象(下),java,开发语言

  

Java SE:面向对象(下),java,开发语言

1.1 static修饰成员 

区分:

一个类的成员有static修饰的成员存储在静态区,statci修饰的成员一旦被赋值那么所有通过这个类创建的对象都会有这个成员的值,一旦修改是该类的所有对象的这个成员被修改

Java SE:面向对象(下),java,开发语言

 栗子:idea中int类型的变量未赋值会默认赋0,double默认0.0,存储地址的变量默认赋空(null)

Java SE:面向对象(下),java,开发语言

 static修饰的成员变量叫静态变量,通常用类名来赋值如:Student(类名).Teacher(被static修饰的成员变量)

1.2 static修饰方法 

静态(static)修饰方法和非静态方法之间存在一些关键的区别,主要表现在以下几个方面:

  1. 加载和执行时间:静态方法随着类的加载而加载,属于类方法,而非静态方法属于类的实例对象。因此,静态方法在类加载阶段就已加载到内存中,而非静态方法只有在创建类的实例对象时才会加载。这意味着静态方法在类加载阶段就已执行,而非静态方法则是在对象实例化后执行。
  2. 访问权限:静态方法只能访问静态变量,不能直接访问非静态变量。而非静态方法可以访问静态和非静态变量。
  3. 调用方式:静态方法可以通过类名直接调用,不需要创建类的实例对象。而非静态方法必须通过类的实例对象才能调用。
  4. 内部实现:在内部实现上,静态方法只能调用其他静态方法和静态变量,不能使用非静态方法和非静态变量。而非静态方法可以调用静态和非静态方法以及非静态变量。
  5. 代码块:静态代码块在类加载时主动执行,普通代码块在实例化时主动执行。静态代码块与静态方法的区别在于,静态代码块只能主动执行一次,而静态方法可以被多次调用。

总的来说,使用static修饰的方法属于类本身,而非static修饰的方法属于类的实例对象。因此,静态方法具有更早的加载和执行时间,更严格的访问权限和调用方式,以及特定的内部实现和执行流程。这些区别使得静态方法和非静态方法在设计和使用上有着不同的考虑和应用场景。

2. 继承 

2.1 继承的特点 

  • 继承:把其他已经定义好的类的东西搬到要新定义的类中称之为继承,被继承的类称为父类,继承的类称为子类,继承之后子类可以调用父类的东西
  • Java只支持单继承,不支持多继承,但支持多层继承                                                      1. 单继承理解:每个类只能继承一个类(大白话理解:一个儿子只有一个亲爸)            2. 不支持多继承:定义的新类c即继承类a又继承类b,Java中是不允许的,(大白话理解:c类有两个亲爸,这在Java是不允许发生的)                                                              3. 多层继承:c类继承d类,b类继承c类,a类继承b类,这是允许的(因为c继承d,c此时是个新的单独的一个类,只是有d的一些特征,此时符合单继承,再接着b类继承c类,b此时也是个新的单独的类,但是c有d的特征,而b又继承c,故b有c和d的特征,这称之为多层继承,并没有违反单继承的规则,b的继承又可以理解为直接继承于c,间接继承于d)
  • Java所有类都直接或简接的继承于Object类,即Object类是所有类的祖宗

2.2 继承的好处 

将共性的东西抽取出来,定义为一个类,后面定义其他类时可直接继承进行调用,无需再重复写代码,减少代码冗余,提高开发效率

2.3 eg: 

 Java SE:面向对象(下),java,开发语言

2.4 extends关键字 

extends:是继承时需要用到的关键字, 

书写格式: public class 继承者的类名 extends 被继承者的类名 { 代码...} 

 2.5 子类可以继承父类哪些内容

  • 非私有(public、proteted关键字修饰)和私有(private修饰)的构造方法都不能被继承  原因:类名是唯一的,即类不能重复定义,而构造方法和类名是保持一致的,故子类若继承了父类的构造方法,就不符合构造方法和类名保持一致的语法规则
  •  非私有(public、proteted关键字修饰)和私有(private修饰)的成员都能被继承              原因:每个标准的JavaBean都会有输入输出方法,而每个对象成员变量可以通过输入  输出方法进行输入输出,故成员可以继承下来进行使用
  • 非私有(public、proteted关键字修饰)的成员能被继承,私有(private修饰)的成员方法不能被继承                                                                                                                          原因:被private关键字修饰的方法只能在本类中使用,故无法继承到别的类中去

面向对象的一些概念不重复赘述,我另一篇学术垃圾里面有,欢迎进来刨垃圾嘿嘿 

m

2.6 super、this关键字和就近原则

2.6.1 继承中成员变量的访问特点

  • 没有任何关键字修饰的变量会先从局部变量开始寻找访问,若有则直接访问,若没有则从本类中成员变量 寻找,若还是没有,则从父类的成员变量中寻找访问,还是没有就会报错,遵循就近原则,离谁近先用谁
  • this关键字修饰的,直接跳过局部变量的搜寻,直接从本类的成员变量中开始搜寻
  • super关键字修饰的,直接跳到父类的成员变量中搜寻

eg: 

Java SE:面向对象(下),java,开发语言

 2.6.2 继承中成员方法的访问特点

和上面成员变量一样 

  • 直接调用满足:离谁近先用谁
  • this关键字修饰:从本类中成员变量开始寻找,没有就访问父类
  • super修饰:直接访问父类的成员

2.7 方法的重写 

 在继承体系中子类和父类出现一摸一样的方法定义时叫做方法的重写

一般父类的方法不满足子类的需求时会进行方法重写,方法重写前加上@Override注释进行验证重写方法是否有语法错误, 该注释不同于普通的注释,该注释还是写给虚拟机看的

Java SE:面向对象(下),java,开发语言

重写的本质 

Java SE:面向对象(下),java,开发语言

加载进虚方法表的条件

  •  不能被static关键字修饰,被static关键字修饰的方法只在static修饰的方法中调用权限不够大,不能被继承下来 
  • 不能被private关键字修饰,被private修饰的方法只能在本类中使用,权限不够大

 方法的访问是先从本类中查找,在查找虚方法表的,故有super修饰就直接从虚表中查询,即直接访问父类的方法

注意:

  1. 重写的方法必须和父类方法名、形参列表保持一致
  2. 重写的方法访问权限必须大于或等于父类
  3. 重写的方法返回值类型必须小于或等于父类
  4. 只有加载进虚方法表中的方法才能被重写

2.8 继承中的构造方法  

  • 子类无法继承父类的构造方法
  • 子类所有构造方法都默认先访问父类的无参构造方法,再执行自己,若要访问父类的有参构造方法得自己写

书写格式 :在子类的构造方法中添加super(调用带参数构造方法就写参数进括号不带可忽略),若不写super()虚拟机会默认调用父类无参的构造方法

super()必须写在构造方法里的最前面,即有效代码的第一行

Java SE:面向对象(下),java,开发语言

3. 多态 

3.1 多态特点:

  • 多态:一个对象多种形态 
  • 好处:一个方法可以让多个(不同形态的)对象调用,提高代码复用性,减少代码冗余,提高开发效率  

3.2 栗子  

后面即使在添加子类也可以直接调用该方法,而不是每添加一个新子类又重写一次 

 Java SE:面向对象(下),java,开发语言

 3.3 多态创建对象格式

父类类名 对象名 = new 子类类名 

 Java SE:面向对象(下),java,开发语言

 通过以上栗子不难发现多态的使用是有前提的

  1.  要有继承关系
  2.  要有重写的方法(比如上面栗子,登录进管理系统后学生、教师都要查询信息但是信     息的具体信息是不同的,教师可能还有管理课程竞赛等内容,那么所用到的方法也是   不同的,所以子类要对应的重写父类的方法)
  3.  父类引用指向子类的对象

3.4 多态调用成员的特点 

 Java SE:面向对象(下),java,开发语言

3.5 父类类型的对象调用子类的方法 

接着上面栗子,只需要将cat强制类型转换即可 ,通过这么一转换即可从子类的表中即上图(堆区new出来的新空间的右表)中开始查询数据,所以可以调用子类的所有方法和成员

注意:转换不能瞎转,new出来的那块空间是什么类型的就只能转该空间的类型,即上面new出来的空间是Cat类的,此时对对象cat转换也只能转成Cat类的,因为转成其他类和上面的空间所记载的数据不同,无法调用,也运行不起来会报错

Java SE:面向对象(下),java,开发语言

3.6  instanceof关键字

Java提供了instanceof关键字进行自动转换,即所转的对象满足条件就会进行转换

if里面那串代码意思:如果对象animal是 Cat类型的就会创建一个新的对象c类型为Cat

Java SE:面向对象(下),java,开发语言

 4. final关键字、权限修饰符、代码块 

4.1 final关键字

  1. final关键字修饰类,则类不能被继承
  2. final关键字修饰方法,则方法不能被重写
  3. final修饰变量,则变量具有常量属性,不能被修改
  • 修饰数值型的变量如:final int a = 10; 则此时a不能被修改,可以把a看成10,若强行修改a = 20即 10 = 20这合理么?不合理,语法也会报错
  • 修饰地址型的变量如:final (类名) a = new 类名(),此时a所存的地址不能不修改,即此时已经固定指向某一块空间了,不能在赋其他空间地址给a,但是a所指的空间里面的内容可以修改

 4.2 权限修饰符

  1. private修饰的成员或方法只能在本类中使用
  2. 没有修饰符即默认的修饰成员或方法只能在本包中使用
  3. protected修饰的成员或方法不仅可以在本包中使用,还可以在其他包的子类中使用
  4. public通用

4.3 代码块

static修饰的代码块,当程序运行时会执行一次,可以利用该特性对某些类的数据进行初始化 

5. 抽象类 

  • 抽象类的作用:可以统一开发时方法的格式,方便开发人员调用方法。 比如:抽象类中定义了一个方法 public void work(); 如果有个类继承了这个抽象类,那么子类要么按照上面的方法格式进行重写方法,要么该子类也定义成抽象类,不然会报错。
  • 抽象类不能实例化(不能创建对象)

abstract关键字 

 抽象一个类或者方法时用到的一个关键字

Java SE:面向对象(下),java,开发语言

 6. 接口

接口:可以理解为一种规则,规定如何定义一个方法的格式,好处也是方法格式统一,方便开发人员进行调用, 

Java SE:面向对象(下),java,开发语言

6.1 接口的成分

  • 接口可以有成员变量,但Java会默认用public static final关键字修饰,即此时的成员变量是个定值不能被修改
  • 接口可以有方法,即此时定义一个方法的格式,后面调用该接口的类都得按照该方法格式进行定义方法,默认用public abstract关键字修饰 
  • 接口不能含有构造方法
  • 接口不能实例化

Java SE:面向对象(下),java,开发语言

 6.2 接口的关系

  1. 接口和接口:有单继承或者多继承的关系 
  2. 类和接口:可以有单实现和多实现的关系,即一个类可以有多个接口(若类实现多个接口那么该类要重写接口里面定义的的所有方法,若类实现的接口有父类,那么接口的父类里面的方法一样要重写)

7. 内部类

7.1 成员内部类

成员内部类也是成员,只是封装成类

应用场景:电脑有很多信息,将电脑封装成类,那么当介绍到电脑里面的CPU、显卡等等时,这些零部件也有很多信息,也可以单独的封装成一个类,此时成员内部类的场景就适用了,因为CPU和显卡封装的类是依附于电脑这个类的,所以可以在电脑这个类里面进行定义

创建内部类对象

方式1:

public class Test8 {

    Computer.Cpu cc = new Computer().new Cpu();
    //成员内部类是成员
    //要调用一个类里面的成员,如果该成员不是静态的,无法通过类名直接调用,需要创建对象才可以调用
    //所以我们要先new电脑这个类出来,然后调用里面的成员,再看成员Cpu也是个类
    //同样要调用一个类的成员还是要先创建对象,所以要在new一次,即此时在堆区开辟了两块空间
    //分别存储Computer类和Cpu类
    //每new一次空间都会返回一个地址,所以cc最终记录第二次new的地址
}

public class Computer {

    String computerName;
    String computerBrand;

    public class Cpu {
        String cpuName;
        String cpuBrand;
    }
}

Java SE:面向对象(下),java,开发语言

 方式2:

外部类定定义个方法,返回内部类的地址即可

public Cpu getCpu() {
        return new Cpu();
    }

成员内部类也是个类,所以用不同权限修饰符修饰有什么区别和前面一样,不过多赘述 

 7.2 静态内部类

静态内部类就是一种特殊的成员内部类,不过是用关键字static修饰,定义了静态内部类后可以直接用类名调用该成员 

 此时没有开辟两次空间,只在堆区上单独开辟一块Cpu类的空间

 Computer.Cpu cc = new Computer.Cpu();

 7.3 匿名内部成员类

不用写类名,适用场景:当一个类不需要重复调用可以定义匿名内部成员类简化代码

定义格式:

new 类名或者接口名() {

};

 栗子

public abstract class Animal {
    public abstract void eat();

    public void drink() {
        System.out.println("喝");
    }
}

public static void main(String[] args) {

        Animal a = new Animal() {
            @Override
            public void eat() {
                System.out.println("吃");
            }
        };
        a.eat();
        a.drink();

    }

Java SE:面向对象(下),java,开发语言文章来源地址https://www.toymoban.com/news/detail-823371.html

到了这里,关于Java SE:面向对象(下)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • [ XJTUSE ]JAVA语言基础知识——第一章 面向对象程序设计思想

    类描述了一组有相同 特性 (属性)和相同 行为 (方法)的对象,类和对象是面向对象思想的两个核心概念 · 人类是一种类,每一个具体的人则是这个类的对象 用面向对象程序来模拟真实世界 发现并创建类 发现类的特征 发现类的行为 在面向对象程序中,对象的特征由各种

    2023年04月13日
    浏览(82)
  • Java面向对象程序开发——网络编程入门知识

    ​ C/S结构 :client/sever是指客户端和服务器结构。常见程序有QQ、迅雷等软件。 B/S结构 :browser/sever是指浏览器和服务器结构。常见浏览器有谷歌、火狐等。 Web应用系统开发的两种流行架构 两种架构各有优势,但是无论哪种架构,都离不开网络的支持。网络编程,就是在一

    2024年02月12日
    浏览(49)
  • 🔥🔥Java开发者的Python快速进修指南:面向对象进阶

    在上一期中,我们对Python中的对象声明进行了初步介绍。这一期,我们将深入探讨对象继承、组合以及多态这三个核心概念。不过,这里不打算赘述太多理论,因为我们都知道,Python与Java在这些方面的主要区别主要体现在语法上。例如,Python支持多重继承,这意味着一个类可

    2024年02月05日
    浏览(59)
  • 🔥🔥Java开发者的Python快速进修指南:面向对象基础

    当我深入学习了面向对象编程之后,我首先感受到的是代码编写的自由度大幅提升。不同于Java中严格的结构和约束,Python在面向对象的实现中展现出更加灵活和自由的特性。它使用了一些独特的,如self和cls,这些不仅增强了代码的可读性,还提供了对类和实例的明确

    2024年02月05日
    浏览(64)
  • Java开发者的Python快速进修指南:面向对象--高级篇

    首先,让我来介绍一下今天的主题。今天我们将讨论封装、反射以及单例模式。除此之外,我们不再深入其他内容。关于封装功能,Python与Java大致相同,但写法略有不同,因为Python没有修饰符。而对于反射来说,我认为它比Java简单得多,不需要频繁地获取方法和属性,而是

    2024年02月05日
    浏览(66)
  • 🔥🔥Java开发者的Python快速进修指南:面向对象--高级篇

    首先,让我来介绍一下今天的主题。今天我们将讨论封装、反射以及单例模式。除此之外,我们不再深入其他内容。关于封装功能,Python与Java大致相同,但写法略有不同,因为Python没有修饰符。而对于反射来说,我认为它比Java简单得多,不需要频繁地获取方法和属性,而是

    2024年02月05日
    浏览(63)
  • c、c++、java、python、js对比【面向对象、过程;解释、编译语言;封装、继承、多态】

    目录 内存管理、适用 区别 C 手动内存管理:C语言没有内置的安全检查机制,容易出现内存泄漏、缓冲区溢出等安全问题。 适用于系统级编程 C++ 手动内存管理:C++需要程序员手动管理内存,包括分配和释放内存,这可能导致内存泄漏和指针错误。 适用于游戏引擎和系统级编

    2024年02月08日
    浏览(73)
  • 【Java SE】类和对象(上)

    目录 一. 面向对象的初步认知 1.1 什么是面向对象 1.2 面向对象与面向过程 二. 类定义和使用 2.1 简单认识类  2.2 类的定义格式 三. 类的实例化  3.1 什么是实例化  3.2 实例化对象  四. this引用(重点)  4.1 为什么要有this引用  4.2 this的使用 4.3 this引用的特性 五.对象的构造及初

    2024年02月03日
    浏览(46)
  • 【Java SE】类和对象详解

    Java是一门纯面向对象的语言(Object Oriented Program,简称OOP),在面向对象的世界里,一切皆为对象。 面向对象是解决问题的一种思想,主要依靠对象之间的交互完成一件事情 。用面向对象的思想来涉及程序,更符合人们对事物的认知,对于大型程序的设计、扩展以及维护都非常

    2024年01月19日
    浏览(47)
  • 【Java SE】类和对象(下)

    接着上文 目录 6. 封装  6.1 封装的概念  6.2 访问限定符 6.3 封装扩展之包 6.3.1 包的概念 6.3.2 自定义包 6.3.3 导入包中的类 6.3.4 包的访问权限控制举例 6.3.5 常见的包  7. static成员 7.1 static修饰成员变量 ​编辑 ​编辑 7.2 static修饰成员方法 8. 代码块 8.1 代码块概念以及分类  

    2024年02月05日
    浏览(40)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包