[Java小题狂做]第五d

文章目录

• 1.抽象类中方法的定义
• 2.继承/多态
• 3.静态代码块
• 4.final,fianlly,fianlize
• • final
  • • 修饰类
    • 修饰方法
    • 修饰变量
    • 类的final变量和普通变量有什么区别？
    • 被final修饰的引用变量指向的对象内容可变吗？
    • fianl和static
  • fianlly
  • finalize
  • finalize作用
  • finalize的问题
• 5.编译看左边，运行看右边
• 6.一维数组的定义
• • Java一维数组初始化方法
  • • 1.静态初始化
    • 2.动态初始化
• 7.AOP/OOP
• 8.重写/重载
• 9.string字符数在heap中保存个数
• 10.继承多态-初始化
• 11.Servlet
• 12.ArrayList/LinkedList
• 13.ClassLoader

1.抽象类中方法的定义

1、抽象方法不能有方法体，这是规定
2、该方法缺少返回值，只有构造没有返回值

2.继承/多态

重写 要求两同两小一大原则， 方法名相同，参数类型相同，子类返回类型小于等于父类方法返回类型， 子类抛出异常小于等于父类方法抛出异常， 子类访问权限大于等于父类方法访问权限。［注意：这里的返回类型必须要在有继承关系的前提下比较］

重载 方法名必须相同，参数类型必须不同，包括但不限于一项，参数数目，参数类型，参数顺序
再来说说这道题 A B 都是方法名和参数相同，是重写，但是返回类型没与父类返回类型有继承关系，错误 D 返回一个类错误 c的参数类型与父类不同，所以不是重写，可以理解为广义上的重载访问权限小于父类，都会显示错误
虽然题目没点明一定要重载或者重写，但是当你的方法名与参数类型与父类相同时，已经是重写了，这时候如果返回类型或者异常类型比父类大，或者访问权限比父类小都会编译错误
虽然Java中有getClass的方法，但很多打开源码来看，都是带有native的方法，底层是用C/C++编写，所以这里返回一个A的类不准确

3.静态代码块

//下面代码运行结果为？
public class Test{
static{
   int x=5;
}
static int x,y;
public static void main(String args[]){
   x--;
   myMethod( );
   System.out.println(x+y+ ++x);
}
public static void myMethod( ){
  y=x++ + ++x;
 }
}

D
1.静态语句块中x为局部变量，不影响静态变量x的值
2.x和y为静态变量，默认初始值为0，属于当前类，其值得改变会影响整个类运行。
3.java中自增 *** 作非原子性的
main方法中：
执行x–后 x=-1
调用myMethod方法，x执行x++结果为-1(后++)，但x=0，++x结果1，x=1 ，则y=0
x+y+ ++x,先执行x+y，结果为1，执行++x结果为2，得到最终结果为3

4.final,fianlly,fianlize

final：可用来定义变量、方法传入的参数、类、方法。
finally：只能跟在try/catch语句中，并且附带一个语句块，表示最后执行。
finalize：是垃圾回收器 *** 作的运行机制中的一部分，进行垃圾回收器 *** 作时会调用finalize方法，因为finalize方法是object的方法，所以每个类都有这个方法并且可以重写这个方法，在这个方法里实现释放系统资源及其他清理工作，JVM不保证此方法总被调用。
在执行一个文件的时候 我们就是用finally来进行关闭 无论结果如何
因为我们肯定会执行finally语句块

final

修饰类

当用final修饰一个类时，表明这个类不能被继承。也就是说，如果一个类你永远不会让他被继承，就可以用final进行修饰。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。

在使用final修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承或者出于安全的考虑，尽量不要将类设计为final类。

修饰方法

下面这段话摘自《Java编程思想》第四版第143页：
　　“使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中，不需要使用final方法进行这些优化了。“
　　因此，如果只有在想明确禁止 该方法在子类中被覆盖的情况下才将方法设置为final的。
注意🐼 ：类的private方法会隐式地被指定为final方法。

修饰变量

修饰变量是final用得最多的地方，首先了解一下final变量的基本语法：
　　对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。

类的final变量和普通变量有什么区别？

当用final作用于类的成员变量时，成员变量（注意是类的成员变量，局部变量只需要保证在使用之前被初始化赋值即可）必须在定义时或者构造器中进行初始化赋值，而且final变量一旦被初始化赋值之后，就不能再被赋值了。

public class Test {
    public static void main(String[] args)  {
        String a = "hello2"; 
        final String b = "hello";
        String d = "hello";
        String c = b + 2; 
        String e = d + 2;
        System.out.println((a == c));
        System.out.println((a == e));
    }
}

大家可以先想一下这道题的输出结果。为什么第一个比较结果为true，而第二个比较结果为fasle。这里面就是final变量和普通变量的区别了，当final变量是基本数据类型以及String类型时，如果在编译期间能知道它的确切值，则编译器会把它当做编译期常量使用。也就是说在用到该final变量的地方，相当于直接访问的这个常量，不需要在运行时确定。这种和C语言中的宏替换有点像。因此在上面的一段代码中，由于变量b被final修饰，因此会被当做编译器常量，所以在使用到b的地方会直接将变量b 替换为它的 值。而对于变量d的访问却需要在运行时通过链接来进行。想必其中的区别大家应该明白了，不过要注意，只有在编译期间能确切知道final变量值的情况下，编译器才会进行这样的优化，比如下面的这段代码就不会进行优化：

public class Test {
    public static void main(String[] args)  {
        String a = "hello2"; 
        final String b = getHello();
        String c = b + 2; 
        System.out.println((a == c));
 
    }
     
    public static String getHello() {
        return "hello";
    }
}
//这段代码的输出结果为false。

被final修饰的引用变量指向的对象内容可变吗？

引用变量被final修饰之后，虽然不能再指向其他对象，但是它指向的对象的内容是可变的。

fianl和static

很多时候会容易把static和final关键字混淆，static作用于成员变量用来表示只保存一份副本，而final的作用是用来保证变量不可变。

public class Test {
    public static void main(String[] args)  {
        MyClass myClass1 = new MyClass();
        MyClass myClass2 = new MyClass();
        System.out.println(myClass1.i);
        System.out.println(myClass1.j);
        System.out.println(myClass2.i);
        System.out.println(myClass2.j);
 
    }
}
 
class MyClass {
    public final double i = Math.random();
    public static double j = Math.random();
}

运行这段代码就会发现，每次打印的两个j值都是一样的，而i的值却是不同的。从这里就可以知道final和static变量的区别了。

fianlly

1. try 关键字最后可以定义 finally 代码块。 finally 块中定义的代码，总是在 try 和任何 catch 块之后、方法完成之前运行。
2. 不管是否发生异常 finally 都会执行，因此我们可以在 finally 代码块中执行关闭连接、关闭文件和释放线程的的 *** 作。
3. 即使出现未被处理的异常，JVM 依然会执行 finally 代码块的代码。
4. try 代码块发生异常， 被 catch 捕捉， finally 依然会执行。
5. 即使 try 代码块中返回，也不能阻止 finally 代码块的执行。
6. 在 catch 代码块中添加返回语句，finally 代码依然会执行。
7. 尽管通常编写 finally 代码块是为了这段代码一定被执行到，但是也有一些特殊情况会导致 JVM 不会执行 finally 代码块。如果 *** 作系统中断了我们的程序，那么finally 代码块可能就不能被执行。也有很多其他类似的行为导致 finally代码块不被执行。
8. 如果守护线程刚开始执行到 finally 代码块，此时没有任何其他非守护线程，那么虚拟机将退出，此时 JVM 不会等待守护线程的 finally 代码块执行完成。
9. Try 代码块出现无限循环，且不出现异常，finally 也将永远得不到执行。
10. finally 代码块包含返回语句，没有处理未捕获的异常。

try {
    System.out.println("Inside try");
    throw new RuntimeException();
} finally {
    System.out.println("Inside finally");
    return "from finally";
}
//此时，try 代码块中的 RuntimeException 会被忽略，函数返回 "from finally"字符串。

11. 如果 finally 代码块中存在返回语句，则 try 和 catch 代码块如果存在返回语句就会被忽略。

try {
    System.out.println("Inside try");
    return "from try";
} finally {
    System.out.println("Inside finally");
    return "from finally";
}
//此段代码总是返回 “from finally” 。

12. 如果再 finally 代码块中扔出异常，则 try 和 catch 中的异常扔出或者返回语句都将被忽略。

try {
    System.out.println("Inside try");
    return "from try";
} finally {
    throw new RuntimeException();
}
//这段代码永远都不会有返回值，总是会抛出 RuntimeException

finalize

finalize作用

finalize()是Object的protected方法，子类可以覆盖该方法以实现资源清理工作，GC在回收对象之前调用该方法。

finalize()与C++中的析构函数不是对应的。C++中的析构函数调用的时机是确定的（对象离开作用域或delete掉），但Java中的finalize的调用具有不确定性

不建议用finalize方法完成“非内存资源”的清理工作，但建议用于：① 清理本地对象(通过JNI创建的对象)；② 作为确保某些非内存资源(如Socket、文件等)释放的一个补充：在finalize方法中显式调用其他资源释放方法。其原因可见下文[finalize的问题]

finalize的问题

一些与finalize相关的方法，由于一些致命的缺陷，已经被废弃了，如System.runFinalizersOnExit()方法、Runtime.runFinalizersOnExit()方法

System.gc()与System.runFinalization()方法增加了finalize方法执行的机会，但不可盲目依赖它们

Java语言规范并不保证finalize方法会被及时地执行、而且根本不会保证它们会被执行

finalize方法可能会带来性能问题。因为JVM通常在单独的低优先级线程中完成finalize的执行

对象再生问题：finalize方法中，可将待回收对象赋值给GC Roots可达的对象引用，从而达到对象再生的目的

finalize方法至多由GC执行一次(用户当然可以手动调用对象的finalize方法，但并不影响GC对finalize的行为)

finalize：是垃圾回收器 *** 作的运行机制中的一部分，进行垃圾回收器 *** 作时会调用finalize方法，因为finalize方法是object的方法，所以每个类都有这个方法并且可以重写这个方法，在这个方法里实现释放系统资源及其他清理工作，JVM不保证此方法总被调用。

5.编译看左边，运行看右边

class A {
    public int func1(int a, int b) {
        return a - b;
    }
}
class B extends A {
    public int func1(int a, int b) {
        return a + b;
    }
}
public class ChildClass {
    public static void main(String[] args) {
    A a = new B();
    B b = new B();
    System.out.println("Result=" + a.func1(100, 50));
    System.out.println("Result=" + b.func1(100, 50));
    }
}

运行结果为？

其实很简单，涉及转型的题目，分为向上或者向下转型。
关键的来了，不论向上或者向下转型，都是一句话，“编译看左边，运行看右边”。也就是编译时候，会看左边引用类型是否能正确编译通过，运行的时候是调用右边的对象的方法。
就本题来说，编译时候会发现左边满足条件所以编译通过，运行时候又会调用右边也就是 class B 的方法，所以答案都是150。

6.一维数组的定义

Java一维数组初始化方法

1.静态初始化

2.动态初始化

静态与动态初始化的区别就在于，前者是声明的时候就初始化，后者是先声明，再动态初始化。

【静态】是自己一个一个用数据撑开的，而【动态】是定义了数组的容量，让系统去初始化赋值00000

7.AOP/OOP

AOP和OOP都是一套方法论，也可以说成设计模式、思维方式、理论规则等等。
AOP不能替代OOP，OOP是obejct abstraction，而AOP是concern abstraction，前者主要是对对象的抽象，诸如抽象出某类业务对象的公用接口、报表业务对象的逻辑封装，更注重于某些共同对象共有行为的抽象，如报表模块中专门需要报表业务逻辑的封装，其他模块中需要其他的逻辑抽象 ，而AOP则是对分散在各个模块中的共同行为的抽象，即关注点抽象。一些系统级的问题或者思考起来总与业务无关又多处存在的功能，可使用AOP，如异常信息处理机制统一将自定义的异常信息写入响应流进而到前台展示、行为日志记录用户 *** 作过的方法等，这些东西用OOP来做，就是一个良好的接口、各处调用，但有时候会发现太多模块调用的逻辑大都一致、并且与核心业务无大关系，可以独立开来，让处理核心业务的人专注于核心业务的处理，关注分离了，自然代码更独立、更易调试分析、更具好维护。
核心业务还是要OOP来发挥作用，与AOP的侧重点不一样，前者有种纵向抽象的感觉，后者则是横向抽象的感觉， AOP只是OOP的补充，无替代关系。

AOP 和 OOP的区别：

1. 面向方面编程 AOP 偏重业务处理过程的某个步骤或阶段，强调降低模块之间的耦合度，使代码拥有更好的移植性。
2. 面向对象编程 (oop) 则是对业务分析中抽取的实体进行方法和属性的封装。也可以说 AOP 是面向业务中的动词领域， OOP 面向名词领域。AOP 的一个很重要的特点是源代码无关性，也就是说如果我们的系统中引用了 AOP 组件，即使我们把该组件去掉，系统代码也应该能够编译通过。要实现这一点，可以使用动态 proxy 模式。

8.重写/重载

我吐了，这道题我又错了···

重载就是一句话：同名不同参，返回值无关。
覆盖/重写：同名同参

Java 重载的规则：
1、必须具有不同的参数列表；
2、可以有不同的返回类型，只要参数列表不同就可以；
3、可以有不同的访问修饰符；
4、可以抛出不同的异常；
5、方法能够在一个类中或者在一个子类中被重载。
方法的重写：
1、在子类中可以根据需要对从基类中继承来的方法进行重写。
2、重写的方法和被重写的方法必须具有相同方法名称、参数列表和返回类型。
3、重写方法不能使用比被重写的方法更严格的访问权限。

9.string字符数在heap中保存个数

substring实际是new，5字符
str3和4也都是new，每个5字符
分别都会创建新的对象
常量池是PermGen的
因此应该是一共15字符

这是一个关于java的垃圾回收机制的题目。垃圾回收主要针对的是堆区的回收，因为栈区的内存是随着线程而释放的。堆区分为三个区：年轻代（Young Generation）、年老代（Old Generation）、永久代（Permanent Generation，也就是方法区）。
年轻代：对象被创建时（new）的对象通常被放在Young（除了一些占据内存比较大的对象）,经过一定的Minor GC（针对年轻代的内存回收）还活着的对象会被移动到年老代（一些具体的移动细节省略）。
年老代：就是上述年轻代移动过来的和一些比较大的对象。Minor GC(FullGC)是针对年老代的回收
永久代：存储的是final常量，static变量，常量池。
str3,str4都是直接new的对象，而substring的源代码其实也是new一个string对象返回，
经过fullgc之后，年老区的内存回收，则年轻区的占了15个，不算PermGen。所以答案选C

10.继承多态-初始化

下面代码的输出结果是

class C {
    C() {
        System.out.print("C");
    }
}
 
class A {
    C c = new C();
 
    A() {
        this("A");
        System.out.print("A");
    }
 
    A(String s) {
        System.out.print(s);
    }
}
 
class Test extends A {
    Test() {
        super("B");
        System.out.print("B");
    }
 
    public static void main(String[] args) {
        new Test();
    }
}

初始化过程是这样的：
1.首先，初始化父类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化；
2.然后，初始化子类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化；
3.其次，初始化父类的普通成员变量和代码块，在执行父类的构造方法；
4.最后，初始化子类的普通成员变量和代码块，在执行子类的构造方法；

（1）初始化父类的普通成员变量和代码块，执行 C c = new C(); 输出C
（2）super(“B”); 表示调用父类的构造方法，不调用父类的无参构造函数，输出B
（3） System.out.print(“B”);
所以输出CBB

11.Servlet

下列有关Servlet的生命周期，说法不正确的是？
A:在创建自己的Servlet时候，应该在初始化方法init()方法中创建Servlet实例
B:在Servlet生命周期的服务阶段，执行service()方法，根据用户请求的方法，执行相应的doGet()或是doPost()方法
C:在销毁阶段，执行destroy()方法后会释放Servlet 占用的资源
D:destroy()方法仅执行一次，即在服务器停止且卸载Servlet时执行该方法

创建Servlet的实例是由Servlet容器来完成的，且创建Servlet实例是在初始化方法init()之前

Servlet的生命周期分为5个阶段：加载、创建、初始化、处理客户请求、卸载。
(1)加载：容器通过类加载器使用servlet类对应的文件加载servlet
(2)创建：通过调用servlet构造函数创建一个servlet对象
(3)初始化：调用init方法初始化
(4)处理客户请求：每当有一个客户请求，容器会创建一个线程来处理客户请求
(5)卸载：调用destroy方法让servlet自己释放其占用的资源

12.ArrayList/LinkedList

ArrayList插入和现有项的删除开销很大,除非在末端
LinkedList插入和删除开销很小
ArrayList和LinkedList都是实现了List接口
HashMap可以用null值和空字符串作为K,不过只能有一个

13.ClassLoader

关于Java中的ClassLoader下面的哪些描述是错误的：( )

A:默认情况下，Java应用启动过程涉及三个ClassLoader: Boostrap, Extension, System
B:一般的情况不同ClassLoader装载的类是不相同的，但接口类例外，对于同一接口所有类装载器装载所获得的类是相同的
C:类装载器需要保证类装载过程的线程安全
D:ClassLoader的loadClass在装载一个类时，如果该类不存在它将返回null
E:ClassLoader的父子结构中，默认装载采用了父优先
F:所有ClassLoader装载的类都来自CLASSPATH环境指定的路径

---

A.Java系统提供3种类加载器：启动类加载器（Bootstrap ClassLoader） 扩展类加载器（Extension ClassLoader） 应用程序类加载器（Application ClassLoader）. A正确
B.《深入理解Java虚拟机》P228：对于任意一个类，都需要由加载它的类加载器和这个类本身一同确立其在Java虚拟机中的唯一性，每一个类加载器，都拥有一个独立的类名称空间。这句话可以表达得更通俗一些：比较两个类是否“相等”，只有在这两个类是由同一个类加载器加载的前提下才有意义，否则，即使这两个类来源于同一个Class文件，被同一个虚拟机加载，只要加载它们的类加载器不同，那么这两个类必定不相等。接口类是一种特殊类，因此对于同一接口不同的类装载器装载所获得的类是不相同的。B错误
C.类只需加载一次就行，因此要保证类加载过程线程安全，防止类加载多次。C正确
D. Java程序的类加载器采用双亲委派模型，实现双亲委派的代码集中在java.lang.ClassLoader的loadClass()方法中，此方法实现的大致逻辑是：先检查是否已经被加载，若没有加载则调用父类加载器的loadClass()方法，若父类加载器为空则默认使用启动类加载器作为父类加载器。如果父类加载失败，抛出ClassNotFoundException异常。D错误
E.双亲委派模型的工作过程：如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一个层次的类加载器都是如此，因此所有的加载请求最终都应该传送到顶层的启动类加载器中，只有当父加载器反馈自己无法完成这个加载请求时，子加载器才会尝试自己去加载。E正确
F.应用程序类加载器（Application ClassLoader）负责加载用户类路径（ClassPath）上所指定的类库，不是所有的ClassLoader都加载此路径。F错误

如果有哪里不懂可以评论区指出
希望能帮到你