每日一练 9

最新推荐文章于 2024-08-23 15:54:50 发布

czhc1140075663

最新推荐文章于 2024-08-23 15:54:50 发布

阅读量418

点赞数

文章标签： java c++ jvm

本文链接：https://blog.csdn.net/czhc1140075663/article/details/127134477

版权

在这里插入图片描述 b

常量池
，原来以为只要是一个整型，都会放进到常量池，比如，0,1,12222222等。查找后发现，Byte,Short,Integer,Long,Character这5种整型的包装类也只是在对应值小于等于127并且大于等于-128时才可使用常量池，因为他们至占用一个字节(-128~127);

请叫我猿叔叔
发表于 2016-07-17 21:20:44

非基本类型，== 比较地址。
基本类型，==比较数值
如果两个有一个包装类型，就把包装类型转换为基本类型再比较数值
俩都为包装类型时，比较的是地址

链接：https://www.nowcoder.com/questionTerminal/e35f449be29548c68352ef302965a44e
来源：牛客网
loveincode
i01== i02 true i02 是int类型(基本类型)，和i01(包装类型)比较，i01会自动拆箱为基本类型再比较值是否相等
i01== i03 true 都指向IntegerCache[59-(-128)]对象
i03== i04 false 引用指向的对象地址不同
i04==i02 true i02 是int类型(基本类型)，和i04(包装类型)比较，i04会自动拆箱为基本类型再比较值是否相等
发表于 2018-05-24 15:45

i01==i03 true 都指向IntegerCache[59-(-128)]对象

Integer i01=59;
int i02=59;
Integer i03=Integer.valueOf(59);
Integer i04=new Integer(59);

链接：https://www.nowcoder.com/questionTerminal/e35f449be29548c68352ef302965a44e
来源：牛客网
i01和i02比的是数值，i01和i03比的是地址（在编译前定义的数值会从常量获取，-128~127之间），因为i01和i03都是编译之前定义的，所以是常量池中的同一个对象。i02和i04比较的也是数值（自动拆装箱），i03和i04比较的是地址，因为i04是编译之后又new出来的对象，所以它的地址必然不在常量池中，所以i03==io4的结果为false

编译前定义的数值

在这里插入图片描述

Trenson
B，局部变量必须有初始值。
编辑于 2015-02-03 11:09:56

定义在类中的变量是类的成员变量，可以不进行初始化

局部变量是定义在方法中的变量，必须要进行初始化，否则不同通过编译

被static关键字修饰的变量是静态的，静态变量随着类的加载而加载，所以也被称为类变量

被final修饰发变量是常量

Jeff_Lui
解析：instanceof关键字是判断对象是否是属于类，格式：对象名 instanceof 类名
发表于 2020-03-21 01:28:24

这里调用 t.run();
并没有启动一个新的线程，启动一个新线程要用t.start();
所以执行顺序是先执行run（），再执行 System.out.print(“HELLO”);

上述代码实际上是在main()方法内部又调用了run()方法，打印sogou语句是在main线程中执行的，没有任何新线程被创建

public class HelloSogou{
     public static synchronized void main(String[] a){
         Thread t=new Thread(){
             public void run(){Sogou();}
     };
     t.run();
     System.out.print("Hello");
     }
     static synchronized void Sogou(){
     System.out.print("Sogou");
    }
}

?
在这里插入图片描述正确答案: C 你的答案: A (错误)

public class HelloB extends HelloA 
{
 public HelloB()
 {
 }
 {
     System.out.println("I’m B class");
 }
 static
 {
     System.out.println("static B");
 }
 public static void main(String[] args)
 {
     new HelloB();
 }
}
class HelloA
{
 public HelloA()
 {
 }
 {
     System.out.println("I’m A class");
 }
 static
 {
     System.out.println("static A");
 }
}

其中涉及：静态初始化代码块、构造代码块、构造方法
当涉及到继承时，按照如下顺序执行：
1、执行父类的静态代码块
static {
System.out.println(“static A”);
}
输出:static A
2、执行子类的静态代码块
static {
System.out.println(“static B”);
}
输出:static B
3、执行父类的构造代码块
{
System.out.println(“I’m A class”);
}
输出:I’m A class
4、执行父类的构造函数
public HelloA() {
}
输出：无
5、执行子类的构造代码块
{
System.out.println(“I’m B class”);
}
输出:I’m B class
6、执行子类的构造函数
public HelloB() {
}
输出：无

static A
static B
I’m A class

I’m B class

在这里插入图片描述

运行时异常：都是RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。

运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。

非运行时异常（编译异常）：是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常。

在这里插入图片描述

牛客100362715号头像
牛客100362715号
synchronized是一种锁机制，（多个线程要排队访问同一个共享对象）存在阻塞问题和性能问题，而volatile并不是锁，是java虚拟机提供的一种轻量级同步机制，不存在阻塞和性能问题，volatile借助内存屏障来帮助其解决可见性和有序性问题，并且还为其带来了一个禁止指令重排的附件功能。
发表于 2021-03-27 20:14:37

会飞的字节
Volatile具有两大特性。一、有序性和可见性。

有序性是为了解决重排序问题。而可见性是为了解决内存可见性问题。

至于原子性则是因为它线程不安全，无法实现。发表于 2020-07-30 23:14:09

在这里插入图片描述 抽象方法

链接：https://www.nowcoder.com/questionTerminal/7f7577c94e694cf7adc7edd4f016310f
来源：牛客网

大橘已定

final：修饰符，如果修饰类，此类不能被继承；如果修饰方法和变量，则表示此方法和此变量不能在被改变，只能使用。
abstract：修饰符，如果是修饰类，**此类是抽象类**，**抽象类可以包含抽象方法，但没必要；抽象类不能直接实例化，需要被继承以后才能实例化，因为抽象类本身就是为了继承而设计的。**
定义抽象类就是让其他类继承的，**如果用 final修饰 该类就不能被继承，这样彼此就会产生矛盾，所以 final 不能修饰抽象类**，

发表于 2019-03-07 16:32

因为不能实例化，即不能创建对象，abstract
final 此类不能被继承
抽象类定义中可以没有抽象方法

在这里插入图片描述

许你清安L

HttpServletResponse（接口）就只是提供了这么几个方法声明来设置响应头的数据。

发表于 2021-10-23 11:16:51

记住就行

在这里插入图片描述

proven丶yu头像
proven丶yu
int 类变量初始值0
boolean 类变量初始值false
char 类变量初始值’\u0000’
double 类变量初始值0.0
float 类变量初始值0.0f
long 类变量初始值0L
发表于 2017-10-10 11:45:44

public class Demo{
    int x=1；

    int y；
    public static void main（String [] args）{

        int z=2;

        Demo t=new Demo();
        System.out.println(t.x+t.y+z);
    }
}

1+2 ？

在这里插入图片描述

鲱鱼罐头
201806171927645头像鲱鱼罐头201806171927645 蒙对的。后来搜索了一下 Java 中的堆是 JVM 所管理的最大的一块内存空间，主要用于存放各种类的实例对象。在 Java 中，堆被划分成两个不同的区域：新生代 ( Young )、老年代
( Old )。新生代 ( Young ) 又被划分为三个区域：Eden、From Survivor、To Survivor。

在这里插入图片描述

解析
选B。

在类内部可以用户可以使用关键字this.**构造方法**名()调用（参数决定调用的是本类对应的构造方法）
在子类中用户可以通过关键字super.父类构造方法名()调用（参数决定调用的是父类对应的构造方法。）
反射机制对于任意一个类，都能够知道这个类的所有属性和方法，包括类的构造方法。

在这里插入图片描述 Top0NE
PreparedStatement 和 CallableStatement都继承了Statement。
CallableStatement 继承了 PreparedStatement。
发表于 2015-09-20 14:00:56

在这里插入图片描述构造方法

构造方法，是一种特殊的方法，它是一个与类同名的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的初始化。当类实例化一个对象时会自动调用构造方法。构造方法和其他方法一样也可以重载。
构造方法

在Java中，任何变量在被使用前都必须先设置初值，如无显式赋值，则编译器会为其进行隐性赋值。Java提供了为类的成员变量赋初值的专门方法。

重载、重写
 重载和重写

一、重载和重写的概念：
重载的概念：
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
重写的概念：
在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。

链接：https://www.nowcoder.com/questionTerminal/5be12dae20c64948b629236dea3d49f9
来源：牛客网

江松展

JAVA的初始化顺序：

父类的静态成员初始化>父类的静态代码块>子类的静态成员初始化>子类的静态代码块>父类的代码块>父类的构造方法>子类的代码块>子类的构造方法

注意：

1.静态成员和静态代码块只有在类加载的时候执行一次，再次创建实例时，不再执行，因为只在方法区存在一份，属于一整个类。

2.上述的是通用的加载顺序，如果没有则省略。
添加链接描述

在这里插入图片描述 在这里插入代码片

public class Test {
    public static class A {
        private B ref;
        public void setB(B b) {
            ref = b;
        }
    }
    public static Class B {
        private A ref;
        public void setA(A a) {
            ref = a;
        }
    }
    public static void main(String args[]) {
    …
        start();
    ….
    }
    public static void start() { A a = new A();
        B b = new B();
        a.setB(b);
        b = null; //
        a = null;
    …
    }
}