面向对象(高级)知识点强势总结!!!

发布时间:2023年12月28日

一、知识点复习

1-关键字:static

文章链接:
Java面向对象(高级)-- static关键字的使用-CSDN博客

1、知识点

【static关键字的使用】

  1. static: 静态的

  2. static 用来修饰的结构:属性、方法; 代码块、内部类;(构造器不能够用static修饰)

  3. static修饰属性
    3.1 复习:变量的分类
    方式1:按照数据类型:基本数据类型、引用数据类型
    方式2:按照类中声明的位置:
    成员变量:按照是否使用static修饰进行分类:
    使用static修饰的成员变量:静态变量、类变量
    不使用static修饰的成员变量:非静态变量、实例变量

    局部变量:方法内、方法形参、构造器内、构造器形参、代码块内等。

3.2 静态变量:类中的属性使用static进行修饰。
对比静态变量与实例变量:
① 个数
>静态变量:在内存空间中只有一份,被类的多个对象所共享。
>实例变量:类的每一个实例(或对象)都保存着一份实例变量。
② 内存位置
>静态变量:jdk6及之前:存放在方法区。 jdk7及之后:存放在堆空间
>实例变量:存放在堆空间的对象实体中。
③ 加载时机
>静态变量:随着类的加载而加载,由于类只会加载一次,所以静态变量也只有一份。
>实例变量:随着对象的创建而加载。每个对象拥有一份实例变量。
④ 调用者
>静态变量:可以被类直接调用,也可以使用对象调用。
>实例变量:只能使用对象进行调用。
⑤ 判断是否可以调用 —> 从生命周期的角度解释
类变量 实例变量
类 yes no
对象 yes yes

⑥ 消亡时机
>静态变量:随着类的卸载而消亡
>实例变量:随着对象的消亡而消亡

  1. static修饰方法:(类方法、静态方法)
    随着类的加载而加载
    可以通过“类.静态方法”的方式,直接调用静态方法
    静态方法内可以调用静态的属性或静态的方法。(属性和方法的前缀使用的是当前类,可以省略)
    不可以调用非静态的结构。(比如:属性、方法)

                  类方法         实例方法
       类            yes            no
       对象          yes            yes
    

    static修饰的方法内,不能使用this和super

补充:在类的非静态方法中,可以调用当前类中的静态结构(属性、方法)或非静态结构(属性、方法)

  1. 开发中,什么时候需要将属性声明为静态的?
    判断当前类的多个实例是否能共享此成员变量,且此成员变量的值是相同的。
    开发中,常将一些常量声明是静态的。比如:Math类中的PI

    什么时候需要将方法声明为静态的?
    方法内操作的变量如果都是静态变量(而非实例变量)的话,则此方法建议声明为静态方法
    开发中,常常将工具类中的方法,声明为静态方法。比如:Arrays类、Math类

2、重点

  • static:静态的,随着类的加载而加载、执行。
  • static用来修饰:属性、方法、代码块、内部类 (不能用来修饰构造器
  • 熟悉:static修饰的类变量、类方法与不使用static修饰的区别。
    • 类变量:类的生命周期内,只有一个。被类的多个实例共享。
  • 掌握:我们遇到属性或方法时,需要考虑是否声明为static的。

2-单例模式(或单子模式)

文章链接:
Java面向对象(高级)-- 单例(Singleton)设计模式-CSDN博客

1、知识点

  1. 设计模式概述:
    设计模式是在大量的实践中总结理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式免去我们自己再思考和摸索。
    就像是经典的棋谱,不同的棋局,我们用不同的棋谱。“套路”
    经典的设计模式一共有23种。

  2. 何为单例模式(Singleton):
    所谓类的单例设计模式,就是采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法。

  3. 如何实现单例模式(掌握):
    饿汉式
    懒汉式

  4. 对比两种模式(特点、优缺点)
    特点:
    饿汉式:“立即加载”,随着类的加载,当前的唯一实例就创建了
    懒汉式:“延迟加载”,在需要使用的时候,进行创建。

优缺点:

饿汉式:(优点)写法简单,由于内存中较早加载,使用更方便、更快。是线程安全的。 (缺点)内存中占用时间较长。

懒汉式:(缺点)线程不安全 (放到多线程章节时解决)(优点)在需要的时候进行创建,节省内存空间。

2、重点

  • 经典的设计模式有23种
  • 解决的问题:在整个软件系统中,只存在当前类的唯一实例
  • 实现方式:饿汉式、懒汉式、枚举类等
  • 对比饿汉式和懒汉式
    • 饿汉式:“立即加载”,线程安全的。
    • 懒汉式:“延迟加载”,线程不安全。
  • 需要会手写饿汉式和懒汉式

3-理解main()方法

文章链接:
Java面向对象(高级)-- 单例(Singleton)设计模式-CSDN博客

1、知识点

【main()方法的剖析】

public static void main(String args[]){}

  1. 理解1:看做是一个普通的静态方法
    理解2:看做是程序的入口,格式是固定的。

  2. 与控制台交互
    如何从键盘获取数据?
    方式1:使用Scanner
    方式2:使用main()的形参进行传值。

2、重点

  • public static void main(String[] args){}
  • public:公共的 、static:由类进行调用 (拿对象来调用不合适,因为这是程序入口,造对象也需要通过入口进去) 、void:不需要返回值 、String[] args:形参,可以传递参数,之前演示了通过命令行、IDEA来传递参数
  • 理解1:作为程序的入口;普通的静态方法
  • 理解2:如何使用main()与控制台进行数据的交互。
    • 命令行:java 类名 “Tom” “Jerry” “123”

4-类的成员之四:代码块

文章链接:
Java面向对象(高级)-- 类的成员之四:代码块-CSDN博客

1、知识点

【类的成员之四:代码块】

回顾:类中可以声明的结构:属性、方法、构造器;代码块(或初始化块)、内部类

代码块:从长的样子来看的(就是封装了一下代码)

初始化块:从它的作用的角度

  1. 代码块(或初始化块)的作用:
    用来初始化类或对象的信息(即初始化类或对象的成员变量)

  2. 代码块的修饰:
    只能使用static进行修饰。

  3. 代码块的分类:
    静态代码块:使用static修饰
    非静态代码块:没有使用static修饰

  4. 具体使用:
    4.1 静态代码块:
    随着类的加载而执行(它没有名字,就不能显示地调用它)
    由于类的加载只会执行一次,进而静态代码块的执行,也只会执行一次
    作用:用来初始化类的信息
    内部可以声明变量、调用属性或方法、编写输出语句等操作。
    静态代码块的执行要先于非静态代码块的执行
    如果声明有多个静态代码块,则按照声明的先后顺序执行
    静态代码块内部只能调用静态的结构(即静态的属性、方法),不能调用非静态的结构(即非静态的属性、方法)

4.2 非静态代码块:
随着对象的创建而执行
每创建当前类的一个实例,就会执行一次非静态代码块
作用:用来初始化对象的信息
内部可以声明变量、调用属性或方法、编写输出语句等操作。
如果声明有多个非静态代码块,则按照声明的先后顺序执行
非静态代码块内部可以调用静态的结构(即静态的属性、方法),也可以调用非静态的结构(即非静态的属性、方法)

2、重点

  • 分类:静态代码块、非静态代码块
  • 使用频率上来讲:用的比较少。
  • 静态代码块:随着类的加载而执行
  • 非静态代码块:随着对象的创建而执行

【属性赋值的过程】

文章链接:

Java面向对象(高级)-- 类中属性赋值的位置及过程_java 给属性赋值-CSDN博客

  1. 可以给类的非静态的属性(即实例变量)赋值的位置有:
    ① 默认初始化
    ② 显式初始化 或 ⑤ 代码块中初始化
    ③ 构造器中初始化
    ####################################
    ④ 有了对象以后,通过"对象.属性"或"对象.方法"的方法进行赋值

  2. 执行的先后顺序:
    ① - ②/⑤ - ③ - ④

  3. (超纲)关于字节码文件中的的简单说明:(通过插件jclasslib bytecode viewer查看)
    方法在字节码文件中可以看到。每个方法都对应着一个类的构造器。(类中声明了几个构造器就会有几个)
    编写的代码中的构造器在编译以后就会以方法的方式呈现
    方法内部的代码包含了实例变量的显示赋值、代码块中的赋值和构造器中的代码。
    方法用来初始化当前创建的对象的信息的。

  4. 给实例变量赋值的位置很多,开发中如何选?
    显示赋值:比较适合于每个对象的属性值相同的场景
    构造器中赋值:比较适合于每个对象的属性值不相同的场景

5-关键字:final

文章链接:
Java面向对象(高级)-- final关键字的使用-CSDN博客

1、知识点

【final关键字的使用】

  1. final的理解:最终的

  2. final可以用来修饰的结构:类、方法、变量

  3. 具体说明:
    3.1 final修饰类:表示此类不能被继承。
    比如:String、StringBuffer、StringBuilder类

3.2 final修饰方法:表示此方法不能被重写
比如:Object类中的getClass()

3.3 final修饰变量:既可以修饰成员变量,也可以修饰局部变量。
此时的"变量"其实就变成了"常量",意味着一旦赋值,就不可更改。

3.3.1 final修饰成员变量: 有哪些位置可以给成员变量赋值?
显式赋值

代码块中赋值

构造器中赋值

3.3.2 final修饰局部变量:一旦赋值就不能修改
方法内声明的局部变量:在调用局部变量前,一定需要赋值。而且一旦赋值,就不可更改
方法的形参:在调用此方法时,给形参进行赋值。而且一旦赋值,就不可更改

  1. final与static搭配:修饰成员变量时,此成员变量称为:全局常量。
    比如:Math的PI

2、重点

  • 最终的
  • 用来修饰:类、方法、变量(成员变量、局部变量)
    • 类:不能被继承
    • 方法:不能被重写
    • 变量:是一个“常量”,一旦赋值不能修改。
  • 成员变量能赋值的位置:显示初始化、代码块中初始化、构造器中初始化 (在造对象结束之前需要把实例变量赋上值)
  • 静态修饰的成员变量能赋值的位置:显示初始化、静态代码块中赋值(构造器中就不要赋值了,因为静态变量不一定调构造器造对象)
  • 局部变量:在调用之前赋值就可以了,一旦赋值就不要修改了。

6-关键字:abstract

文章链接:
Java面向对象(高级)-- 抽象类与抽象方法(或abstract关键字)-CSDN博客

1、知识点

【抽象类与抽象方法】

  1. 案例引入
    举例1:GeometricObject-Circle-Rectangle
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{ //信用卡
    //取钱(需要重写父类中的抽象方法)

    //存钱(需要重写父类中的抽象方法)
}
//....
  1. abstract的概念:抽象的

  2. abstract可以用来修饰:类、方法

  3. 具体的使用:
    4.1 abstract修饰类:
    此类称为抽象类
    抽象类不能实例化。
    抽象类中是包含构造器的,因为子类对象实例化时,需要直接或间接的调用到父类的构造器。
    抽象类中可以没有抽象方法。反之,抽象方法所在的类,一定是抽象类。

4.2 abstract修饰方法:
此方法即为抽象方法
抽象方法只有方法的声明,没有方法体。
抽象方法其功能是确定的(通过方法的声明即可确定),只是不知道如何具体实现(体现为没有方法体)
子类必须重写父类中的所有的抽象方法之后,方可实例化。否则,此子类仍然是一个抽象类。

  1. abstract不能使用的场景:
    5.1 abstract 不能修饰哪些结构?
    属性、构造器、代码块等。

5.2 abstract 不能与哪些关键字共用?(自洽)

不能用abstract修饰私有方法、静态方法、final的方法、final的类。

私有方法不能重写

避免静态方法使用类进行调用

final的方法不能被重写

final修饰的类不能有子类

2、重点

  • 抽象的
  • 用来修饰:类、方法
    • 类:抽象类:不能实例化。
    • 方法:抽象方法:没有方法体,必须由子类实现此方法。

7-关键字:interface

文章链接:
Java面向对象(高级)-- 接口(interface)-CSDN博客

1、知识点

【接口的使用】

  1. 接口的理解:接口的本质是契约、标准、规范,就像我们的法律一样。制定好后大家都要遵守。

  2. 定义接口的关键字:interface

  3. 接口内部结构的说明:
    可以声明:
    属性:必须使用public static final修饰
    方法:jdk8之前:声明抽象方法,修饰为public abstract
    jdk8:声明静态方法、默认方法
    jdk9:声明私有方法

    不可以声明:构造器、代码块等

  4. 接口与类的关系 :实现关系

  5. 格式:class A extends SuperA implements B,C{}
    A相较于SuperA来讲,叫做子类
    A相较于B,C来讲,叫做实现类。

  6. 满足此关系之后,说明:
    类可以实现多个接口。
    类针对于接口的多实现,一定程度上就弥补了类的单继承的局限性。
    类必须将实现的接口中的所有的抽象方法都重写(或实现),方可实例化。否则,此实现类必须声明为抽象类。

  7. 接口与接口的关系:继承关系,且可以多继承

  8. 接口的多态性: 接口名 变量名 = new 实现类对象;

  9. 面试题:区分抽象类和接口
    共性:都可以声明抽象方法
    都不能实例化

不同:① 抽象类一定有构造器。接口没有构造器
② 类与类之间继承关系,类与接口之间是实现关系,接口与接口之间是多继承关系

2、重点

  • interface:接口,用来定义一组规范、一种标准。
  • 掌握:接口中可以声明的结构。
    • 属性:使用public static final修饰 (可以省略)
    • 方法:jdk8之前:只能声明抽象方法,使用public abstract修饰
      jdk8中:声明static方法、default方法。
      jdk9中:声明private方法。
  • 笔试题:抽象类、接口的对比。

8-类的成员之五:内部类

文章链接:
Java面向对象(高级)-- 类的成员之五:内部类(InnerClass)-CSDN博客

1、知识点

【类的成员之五:内部类】

  1. 什么是内部类?
    将一个类A定义在另一个类B里面,里面的那个类A就称为内部类(InnerClass),类B则称为外部类(OuterClass)

  2. 为什么需要内部类?
    具体来说,当一个事物A的内部,还有一个部分需要一个完整的结构B进行描述,而这个内部的完整的结构B又只为外部事物A
    提供服务,不在其他地方单独使用,那么整个内部的完整结构B最好使用内部类。
    总的来说,遵循高内聚、低耦合的面向对象开发原则。

  3. 内部类使用举例:
    Thread类内部声明了State类,表示线程的生命周期
    HashMap类中声明了Node类,表示封装的key和value

  4. 内部类的分类:(参考变量的分类)
    成员内部类:直接声明在外部类的里面。
    使用static修饰的:静态的成员内部类
    不使用static修饰的:非静态的成员内部类

    局部内部类:声明在方法内、构造器内、代码块内的内部类
    匿名的局部内部类
    非匿名的局部内部类

  5. 内部类这节要讲的知识:
    成员内部类的理解
    如何创建成员内部类的实例
    如何在成员内部类中调用外部类的结构
    局部内部类的基本使用

  6. 关于成员内部类的理解:
    从类的角度看:
    - 内部可以声明属性、方法、构造器、代码块、内部类等结构
    - 此内部类可以声明父类,可以实现接口
    - 可以使用final修饰
    - 可以使用abstract修饰

    从外部类的成员的角度看:
    - 在内部可以调用外部类的结构。比如:属性、方法等
    - 除了使用public、缺省权限修饰之外,还可以使用private、protected修饰
    - 可以使用static修饰

  7. 关于局部内部类的说明:

2、重点

成员内部类的理解

如何创建成员内部类的实例

如何在成员内部类中调用外部类的结构

局部内部类的基本使用(关注:如何在方法内创建匿名局部内部类的对象)

9-枚举类:enum

文章链接:
Java面向对象(高级)-- 枚举类的使用-CSDN博客

1、知识点

【枚举类的使用】

  1. 枚举类的理解:
    枚举类型本质上也是一种类,只不过是这个类的对象是有限的、固定的几个,不能让用户随意创建。

  2. 举例:

  • 星期: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(取消)
  • 线程状态:创建、就绪、运行、阻塞、死亡
  1. 开发中的建议:
    开发中,如果针对于某个类,其实例是确定个数的。则推荐将此类声明为枚举类。
    如果枚举类的实例只有一个,则可以看做是单例的实现方式。

  2. JDK5.0 之前如何自定义枚举类 (了解)
    见代码

  3. JDK5.0中使用enum定义枚举类
    见代码

  4. 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开始

  5. 枚举类实现接口的操作
    情况1:枚举类实现接口,在枚举类中重写接口中的抽象方法。当通过不同的枚举类对象调用此方法时,执行的是同一个方法。
    情况2:让枚举类的每一个对象重写接口中的抽象方法。当通过不同的枚举类对象调用此方法时,执行的是不同的实现的方法。

2、重点

  • 掌握:使用enum关键字定义枚举类即可。

10-注解:Annotation

文章链接:
Java面向对象(高级)-- 注解(Annotation)-CSDN博客

1、知识点

【注解的使用】

  1. Annotation的理解
    注解(Annotation)是从JDK5.0开始引入,以“@注解名”在代码中存在。
    Annotation 可以像修饰符一样被使用,可用于修饰包、类、构造器、方法、成员变量、参数、局部变量的声明。
    还可以添加一些参数值,这些信息被保存在 Annotation 的 “name=value” 对中。
    注解可以在类编译、运行时进行加载,体现不同的功能。

  2. 注解的应用场景:
    示例1:生成文档相关的注解
    示例2:在编译时进行格式检查(JDK内置的三个基本注解)
    示例3:跟踪代码依赖性,实现替代配置文件功能

  3. Java基础涉及到的三个常用注解
    @Override: 限定重写父类方法,该注解只能用于方法
    @Deprecated: 用于表示所修饰的元素(类,方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择
    @SuppressWarnings: 抑制编译器警告

  4. 自定义注解
    以@SuppressWarnings为参照,进行定义即可。

  5. 元注解的理解:
    元注解:对现有的注解进行解释说明的注解。

讲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”;

框架 = 注解 + 反射 + 设计模式

2、重点

  • 框架 = 注解 + 反射 + 设计模式
  • Java基础阶段:简单。@Override 、 @Deprecated、@SuppressWarnings
  • 元注解:对现有的注解进行解释说明。
    • @Target:表明可以用来修饰的结构
    • @Retation:表明生命周期
  • 如何自定义注解。

11-包装类的使用

文章链接:
Java面向对象(高级)-- 包装类(wrapper)的使用-CSDN博客

1、知识点

【包装类的使用】

  1. 为什么要使用包装类?
    为了使得基本数据类型的变量具备引用数据类型变量的相关特征(比如:封装性、继承性、多态性),我们给各个基本数据
    类型的变量都提供了对应的包装类。

  2. (掌握)基本数据类型对应的包装类类型
    byte -> Byte
    short -> Short
    int -> Integer
    long -> Long
    float -> Float
    double ->Double

char -> Character
boolean -> Boolean

  1. 掌握基本数据类型 与 包装类之间的转换。
    3.1 为什么需要转换
    一方面,在有些场景下,需要使用基本数据类型对应的包装类的对象。此时就需要将基本数据类型的变量转换为
    包装类的对象。比如:ArrayList的add(Object obj);Object类的equals(Object obj)
    对于包装类来讲,既然我们使用的是对象,那么对象是不能进行+ - * /等运算的。为了能够进行这些运算,就
    需要将包装类的对象转换为基本数据类型的变量。

    3.2 如何转换:
    (装箱)基本数据类型 —> 包装类:① 使用包装类的构造器 ② (建议)调用包装类的valueOf(xxx xx)
    (拆箱)包装类 —> 基本数据类型:调用包装类的xxxValue()

    注意:原来使用基本数据类型变量的位置,改成包装类以后,对于成员变量来说,其默认值变化了!
    jdk5.0新特性:自动装箱、自动拆箱。

  2. String 与 基本数据类型、包装类之间的转换。
    基本数据类型、包装类 —> String类型:① 调用String的重载的静态方法valueOf(xxx xx) ; ② 基本数据类型的变量 + “”

    String类型 —> 基本数据类型、包装类: 调用包装类的静态方法:parseXxx()

2、重点

  • 掌握:基本数据类型对应的包装类都有哪些?
  • 掌握:基本数据类型、包装类、String三者之间的转换
    • 基本数据类型 <-> 包装类:自动装箱、自动拆箱
    • 基本数据类型、包装类 <-> String (转换成谁,就在谁里面找方法)
      • String的valueOf(xxx)
      • 包装类的parseXxx(String str)

12-IDEA:快捷键和debug

文章链接:
IntelliJ IDEA快捷键及调试-CSDN博客

1、知识点

【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中调试程序】

  1. 为什么需要Debug?
    编好的程序在执行过程中如果出现错误,该如何查找或定位错误呢?简单的代码直接就可以看出来,
    但如果代码比较复杂,就需要借助程序调试工具(Debug)来查找错误了。

  2. Debug的步骤
    1、添加断点
    2、启动调试
    3、单步执行
    4、观察变量和执行流程,找到并解决问题

2、重点

  • 掌握如何调试

二、企业真题

1- static关键字

题1

🌋1、静态变量和实例变量的区别?(保*丰、*软国际、软华、北京明**信)

类似问题:
> 说明静态变量和实例变量之间的区别和使用场景(上海*动)

🍺答:
【区别】
① 个数
>静态变量:在内存空间中只有一份,被类的多个对象所共享。
>实例变量:类的每一个实例(或对象)都保存着一份实例变量。
② 内存位置
>静态变量:jdk6及之前:存放在方法区。 jdk7及之后:存放在堆空间
>实例变量:存放在堆空间的对象实体中。
③ 加载时机
>静态变量:随着类的加载而加载,由于类只会加载一次,所以静态变量也只有一份。
>实例变量:随着对象的创建而加载。每个对象拥有一份实例变量。
④ 调用者
>静态变量:可以被类直接调用,也可以使用对象调用。
>实例变量:只能使用对象进行调用。
⑤ 判断是否可以调用 —> 从生命周期的角度解释
类变量 实例变量
类 yes no
对象 yes yes

⑥ 消亡时机
>静态变量:随着类的卸载而消亡
>实例变量:随着对象的消亡而消亡

【使用场景】
什么时候需要将属性声明为静态的?
> 判断当前类的多个实例是否能共享此成员变量,且此成员变量的值是相同的。
> 开发中,常将一些常量声明是静态的。比如:Math类中的PI
什么时候需要将方法声明为静态的?
> 方法内操作的变量如果都是静态变量(而非实例变量)的话,则此方法建议声明为静态方法
> 开发中,常常将工具类中的方法,声明为静态方法。比如:Arrays类、Math类


题2

🌋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("学生吃饭");
    }
}

输出:

image.png

此时没有任何问题,接下来让父类中的方法为静态方法。

父类中的方法是静态的,那么子类不能与父类定义同名同参数的。如下:

image.png

若子类中出现了同名同参数的,就说明它想重写,父类中是静态的,那么需要保证子类中也是静态。

image.png

但此时也不能叫重写了。

若子类、父类中出现了同名同参数的方法,那么这两个方法要么都是static,要么全不是static。

不是static的时候叫重写,是static的时候仅仅是这两个方法同名而已。

image.png

静态方法随着类的加载而加载,两个同名的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调用的。(其实和对象没有关系)

这时候结果就是父类里面的了,如下:

image.png

其实此时这样写也不会报错:

Person p2=null; //没有空指针异常
p2.eat();

输出结果和对象没有关系,根本不看是谁的对象,只看是什么类型。由类发起对方法的调用

image.png

多态只是对象的事,现在是静态的方法,跟多态没有关系。

所以静态的方法不能被重写,也不能被覆盖。也不存在多态性

静态方法可以重载,重载只和方法名、参数有关。比如:

class Person{
    public static void eat(){
        System.out.println("人吃饭");
    }

    public static void food(String food){
        System.out.println("人喜欢吃"+food);
    }
}

题3

🌋3、是否可以从一个static方法内部发出对非static方法的调用?(同*顺)

🍺答:

只能通过对象来对非静态方法调用

比如main方法,它是静态方法,所以在main方法里面要对非静态方法调用的时候,需要使用对象来调用。


题4

🌋4、被static修饰的成员(类、方法、成员变量)能否再使用private进行修饰?(联*优势)

🍺答:

完全可以。除了代码块(代码块本身不能用权限修饰符来修饰)。

被static修饰的类肯定是内部类,private体现封装性(能不能被调用)。

被static修饰的成员随着类的加载而加载,该被修饰的可以被修饰。

2- 设计模式

题1

🌋1、知道哪些设计模式?(*通快递、蚂**服)

🍺答:

单例模式、模板方法设计模式、享元设计模式


题2

🌋2、开发中都用到了那些设计模式?用在什么场合? (久*国际物流)

🍺答:

略(目前无法回答,后续学到再说)

3- main()

题1

🌋1、main()方法的public能不能换成private,为什么(凡科技、顺

🍺答:

可以改。

但是改完以后就不是程序入口了,就是一个普通的静态方法,权限是私有的。


题2

🌋2、main()方法中是否可以调用非静态方法?(浩*科技)

🍺答:

只能通过对象来对非静态方法调用。

4- 代码块

题1

🌋1、类的组成和属性赋值执行顺序?(航*拓普)

类似问题:
> Java中类的变量初始化的顺序?(*壳)

🍺答:

可以给类的非静态的属性(即实例变量)赋值的位置有:

① 默认初始化

② 显式初始化 或 ⑤ 代码块中初始化

③ 构造器中初始化

###############################

④ 有了对象以后,通过"对象.属性"或"对象.方法"的方法进行赋值

执行的先后顺序:

① - ②/⑤ - ③ - ④

这里拿实例变量来说的,实际上类变量(不考虑构造器)也可以。


题2

🌋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){

    }
}

字节码文件:

image.png

5- final关键字

题1

🌋1、描述一下对final理解(华**博普)

🍺答:

  • 最终的
  • 用来修饰:类、方法、变量(成员变量、局部变量)
    • 类:不能被继承
    • 方法:不能被重写
    • 变量:是一个“常量”,一旦赋值不能修改。

题2

🌋2、判断题:使用final修饰一个变量时,是引用不能改变,引用指向的对象可以改变?(*米)

🍺答:

引用不能改变

引用指向的对象实体中的属性,如果没有使用final修饰,则可以改变。


题3

🌋3、判断题:final不能用于修饰构造方法?(联*优势)

🍺答:

是的。若用final修饰方法就是不能变,不能重写,但修饰构造器没有意义。


题4

🌋4、final或static final 修饰成员变量,能不能进行++操作?(佳*贸易)

🍺答:

不能进行++操作。但是可以进行+1操作,因为变量本身没有变。

6- 抽象类与接口

题1

🌋1、什么是抽象类?如何识别一个抽象类?(易*支付)

🍺答:

使用abstract修饰的就是一个抽象类。


题2

🌋2、为什么不能用abstract修饰属性、私有方法、构造器、静态方法、final的方法?(止**善)

🍺答:

为了语言的自洽。这些都不能被重写,而abstract修饰则必须重写其内容。

abstract 不能与哪些关键字共用?(自洽)

不能用abstract修饰私有方法、静态方法、final的方法、final的类。

  • 私有方法不能重写

  • 避免静态方法使用类进行调用

  • final的方法不能被重写

  • final修饰的类不能有子类


题3

🌋3、接口与抽象类的区别?(字跳动、阿校招、度校招、**计算机技术及应用研究所、航拓普、纬*、招晟、汇*云通、数信科技、北京永鼎力、上海连科技)

🍺答:

image.png


题4

🌋4、接口是否可继承接口?抽象类是否可实现(implements)接口?抽象类是否可继承实现类(concrete class)?(航*拓普、蝶、深圳德科技)

类似问题:
> 接口A可以继承接口B吗?接口A可以实现接口B吗?(久*国际物流)

🍺答:

是;是;是。

接口可以继承接口;

抽象类可以实现接口(比如一个类实现了一个接口,这个接口里面有两个抽象方法,它就重写了一个方法,另一个没有重写,那么这个类就是抽象类);

抽象类可以继承实现类(即非抽象类,没有写父类就是abstract,abstract就是非抽象的)。


题5

🌋5、接口可以有自己属性吗?(华*中盛)

🍺答:

可以。必须是public static final的。


题6

🌋6、访问接口的默认方法如何使用(上海*思)

🍺答:

使用实现类的对象进行调用。而且实现类还可以重写此默认方法。

7- 内部类

题1

🌋1、内部类有哪几种?(华油**普、来*科技)

🍺答:

内部类的分类:(参考变量的分类)

成员内部类:直接声明在外部类的里面。
使用static修饰的:静态的成员内部类
不使用static修饰的:非静态的成员内部类

局部内部类:声明在方法内、构造器内、代码块内的内部类
匿名的局部内部类
非匿名的局部内部类

题2

🌋2、内部类的特点说一下(招通**)

类似问题:
> 说一下内部类的好处(北京楚*龙)
> 使用过内部类编程吗,有什么作用(软**力)

🍺答:
关于成员内部类的理解:
从类的角度看:
- 内部可以声明属性、方法、构造器、代码块、内部类等结构
- 此内部类可以声明父类,可以实现接口
- 可以使用final修饰
- 可以使用abstract修饰

从外部类的成员的角度看:
- 在内部可以调用外部类的结构。比如:属性、方法等
- 除了使用public、缺省权限修饰之外,还可以使用private、protected修饰
- 可以使用static修饰


题3

🌋3、匿名类说一下(阿校招、上海立网络)

🍺答:

有的时候不想显示地造一个实现类,就像临时拿一个用,就可以使用匿名类。

8- 枚举类

题1

🌋1、枚举可以继承吗?(顺*)

🍺答:

使用enum定义的,其父类就是Enum类,就不要再继承其他的类了。(如果要写就会报错)

如果是自定义(不使用enum),是自己写的class,想继承啥都可以啦。

9- 包装类

题1

🌋1、Java基本类型与包装类的区别(凡*科技)

🍺答:

包装类可以造对象、调方法,Java基本类型就不行。

10- 综合

题1

🌋1、谈谈你对面向对象的理解(君科技、航拓普、…)。

🍺答:

  • 面向对象的两个要素:类(抽象的 概念上的定义)、对象(类创造出来的实打实的对象实体,具体存在的一个一个的个体) —> 面向对象编程(在完成具体功能的时候,通常由对象出发,对类中声明的方法进行调用)。“万事万物皆对象”。
  • 面向对象的三大特征
  • 接口,与类并列的结构,作为一个补充:类可以实现多个接口,弥补单继承的局限性。

题2

🌋2、面向对象的特征有哪些方面? (北京楚龙、深圳德科技、直科技、米奇网络、航*拓普)

类似问题:
> 面向对象核心是什么?(平**服)

答:面向对象的编程的核心思想是,将程序中的实体、数据和功能抽象为单独的对象,并在这些对象之间建立联系。

🍺答:封装、继承、多态

文章来源:https://blog.csdn.net/m0_55746113/article/details/135257903
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。