文章链接:
Java面向对象(高级)-- static关键字的使用-CSDN博客
【static关键字的使用】
static: 静态的
static 用来修饰的结构:属性、方法; 代码块、内部类;(构造器不能够用static修饰)
static修饰属性
3.1 复习:变量的分类
方式1:按照数据类型:基本数据类型、引用数据类型
方式2:按照类中声明的位置:
成员变量:按照是否使用static修饰进行分类:
使用static修饰的成员变量:静态变量、类变量
不使用static修饰的成员变量:非静态变量、实例变量
局部变量:方法内、方法形参、构造器内、构造器形参、代码块内等。
3.2 静态变量:类中的属性使用static进行修饰。
对比静态变量与实例变量:
① 个数
>静态变量:在内存空间中只有一份,被类的多个对象所共享。
>实例变量:类的每一个实例(或对象)都保存着一份实例变量。
② 内存位置
>静态变量:jdk6及之前:存放在方法区。 jdk7及之后:存放在堆空间
>实例变量:存放在堆空间的对象实体中。
③ 加载时机
>静态变量:随着类的加载而加载,由于类只会加载一次,所以静态变量也只有一份。
>实例变量:随着对象的创建而加载。每个对象拥有一份实例变量。
④ 调用者
>静态变量:可以被类直接调用,也可以使用对象调用。
>实例变量:只能使用对象进行调用。
⑤ 判断是否可以调用 —> 从生命周期的角度解释
类变量 实例变量
类 yes no
对象 yes yes
⑥ 消亡时机
>静态变量:随着类的卸载而消亡
>实例变量:随着对象的消亡而消亡
static修饰方法:(类方法、静态方法)
随着类的加载而加载
可以通过“类.静态方法”的方式,直接调用静态方法
静态方法内可以调用静态的属性或静态的方法。(属性和方法的前缀使用的是当前类,可以省略)
不可以调用非静态的结构。(比如:属性、方法)
类方法 实例方法
类 yes no
对象 yes yes
static修饰的方法内,不能使用this和super
补充:在类的非静态方法中,可以调用当前类中的静态结构(属性、方法)或非静态结构(属性、方法)
开发中,什么时候需要将属性声明为静态的?
判断当前类的多个实例是否能共享此成员变量,且此成员变量的值是相同的。
开发中,常将一些常量声明是静态的。比如:Math类中的PI
什么时候需要将方法声明为静态的?
方法内操作的变量如果都是静态变量(而非实例变量)的话,则此方法建议声明为静态方法
开发中,常常将工具类中的方法,声明为静态方法。比如:Arrays类、Math类
文章链接:
Java面向对象(高级)-- 单例(Singleton)设计模式-CSDN博客
设计模式概述:
设计模式是在大量的实践中总结
和理论化
之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式免去我们自己再思考和摸索。
就像是经典的棋谱,不同的棋局,我们用不同的棋谱。“套路”
经典的设计模式一共有23种。
何为单例模式(Singleton):
所谓类的单例设计模式,就是采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法。
如何实现单例模式(掌握):
饿汉式
懒汉式
对比两种模式(特点、优缺点)
特点:
饿汉式:“立即加载”,随着类的加载,当前的唯一实例就创建了
懒汉式:“延迟加载”,在需要使用的时候,进行创建。
优缺点:
饿汉式:(优点)写法简单,由于内存中较早加载,使用更方便、更快。是线程安全的。 (缺点)内存中占用时间较长。
懒汉式:(缺点)线程不安全 (放到多线程章节时解决)(优点)在需要的时候进行创建,节省内存空间。
文章链接:
Java面向对象(高级)-- 单例(Singleton)设计模式-CSDN博客
【main()方法的剖析】
public static void main(String args[]){}
理解1:看做是一个普通的静态方法
理解2:看做是程序的入口,格式是固定的。
与控制台交互
如何从键盘获取数据?
方式1:使用Scanner
方式2:使用main()的形参进行传值。
public static void main(String[] args){}
文章链接:
Java面向对象(高级)-- 类的成员之四:代码块-CSDN博客
【类的成员之四:代码块】
回顾:类中可以声明的结构:属性、方法、构造器;代码块(或初始化块)、内部类
代码块:从长的样子来看的(就是封装了一下代码)
初始化块:从它的作用的角度
代码块(或初始化块)的作用:
用来初始化类或对象的信息(即初始化类或对象的成员变量)
代码块的修饰:
只能使用static进行修饰。
代码块的分类:
静态代码块:使用static修饰
非静态代码块:没有使用static修饰
具体使用:
4.1 静态代码块:
随着类的加载而执行(它没有名字,就不能显示地调用它)
由于类的加载只会执行一次,进而静态代码块的执行,也只会执行一次
作用:用来初始化类的信息
内部可以声明变量、调用属性或方法、编写输出语句等操作。
静态代码块的执行要先于非静态代码块的执行
如果声明有多个静态代码块,则按照声明的先后顺序执行
静态代码块内部只能调用静态的结构(即静态的属性、方法),不能调用非静态的结构(即非静态的属性、方法)
4.2 非静态代码块:
随着对象的创建而执行
每创建当前类的一个实例,就会执行一次非静态代码块
作用:用来初始化对象的信息
内部可以声明变量、调用属性或方法、编写输出语句等操作。
如果声明有多个非静态代码块,则按照声明的先后顺序执行
非静态代码块内部可以调用静态的结构(即静态的属性、方法),也可以调用非静态的结构(即非静态的属性、方法)
【属性赋值的过程】
文章链接:
Java面向对象(高级)-- 类中属性赋值的位置及过程_java 给属性赋值-CSDN博客
可以给类的非静态的属性(即实例变量)赋值的位置有:
① 默认初始化
② 显式初始化 或 ⑤ 代码块中初始化
③ 构造器中初始化
####################################
④ 有了对象以后,通过"对象.属性"或"对象.方法"的方法进行赋值
执行的先后顺序:
① - ②/⑤ - ③ - ④
(超纲)关于字节码文件中的的简单说明:(通过插件jclasslib bytecode viewer查看)
方法在字节码文件中可以看到。每个方法都对应着一个类的构造器。(类中声明了几个构造器就会有几个)
编写的代码中的构造器在编译以后就会以方法的方式呈现
方法内部的代码包含了实例变量的显示赋值、代码块中的赋值和构造器中的代码。
方法用来初始化当前创建的对象的信息的。
给实例变量赋值的位置很多,开发中如何选?
显示赋值:比较适合于每个对象的属性值相同的场景
构造器中赋值:比较适合于每个对象的属性值不相同的场景
文章链接:
Java面向对象(高级)-- final关键字的使用-CSDN博客
【final关键字的使用】
final的理解:最终的
final可以用来修饰的结构:类、方法、变量
具体说明:
3.1 final修饰类:表示此类不能被继承。
比如:String、StringBuffer、StringBuilder类
3.2 final修饰方法:表示此方法不能被重写
比如:Object类中的getClass()
3.3 final修饰变量:既可以修饰成员变量,也可以修饰局部变量。
此时的"变量"其实就变成了"常量",意味着一旦赋值,就不可更改。
3.3.1 final修饰成员变量: 有哪些位置可以给成员变量赋值?
显式赋值
代码块中赋值
构造器中赋值
3.3.2 final修饰局部变量:一旦赋值就不能修改
方法内声明的局部变量:在调用局部变量前,一定需要赋值。而且一旦赋值,就不可更改
方法的形参:在调用此方法时,给形参进行赋值。而且一旦赋值,就不可更改
文章链接:
Java面向对象(高级)-- 抽象类与抽象方法(或abstract关键字)-CSDN博客
【抽象类与抽象方法】
abstract class GeometricObject{ //几何图形
//求面积 (只能考虑提供方法的声明,而没有办法提供方法体。所以,此方法适合声明为抽象方法)
//求周长(只能考虑提供方法的声明,而没有办法提供方法体。所以,此方法适合声明为抽象方法)
}
class Circle extends GeometricObject{
//求面积 (必须重写(或实现)父类中的抽象方法)
//求周长(必须重写(或实现)父类中的抽象方法)
}
class Rectangle extends GeometricObject{
//求面积 (必须重写(或实现)父类中的抽象方法)
//求周长(必须重写(或实现)父类中的抽象方法)
}
举例2:Account-SavingAccount-CheckAcount
abstract class Account{
double balance;//余额
//取钱 (声明为抽象方法)
//存钱 (声明为抽象方法)
}
class SavingAccount extends Account{ //储蓄卡
//取钱 (需要重写父类中的抽象方法)
//存钱(需要重写父类中的抽象方法)
}
class CheckAccount extends Account{ //信用卡
//取钱(需要重写父类中的抽象方法)
//存钱(需要重写父类中的抽象方法)
}
//....
abstract的概念:抽象的
abstract可以用来修饰:类、方法
具体的使用:
4.1 abstract修饰类:
此类称为抽象类
抽象类不能实例化。
抽象类中是包含构造器的,因为子类对象实例化时,需要直接或间接的调用到父类的构造器。
抽象类中可以没有抽象方法。反之,抽象方法所在的类,一定是抽象类。
4.2 abstract修饰方法:
此方法即为抽象方法
抽象方法只有方法的声明,没有方法体。
抽象方法其功能是确定的(通过方法的声明即可确定),只是不知道如何具体实现(体现为没有方法体)
子类必须重写父类中的所有的抽象方法之后,方可实例化。否则,此子类仍然是一个抽象类。
5.2 abstract 不能与哪些关键字共用?(自洽)
不能用abstract修饰私有方法、静态方法、final的方法、final的类。
私有方法不能重写
避免静态方法使用类进行调用
final的方法不能被重写
final修饰的类不能有子类
文章链接:
Java面向对象(高级)-- 接口(interface)-CSDN博客
【接口的使用】
接口的理解:接口的本质是契约、标准、规范,就像我们的法律一样。制定好后大家都要遵守。
定义接口的关键字:interface
接口内部结构的说明:
可以声明:
属性:必须使用public static final修饰
方法:jdk8之前:声明抽象方法,修饰为public abstract
jdk8:声明静态方法、默认方法
jdk9:声明私有方法
不可以声明:构造器、代码块等
接口与类的关系 :实现关系
格式:class A extends SuperA implements B,C{}
A相较于SuperA来讲,叫做子类
A相较于B,C来讲,叫做实现类。
满足此关系之后,说明:
类可以实现多个接口。
类针对于接口的多实现,一定程度上就弥补了类的单继承的局限性。
类必须将实现的接口中的所有的抽象方法都重写(或实现),方可实例化。否则,此实现类必须声明为抽象类。
接口与接口的关系:继承关系,且可以多继承
接口的多态性: 接口名 变量名 = new 实现类对象;
面试题:区分抽象类和接口
共性:都可以声明抽象方法
都不能实例化
不同:① 抽象类一定有构造器。接口没有构造器
② 类与类之间继承关系,类与接口之间是实现关系,接口与接口之间是多继承关系
public static final
修饰 (可以省略)文章链接:
Java面向对象(高级)-- 类的成员之五:内部类(InnerClass)-CSDN博客
【类的成员之五:内部类】
什么是内部类?
将一个类A定义在另一个类B里面,里面的那个类A就称为内部类(InnerClass)
,类B则称为外部类(OuterClass)
。
为什么需要内部类?
具体来说,当一个事物A的内部,还有一个部分需要一个完整的结构B进行描述,而这个内部的完整的结构B又只为外部事物A
提供服务,不在其他地方单独使用,那么整个内部的完整结构B最好使用内部类。
总的来说,遵循高内聚、低耦合
的面向对象开发原则。
内部类使用举例:
Thread类内部声明了State类,表示线程的生命周期
HashMap类中声明了Node类,表示封装的key和value
内部类的分类:(参考变量的分类)
成员内部类:直接声明在外部类的里面。
使用static修饰的:静态的成员内部类
不使用static修饰的:非静态的成员内部类
局部内部类:声明在方法内、构造器内、代码块内的内部类
匿名的局部内部类
非匿名的局部内部类
内部类这节要讲的知识:
成员内部类的理解
如何创建成员内部类的实例
如何在成员内部类中调用外部类的结构
局部内部类的基本使用
关于成员内部类的理解:
从类的角度看:
- 内部可以声明属性、方法、构造器、代码块、内部类等结构
- 此内部类可以声明父类,可以实现接口
- 可以使用final修饰
- 可以使用abstract修饰
从外部类的成员的角度看:
- 在内部可以调用外部类的结构。比如:属性、方法等
- 除了使用public、缺省权限修饰之外,还可以使用private、protected修饰
- 可以使用static修饰
关于局部内部类的说明:
成员内部类的理解
如何创建成员内部类的实例
如何在成员内部类中调用外部类的结构
局部内部类的基本使用(关注:如何在方法内创建匿名局部内部类的对象)
文章链接:
Java面向对象(高级)-- 枚举类的使用-CSDN博客
【枚举类的使用】
枚举类的理解:
枚举类型本质上也是一种类,只不过是这个类的对象是有限的、固定的几个,不能让用户随意创建。
举例:
星期
:Monday(星期一)…Sunday(星期天)性别
:Man(男)、Woman(女)月份
:January(1月)…December(12月)季节
:Spring(春节)…Winter(冬天)三原色
:red(红色)、green(绿色)、blue(蓝色)支付方式
:Cash(现金)、WeChatPay(微信)、Alipay(支付宝)、BankCard(银行卡)、CreditCard(信用卡)就职状态
:Busy(忙碌)、Free(空闲)、Vocation(休假)、Dimission(离职)订单状态
:Nonpayment(未付款)、Paid(已付款)、Fulfilled(已配货)、Delivered(已发货)、Checked(已确认收货)、Return(退货)、Exchange(换货)、Cancel(取消)线程状态
:创建、就绪、运行、阻塞、死亡开发中的建议:
开发中,如果针对于某个类,其实例是确定个数的。则推荐将此类声明为枚举类。
如果枚举类的实例只有一个,则可以看做是单例的实现方式。
JDK5.0 之前如何自定义枚举类 (了解)
见代码
JDK5.0中使用enum定义枚举类
见代码
Enum中的常用方法:
6.1 使用enum关键字定义的枚举类,默认其父类是java.lang.Enum类
使用enum关键字定义的枚举类,不要再显示的定义其父类。否则报错。
6.2 熟悉Enum类中常用的方法
String toString(): 默认返回的是常量名(对象名),可以继续手动重写该方法!
(关注)static 枚举类型[] values():返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值,是一个静态方法
(关注)static 枚举类型 valueOf(String name):可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是,会有运行时异常:IllegalArgumentException。
String name():得到当前枚举常量的名称。建议优先使用toString()。
int ordinal():返回当前枚举常量的次序号,默认从0开始
枚举类实现接口的操作
情况1:枚举类实现接口,在枚举类中重写接口中的抽象方法。当通过不同的枚举类对象调用此方法时,执行的是同一个方法。
情况2:让枚举类的每一个对象重写接口中的抽象方法。当通过不同的枚举类对象调用此方法时,执行的是不同的实现的方法。
文章链接:
Java面向对象(高级)-- 注解(Annotation)-CSDN博客
【注解的使用】
Annotation的理解
注解(Annotation)是从JDK5.0
开始引入,以“@注解名
”在代码中存在。
Annotation 可以像修饰符一样被使用,可用于修饰包、类、构造器、方法、成员变量、参数、局部变量的声明。
还可以添加一些参数值,这些信息被保存在 Annotation 的 “name=value” 对中。
注解可以在类编译、运行时进行加载,体现不同的功能。
注解的应用场景:
示例1:生成文档相关的注解
示例2:在编译时进行格式检查(JDK内置的三个基本注解)
示例3:跟踪代码依赖性,实现替代配置文件功能
Java基础涉及到的三个常用注解
@Override
: 限定重写父类方法,该注解只能用于方法
@Deprecated
: 用于表示所修饰的元素(类,方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择
@SuppressWarnings
: 抑制编译器警告
自定义注解
以@SuppressWarnings为参照,进行定义即可。
元注解的理解:
元注解:对现有的注解进行解释说明的注解。
讲4个元注解:
(1)@Target:用于描述注解的使用范围
可以通过枚举类型ElementType的10个常量对象来指定
TYPE,METHOD,CONSTRUCTOR,PACKAGE…
(2)@Retention:用于描述注解的生命周期
可以通过枚举类型RetentionPolicy的3个常量对象来指定s
SOURCE(源代码)、CLASS(字节码)、RUNTIME(运行时)
唯有RUNTIME阶段才能被反射读取到。
(3)@Documented:表明这个注解应该被 javadoc工具记录。
(4)@Inherited:允许子类继承父类中的注解
拓展: 元数据。
String name = “Tom”;
框架 = 注解 + 反射 + 设计模式
文章链接:
Java面向对象(高级)-- 包装类(wrapper)的使用-CSDN博客
【包装类的使用】
为什么要使用包装类?
为了使得基本数据类型的变量具备引用数据类型变量的相关特征(比如:封装性、继承性、多态性),我们给各个基本数据
类型的变量都提供了对应的包装类。
(掌握)基本数据类型对应的包装类类型
byte -> Byte
short -> Short
int -> Integer
long -> Long
float -> Float
double ->Double
char -> Character
boolean -> Boolean
掌握基本数据类型 与 包装类之间的转换。
3.1 为什么需要转换
一方面,在有些场景下,需要使用基本数据类型对应的包装类的对象。此时就需要将基本数据类型的变量转换为
包装类的对象。比如:ArrayList的add(Object obj);Object类的equals(Object obj)
对于包装类来讲,既然我们使用的是对象,那么对象是不能进行+ - * /等运算的。为了能够进行这些运算,就
需要将包装类的对象转换为基本数据类型的变量。
3.2 如何转换:
(装箱)基本数据类型 —> 包装类:① 使用包装类的构造器 ② (建议)调用包装类的valueOf(xxx xx)
(拆箱)包装类 —> 基本数据类型:调用包装类的xxxValue()
注意:原来使用基本数据类型变量的位置,改成包装类以后,对于成员变量来说,其默认值变化了!
jdk5.0新特性:自动装箱、自动拆箱。
String 与 基本数据类型、包装类之间的转换。
基本数据类型、包装类 —> String类型:① 调用String的重载的静态方法valueOf(xxx xx) ; ② 基本数据类型的变量 + “”
String类型 —> 基本数据类型、包装类: 调用包装类的静态方法:parseXxx()
文章链接:
IntelliJ IDEA快捷键及调试-CSDN博客
【IDEA常用快捷键】
第1组:通用型
说明 快捷键
--------------------------------
复制代码-copy ctrl + c
粘贴-paste ctrl + v
剪切-cut ctrl + x
撤销-undo ctrl + z
反撤销-redo ctrl + shift + z
保存-save all ctrl + s
全选-select all ctrl + a
第2组:提高编写速度(上)
说明 快捷键
-------------------------------------------------------------------
智能提示-edit alt + enter
提示代码模板-insert live template ctrl+j
使用xx块环绕-surround with ... ctrl+alt+t
调出生成getter/setter/构造器等结构-generate ... alt+insert
自动生成返回值变量-introduce variable ... ctrl+alt+v
复制指定行的代码-duplicate line or selection ctrl+d
删除指定行的代码-delete line ctrl+y
切换到下一行代码空位-start new line shift + enter
切换到上一行代码空位-start new line before current ctrl +alt+ enter
向上移动代码-move statement up ctrl+shift+↑
向下移动代码-move statement down ctrl+shift+↓
向上移动一行-move line up alt+shift+↑
向下移动一行-move line down alt+shift+↓
方法的形参列表提醒-parameter info ctrl+p
第3组:提高编写速度(下)
说明 快捷键
---------------------------------------------------------
批量修改指定的变量名、方法名、类名等-rename shift+f6
抽取代码重构方法-extract method ... ctrl+alt+m
重写父类的方法-override methods ... ctrl+o
实现接口的方法-implements methods ... ctrl+i
选中的结构的大小写的切换-toggle case ctrl+shift+u
批量导包-optimize imports ctrl+alt+o
第4组:类结构、查找和查看源码
说明 快捷键
-----------------------------------------------------------------------------------------
如何查看源码-go to class... ctrl + 选中指定的结构 或 ctrl+n
显示当前类结构,支持搜索指定的方法、属性等-file structure ctrl+f12
退回到前一个编辑的页面-back ctrl+alt+←
进入到下一个编辑的页面-forward ctrl+alt+→
打开的类文件之间切换-select previous/next tab alt+←/→
光标选中指定的类,查看继承树结构-Type Hierarchy ctrl+h
查看方法文档-quick documentation ctrl+q
类的UML关系图-show uml popup ctrl+alt+u
定位某行-go to line/column ctrl+g
回溯变量或方法的来源-go to implementation(s) ctrl+alt+b
折叠方法实现-collapse all ctrl+shift+ -
展开方法实现-expand all ctrl+shift+ +
第5组:查找、替换与关闭
说明 快捷键
--------------------------------------------------------------
查找指定的结构 ctrl+f
查找与替换-replace ctrl+r
直接定位到当前行的首位-move caret to line start home
直接定位到当前行的末位 -move caret to line end end
全项目搜索文本-find in path ... ctrl+shift+f
第6组:调整格式
说明 快捷键
--------------------------------------------------------------
格式化代码-reformat code ctrl+alt+l
使用单行注释-comment with line comment ctrl + /
使用/取消多行注释-comment with block comment ctrl + shift + /
选中数行,整体往后移动-tab tab
选中数行,整体往前移动-prev tab shift + tab
【IDEA中调试程序】
为什么需要Debug?
编好的程序在执行过程中如果出现错误,该如何查找或定位错误呢?简单的代码直接就可以看出来,
但如果代码比较复杂,就需要借助程序调试工具(Debug)来查找错误了。
Debug的步骤
1、添加断点
2、启动调试
3、单步执行
4、观察变量和执行流程,找到并解决问题
🌋1、静态变量和实例变量的区别?(保*丰、*软国际、软华、北京明**信)
类似问题:
> 说明静态变量和实例变量之间的区别和使用场景(上海*动)
🍺答:
【区别】
① 个数
>静态变量:在内存空间中只有一份,被类的多个对象所共享。
>实例变量:类的每一个实例(或对象)都保存着一份实例变量。
② 内存位置
>静态变量:jdk6及之前:存放在方法区。 jdk7及之后:存放在堆空间
>实例变量:存放在堆空间的对象实体中。
③ 加载时机
>静态变量:随着类的加载而加载,由于类只会加载一次,所以静态变量也只有一份。
>实例变量:随着对象的创建而加载。每个对象拥有一份实例变量。
④ 调用者
>静态变量:可以被类直接调用,也可以使用对象调用。
>实例变量:只能使用对象进行调用。
⑤ 判断是否可以调用 —> 从生命周期的角度解释
类变量 实例变量
类 yes no
对象 yes yes
⑥ 消亡时机
>静态变量:随着类的卸载而消亡
>实例变量:随着对象的消亡而消亡
【使用场景】
什么时候需要将属性声明为静态的?
> 判断当前类的多个实例是否能共享此成员变量,且此成员变量的值是相同的。
> 开发中,常将一些常量声明是静态的。比如:Math类中的PI
什么时候需要将方法声明为静态的?
> 方法内操作的变量如果都是静态变量(而非实例变量)的话,则此方法建议声明为静态方法
> 开发中,常常将工具类中的方法,声明为静态方法。比如:Arrays类、Math类
🌋2、静态属性和静态方法是否可以被继承?是否可以被重写?以及原因?(*度)
类似问题:
> 在java中,可以重载一个static方法吗?可以覆盖一个static方法吗?(Vi*o)
答:静态方法可以重载,可以重载一个static方法。
不能覆盖一个static方法(重写)。
🍺答:
静态属性和静态方法可以被继承,子类当中可以使用父类中静态的结构(条件允许的情况下可以直接调用),拿子类.
调用。
静态方法不能被重写,因为和对象没有关系。不存在多态性。
这里稍微说一下这个问题,举个例子。
【StaticTest.java】
package yuyi03;
/**
* ClassName: StaticTest
* Package: yuyi03
* Description:
*
* @Author 雨翼轻尘
* @Create 2023/12/27 0027 11:13
*/
public class StaticTest {
public static void main(String[] args) {
Person p1=new Student();
p1.eat();
}
}
class Person{
public void eat(){
System.out.println("人吃饭");
}
}
class Student extends Person{
@Override
public void eat() {
System.out.println("学生吃饭");
}
}
输出:
此时没有任何问题,接下来让父类中的方法为静态方法。
父类中的方法是静态的,那么子类不能与父类定义同名同参数的。如下:
若子类中出现了同名同参数的,就说明它想重写,父类中是静态的,那么需要保证子类中也是静态。
但此时也不能叫重写了。
若子类、父类中出现了同名同参数的方法,那么这两个方法要么都是static,要么全不是static。
不是static的时候叫重写,是static的时候仅仅是这两个方法同名而已。
静态方法随着类的加载而加载,两个同名的static方法就是相当于是两个不同的方法。
那么有什么影响呢?
看一下现在的代码:
package yuyi03;
/**
* ClassName: StaticTest
* Package: yuyi03
* Description:
*
* @Author 雨翼轻尘
* @Create 2023/12/27 0027 11:13
*/
public class StaticTest {
public static void main(String[] args) {
Person p1=new Student();
p1.eat();
}
}
class Person{
public static void eat(){
System.out.println("人吃饭");
}
}
class Student extends Person{
public static void eat() {
System.out.println("学生吃饭");
}
}
现在还是一个多态场景,调用了eat()方法,注意这里是拿对象p1调用的。(其实和对象没有关系)
这时候结果就是父类里面的了,如下:
其实此时这样写也不会报错:
Person p2=null; //没有空指针异常
p2.eat();
输出结果和对象没有关系,根本不看是谁的对象,只看是什么类型。由类发起对方法的调用。
多态只是对象的事,现在是静态的方法,跟多态没有关系。
所以静态的方法不能被重写,也不能被覆盖。也不存在多态性。
静态方法可以重载,重载只和方法名、参数有关。比如:
class Person{
public static void eat(){
System.out.println("人吃饭");
}
public static void food(String food){
System.out.println("人喜欢吃"+food);
}
}
🌋3、是否可以从一个static方法内部发出对非static方法的调用?(同*顺)
🍺答:
只能通过对象来对非静态方法调用。
比如main方法,它是静态方法,所以在main方法里面要对非静态方法调用的时候,需要使用对象来调用。
🌋4、被static修饰的成员(类、方法、成员变量)能否再使用private进行修饰?(联*优势)
🍺答:
完全可以。除了代码块(代码块本身不能用权限修饰符来修饰)。
被static修饰的类肯定是内部类,private体现封装性(能不能被调用)。
被static修饰的成员随着类的加载而加载,该被修饰的可以被修饰。
🌋1、知道哪些设计模式?(*通快递、蚂**服)
🍺答:
单例模式、模板方法设计模式、享元设计模式
🌋2、开发中都用到了那些设计模式?用在什么场合? (久*国际物流)
🍺答:
略(目前无法回答,后续学到再说)
🌋1、main()方法的public能不能换成private,为什么(凡科技、顺)
🍺答:
可以改。
但是改完以后就不是程序入口了,就是一个普通的静态方法,权限是私有的。
🌋2、main()方法中是否可以调用非静态方法?(浩*科技)
🍺答:
只能通过对象来对非静态方法调用。
🌋1、类的组成和属性赋值执行顺序?(航*拓普)
类似问题:
> Java中类的变量初始化的顺序?(*壳)
🍺答:
可以给类的非静态的属性(即实例变量)赋值的位置有:
① 默认初始化
② 显式初始化 或 ⑤ 代码块中初始化
③ 构造器中初始化
###############################
④ 有了对象以后,通过"对象.属性"或"对象.方法"的方法进行赋值
执行的先后顺序:
① - ②/⑤ - ③ - ④
这里拿实例变量来说的,实际上类变量(不考虑构造器)也可以。
🌋2、静态代码块,普通代码块,构造方法,从类加载开始的执行顺序?(恒*电子)
类似问题:
> 类加载成员变量、静态代码块、构造器的加载顺序(*科软、软**力、同*顺)
> static代码块(静态代码块)是否在类的构造函数之前被执行(联*优势)
🍺答:
静态代码块(类加载) --> 普通代码块 --> 构造器
在字节码文件中,会将“普通代码块”和“构造器”合在一起形成方法,关于变量的显示赋值也会放到里面。
其实“静态代码块”也会以一种方法的形式呈现。
比如:
package yuyi03;
/**
* ClassName: BlockTest
* Package: yuyi03
* Description:
*
* @Author 雨翼轻尘
* @Create 2023/12/27 0027 21:49
*/
public class BlockTest {
//静态代码块
static{
System.out.println("abc");
}
//普通代码块
{
System.out.println("hello");
}
//无参构造器
public BlockTest(){
}
//有参构造器
public BlockTest(int id){
}
}
字节码文件:
🌋1、描述一下对final理解(华**博普)
🍺答:
🌋2、判断题:使用final修饰一个变量时,是引用不能改变,引用指向的对象可以改变?(*米)
🍺答:
引用不能改变。
引用指向的对象实体中的属性,如果没有使用final修饰,则可以改变。
🌋3、判断题:final不能用于修饰构造方法?(联*优势)
🍺答:
是的。若用final修饰方法就是不能变,不能重写,但修饰构造器没有意义。
🌋4、final或static final 修饰成员变量,能不能进行++操作?(佳*贸易)
🍺答:
不能进行++
操作。但是可以进行+1
操作,因为变量本身没有变。
🌋1、什么是抽象类?如何识别一个抽象类?(易*支付)
🍺答:
使用abstract修饰的就是一个抽象类。
🌋2、为什么不能用abstract修饰属性、私有方法、构造器、静态方法、final的方法?(止**善)
🍺答:
为了语言的自洽。这些都不能被重写,而abstract修饰则必须重写其内容。
abstract 不能与哪些关键字共用?(自洽)
不能用abstract修饰私有方法、静态方法、final的方法、final的类。
私有方法不能重写
避免静态方法使用类进行调用
final的方法不能被重写
final修饰的类不能有子类
🌋3、接口与抽象类的区别?(字跳动、阿校招、度校招、**计算机技术及应用研究所、航拓普、纬*、招晟、汇*云通、数信科技、北京永鼎力、上海连科技)
🍺答:
🌋4、接口是否可继承接口?抽象类是否可实现(implements)接口?抽象类是否可继承实现类(concrete class)?(航*拓普、蝶、深圳德科技)
类似问题:
> 接口A可以继承接口B吗?接口A可以实现接口B吗?(久*国际物流)
🍺答:
是;是;是。
接口可以继承接口;
抽象类可以实现接口(比如一个类实现了一个接口,这个接口里面有两个抽象方法,它就重写了一个方法,另一个没有重写,那么这个类就是抽象类);
抽象类可以继承实现类(即非抽象类,没有写父类就是abstract,abstract就是非抽象的)。
🌋5、接口可以有自己属性吗?(华*中盛)
🍺答:
可以。必须是public static final
的。
🌋6、访问接口的默认方法如何使用(上海*思)
🍺答:
使用实现类的对象进行调用。而且实现类还可以重写此默认方法。
🌋1、内部类有哪几种?(华油**普、来*科技)
🍺答:
内部类的分类:(参考变量的分类)
成员内部类:直接声明在外部类的里面。
使用static修饰的:静态的成员内部类
不使用static修饰的:非静态的成员内部类
局部内部类:声明在方法内、构造器内、代码块内的内部类
匿名的局部内部类
非匿名的局部内部类
🌋2、内部类的特点说一下(招通**)
类似问题:
> 说一下内部类的好处(北京楚*龙)
> 使用过内部类编程吗,有什么作用(软**力)
🍺答:
关于成员内部类的理解:
从类的角度看:
- 内部可以声明属性、方法、构造器、代码块、内部类等结构
- 此内部类可以声明父类,可以实现接口
- 可以使用final修饰
- 可以使用abstract修饰
从外部类的成员的角度看:
- 在内部可以调用外部类的结构。比如:属性、方法等
- 除了使用public、缺省权限修饰之外,还可以使用private、protected修饰
- 可以使用static修饰
🌋3、匿名类说一下(阿校招、上海立网络)
🍺答:
有的时候不想显示地造一个实现类,就像临时拿一个用,就可以使用匿名类。
🌋1、枚举可以继承吗?(顺*)
🍺答:
使用enum定义的,其父类就是Enum类,就不要再继承其他的类了。(如果要写就会报错)
如果是自定义(不使用enum),是自己写的class,想继承啥都可以啦。
🌋1、Java基本类型与包装类的区别(凡*科技)
🍺答:
包装类可以造对象、调方法,Java基本类型就不行。
🌋1、谈谈你对面向对象的理解(君科技、航拓普、…)。
🍺答:
🌋2、面向对象的特征有哪些方面? (北京楚龙、深圳德科技、直科技、米奇网络、航*拓普)
类似问题:
> 面向对象核心是什么?(平**服)
答:面向对象的编程的核心思想是,将程序中的实体、数据和功能抽象为单独的对象,并在这些对象之间建立联系。
🍺答:封装、继承、多态