【方向盘】JavaSE/EE基础面试题、基础知识记录---大杂烩

【方向盘】-JDK 同时被 2 个专栏收录
116 篇文章 72 订阅

非常地难学,但是却不可思议地好用。你还要学吗?
本文已被https://yourbatman.cn收录;女娲Knife-Initializr工程可公开访问啦;程序员专用网盘https://wangpan.yourbatman.cn;公号后台回复“专栏列表”获取全部小而美的原创技术专栏

你好,我是方向盘(YourBatman、方哥)

说在前面

此博文旨在搜集一些JavaSE基础部分的经典面试题,希望能达到一针见血,通过面试题来达到让大家记忆深刻的目的。
持续连载中。。。

案例

++i和i++有什么区别?volatile关键字?能保证这个操作的原子性吗?
1、请补全下面代码,达到所需输出的效果
 public static void main(String[] args) throws Exception {
        List<Integer> list = new ArrayList<>();
        list.add(1);

        //请在此处补全代码

        System.out.println(list); //期望输出为:[1, a, 2, b]
    }
2、判断下面输出什么内容?

输出内容eg:
java.lang.Number
java.lang.Integer
等类似的

public static void main(String[] args) throws NoSuchFieldException {
        Field id = Son.class.getField("id");
        System.out.println(id.getType()); 
    }

    class Son extends BaseEntity<Integer> {
        public String name;
    }

    class BaseEntity<PK extends Number> {
        public PK id;
    }
 public static void main(String[] args) throws NoSuchFieldException {
        Field id = Son.class.getField("id");
        System.out.println(id.getType()); 
    }

    class Son extends BaseEntity<Integer> {
        public String id;
        public String name;
    }

    class BaseEntity<PK extends Number> {
        public PK id;
    }
说说给String直接赋值,和采用new赋值有什么异同?

注解的属性们,都必须有默认值吗?属性们能够哪些类型?

答:属性的default默认值都不是必须的。若不指定默认值,使用该注解时每个属性都必填,所以一般建议给默认值

**只有你的属性叫“value()”,并且使用时只给他一个赋值的时候是可以省略的~~~**,其余情况均不能省略

它支持的类型;

  • 所有基本类型(int,float,boolean,byte,double,char,long,short)
  • String
  • Class
  • enum
  • Annotation
  • 上述类型的数组
方法内部可以书写代码块吗?可以书写多个吗?若能说说它有什么好处

可以的。

    // 代码方法内部定义的变量互不干扰,有很好的隔离效果
    public void fun1() {
        {
            String s = "demo";
            // 代码块一
        }

        {
            //System.out.println(s); // 此处不能引入变量s
            // 代码块二
        }
    }
阐述你对Java中eq方法和==的区别?说得越详细越好?举例说明

要点:答出重写HashCode不能改变==是至少的要求

说说你对Map中put方法和putIfAbsent的理解?

下面编译报错吗?不抱错会输出什么呢?

 public static void main(String[] args) {

        Map<String,String> map = new HashMap<>();
        System.out.println(map.put("a","a")); 
        System.out.println(map.putIfAbsent("b","b")); 
        System.out.println(map.putIfAbsent("b","b")); 

    }

面试题:Map的put方法,相同的key会被覆盖,请解释相同二字

System.out.print的输出、输出流为什么不用手动关闭呢?

  public static void main(String[] args) {
        PrintStream out = System.out;
        out.println("我");
        out.close();
        out.println("爱");
        out.println("中");
        out.println("国");
    }

请问上述会输出什么?

那为什么我们平时不需要自己手动去关闭呢?请回答

针对Map的put方法,请输出下面的打印结果?并解释为什么?

 public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        System.out.println(map.put("a","a")); 
        System.out.println(map.putIfAbsent("b","b")); 
        System.out.println(map.putIfAbsent("b","c"));
        //put的用法  
        System.out.println(map.put("c","c")); 
        System.out.println(map.put("d","d")); 
        System.out.println(map.put("c","d")); 
    }

void.class == Void.class是true还是false

答案:false

public static void main(String[] args) {
    System.out.println(void.class); // void
    System.out.println(Void.class); // class java.lang.Void
}

同样的int.class == Integer.class都是false的~

当我们比较Boolean包装类型时,可能遇到的坑

public static void main(String[] args) {
         Boolean b = null;
         System.out.println(b == Boolean.TRUE); //false  此处不报错
         System.out.println(b == true); //java.lang.NullPointerException
    }

   public static void main(String[] args) {
        Boolean b = new Boolean(true);
        System.out.println(b == new Boolean(true)); //false
        System.out.println(b == Boolean.TRUE); //false
        System.out.println(b == Boolean.TRUE.booleanValue()); //true
        System.out.println(b == true); //true

    }

比如上面的例子。如果是包装类型,千万不要简单的用if(b == true)来判断

说说i++和++i的区别?

说出下面两题的答案:

    public static void main(String[] args) throws InterruptedException {
        int i = 1;
        System.out.println((i++) - (++i)); 

        i=5;
        System.out.println((++i)+(++i)+(++i));
    }

答案:-2 21
原因(第一题为例):第一个i++是先用i的值,所以表达式取值1,最后i的值变为了2。到第二个++i时,表达式取值为3了。所以最终为1-3 = -2

使用javap -c -l Main.class可以查看字节码最终执行的指令,一目了然
在这里插入图片描述

maven相关的面试:

maven有哪些优点?

(1)依赖管理,节省空间
(2)一键构建 编码 编译 测试(junit) 运行 打包 部署
(3)应用于大型项目 可以提高开发效率

Maven常见的依赖范围有哪些?
          编译 测试 运行 打包 

compile(struts2-core) 要 要 要 要
provided(jsp-api.jar) 要 要 不要 不要
runtime(数据库驱动包) 不要 要 要 要
test(junit.jar) 不要 要 不要 不要

maven中怎么排除依赖?Optional和Exclusions的使用的异同?

在maven的依赖管理中,有两种方式可以对依赖关系进行,分别是可选依赖(Optional Dependencies)以及依赖排除(Dependency Exclusions)

maven的常用命令

Clean 清理编译的文件
Compile 编译了主目录的文件
Test 编译并运行了test目录的代码
Package 打包
Install 就是把项目发布到本地仓库
deploy 发布到私服
Tomcat:run 一键启动

坐标的组成 (GAV)

Gruop Id
Artifact Id
Version

Maven版本冲突出现的原因?maven是如何自动解决冲突的依赖的?

1、路径最短原则
2、**优先声明原则:**当出现路径长短相同的时候,谁先声明就用谁。如F1和F2的路径距离相同,但是由于F1比F2先声明(B比C先声明),所以最终使用F1。

优先声明的解释:如果你是在自己的pom里书写(并不是间接依赖进来的),那么下面的版本号是会覆盖上面的

说说Maven的包的依赖关系怎么决定的?
自定义maben骨架模版、自定义maven插件的步骤?使用场景呢?
mvn deploy之前需要先执行clean吗?有必要吗?如果不执行会不会有问题?

怎么解释最近依赖原则?怎么解释同路径长度的依赖呢?

maven打包src/main/java的xml、properties等文件

这里面我推荐这篇文章来解答:maven资源文件的相关配置

        <!--
            directory:属性指定资源文件放置的目录。
            includes:包含哪些配置文件(.class文件不用写)
            filtering:如果设置为false的话,则表示上文的filters配置失效;如果设置为true,则会根据${env}.properties里面的键值对来
                       填充includes指定文件里的${xxxx}占位符(若不做环境区分,一般就是false即可)
        -->
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                    <include>**/*.tld</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                    <include>**/*.tld</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>
maven中的scope和optional的区别???

maven的scope决定依赖的包是否加入本工程的classpath下,下面一幅图就能看懂
在这里插入图片描述
optional与scope区别在于:仅限制依赖包的传递性,不影响依赖包的classpath

比如如下例子:A->B, B->C(scope:compile, optional:true)
B的编译/运行/测试classpath都有C,所以非常良好木有问题
但是,A因为是间接依赖的C,但是因为c上有optional:true,所以A中的编译/运行/测试classpath都是不会有C的。(尽管C是compile),可见optional的优先级比scope高

optional:true的功能特别像scope:provided,所以姑且可以认为他俩没有太大的区别~




for循环声明上调用方法,下面例子,方法被调用了几次呢?

public static void main(String[] args) {
        System.out.println("================普通for循环:");
        for (int i = 0; i < getData().size(); i++) {
            System.out.println(i);
        }
        System.out.println("================增强for循环:");
        for (Integer i : getData()) {
            System.out.println(i);
        }
        System.out.println("================Java8提供的foreach循环:");
        getData().forEach(System.out::println);
    }

    private static List<Integer> getData() {
        System.out.println("getDate被调用...");
        var list = new ArrayList<Integer>();
        list.add(10);
        list.add(20);
        list.add(30);
        return list;
    }

原因剖析,可参见另外一篇博文:【小家java】剖析for、while、foreach、标签循环语句的控制( break,continue,return )

怎么判断A是否是B的子类、实例等等

    public static void main(String[] args) {
        //若我们得到的都只有Class类对象  可以这么判断
        Class<Number> numberClass = Number.class;
        Class<Long> longClass = Long.class;
        boolean assignableFrom = numberClass.isAssignableFrom(longClass); //longClass是否归属于numberClass
        System.out.println(assignableFrom); //true  说明long是number的子类
        //进而可以各种强转
        Class<? extends Number> aClass = longClass.asSubclass(numberClass);
        System.out.println(aClass); //class java.lang.Long  若没报错 说明转换完成

        //如果你是两个实例
        Long lon = new Long(100);
        boolean b = lon instanceof Number;
        System.out.println(b); //true
        //转换
        Number cast = Number.class.cast(lon);
        //lon.getClass().cast(Number.class); //这是错误写法
        System.out.println(cast); //100
    }
说说Java中常用的几种数据结构?

数据元素相互之间的关系称为结构。有四类基本结构:集合、线性结构、树形结构、图状结构;Java中有几种常用的数据结构,主要分为Collection和Map两个主要接口,而程序中最终使用的数据结构是继承自这些接口的数据结构类
数组、链表、红黑树、哈希表等

什么叫hash碰撞?hashMap是怎么解决碰撞问题的?

如果两个输入串的hash函数的值一样,则称这两个串是一个碰撞(Collision)。既然是把任意长度的字符串变成固定长度的字符串,所以必有一个输出串对应无穷多个输入串,碰撞是必然存在的。
通常有两类方法处理碰撞:开放寻址(Open Addressing)法和链接(Chaining)法。前者是将所有结点均存放在散列表T[0…m-1]中;后者通常是把散列到同一槽中的所有元素放在一个链表中,而将此链表的头指针放在散列表T[0…m-1]中。显然HashMap采用链表法

说说get请求和Post请求的基本区别:
  1. get参数通过url传递,post放在request body中。
  2. get请求在url中传递的参数是有长度限制的,而post没有。(HTTP协议规范没有对URL长度进行限制,但各大浏览器和web服务器加了限制。要支持IE,则最大长度为2083byte,若只支持Chrome,则最大长度 8182byte
  3. get比post更不安全,因为参数直接暴露在url中,所以不能用来传递敏感信息。
  4. get请求只能进行url编码,而post支持多种编码方式
  5. get请求会浏览器主动cache,而post则需要设置参数
  6. get请求参数会被完整保留在浏览历史记录里,而post中的参数不会被保留。
  7. GET和POST本质上就是TCP链接,并无差别。但是由于HTTP的规定和浏览器/服务器的限制,导致他们在应用过程中体现出一些不同。
  8. GET产生一个TCP数据包;POST产生两个TCP数据包。
    对于GET方式的请求,浏览器会把http header和data一并发送出去,服务器响应200(返回数据);
    而对于POST,浏览器先发送header,服务器响应100 continue,浏览器再发送data,服务器响应200 ok(返回数据)

(据研究,在网络环境好的情况下,发一次包的时间和发两次包的时间差别基本可以无视。而在网络环境差的情况下,两次包的TCP在验证数据包完整性上,有非常大的优点。)

mysql分布式集群实现原理?

mysql-cluster配置管理节点、数据节点
集群主要分成三大类( 高可用集群, 负载均衡集群,科学计算集群)

  1. 高可用集群:活动节点一般只有一个,如Nginx。常见的就是2个节点做成的HA集群,有很多通俗的不科学的名称,比如"双机热备", “双机互备”, “双机”.
  2. 负载均衡集群(Load Balance Cluster):集群中所有的节点都处于活动状态,它们分摊系统的工作负载。一般Web服务器集群、数据库集群和应用服务器集群都属于这种类型。
  3. 高性能计算(High Perfermance Computing)集群,简称HPC集群。这类集群致力于提供单个计算机所不能提供的强大的计算能力
说说分布式和集群的区别:

集群是个物理形态,分布式是个工作方式。
1、只要是一堆机器,就可以叫集群,他们是不是一起协作着干活,这个谁也不知道;一个程序或系统,只要运行在不同的机器上,就可以叫分布式
2、集群可能运行着一个或多个分布式系统,也可能根本没有运行分布式系统;分布式系统可能运行在一个集群上,也可能运行在不属于一个集群的多台(2台也算多台)机器上。
3、分布式是相对中心化而来,强调的是任务在多个物理隔离的节点上进行。中心化带来的主要问题是可靠性,若中心节点宕机则整个系统不可用,分布式除了解决部分中心化问题,也倾向于分散负载,但分布式会带来很多的其他问题,最主要的就是一致性。
4、分布式:一个业务分拆多个子业务,部署在不同的服务器上(集群是解决高可用的)
5、集群:同一个业务,部署在多个服务器上(分布式是解决高性能、高并发的)

zookeeper有什么用?

分析zookeeper到底能做什么?

分布式接口的幂等性设计?

分布式系统接口幂等性设计
分布式系统的接口幂等性设计

深度优先与广度优先的区别?

广度优先和深度优先的区别

jstack,jmap,jutil分别的意义?

jstack,jmap,jutil分别的意义

有界、无界队列对ThreadPoolExcutor执行的影响?

有界、无界队列对ThreadPoolExcutor执行的影响

通过面试题来看,可以看出目前互联网公司面试考点为:
1.性能调优、算法数据机构
2.高并发下数据安全、接口冪等性、原子性等
3.分布式下协同、已经锁的处理
4.数据库的分库分表、项目之间的垂直拆分
出现频率高的技术点有:
1.HashMap
2.JVM
3.Dubbo
4.Mybatis
5.Zookeeper
6.http tcp/ip

简述Spring是怎么巧妙的解决bean循环依赖问题的?

Spring-bean的循环依赖以及解决方式
Spring循环依赖的三种方式

判断下面多线程环境下,输出顺序?

    public static void main(String[] args) throws ExecutionException, InterruptedException {
                ExecutorService executorService = Executors.newFixedThreadPool(1);
        Future<Integer> submit = executorService.submit(() -> {
            System.out.println("子线程开始执行...");
            return 10;
        });

        //TimeUnit.SECONDS.sleep(1);

        System.out.println(submit);

    }
输出:
java.util.concurrent.FutureTask@76fb509a
子线程开始执行...

原因:系统创建一个子线程是需要时间开销的,所以肯定主线程先打印了
-----------------------------------------------------
取消掉注释语句,输出:
开始执行...
java.util.concurrent.FutureTask@76fb509a

原因:创建子线程虽有时间开销,但不可能有1s之久
-----------------------------------------------------
注释加上,但把最后一句输出改为:System.out.println(submit.get()); 输出:
开始执行...
10

原因:get()方法是阻塞的,因此肯定得子线程完全结束后,才会继续主线程

使用多种方法,计算1至10000000的正整数之和?

1、forloop
2、多线程
3、线程池
4、ForkJoin
5、并行流

LockSupport有了解过吗?park()和unpark()方法呢?
说说Thread.join()方法的使用方式?怎么实现t1、t2并行,但它俩执行都完成后才让主线程执行呢?

说说eq和==的区别?==依赖于HashCode重写吗?HashMap和IdentityHashMap的区别在哪儿呢?

Java中基本数据类型占用字节数?位数呢?Long和double在64位的虚拟机上的线程安全问题有研究过吗?

byte 1字节
short 2字节
int 4字节
long 8字节
char 2字节(C语言中是1字节)可以存储一个汉字
float 4字节
double 8字节
boolean false/true(理论上占用1bit,1/8字节,实际处理按1byte处理)

JAVA是采用Unicode编码。每一个字节占8位。你电脑系统应该是 32位系统,这样每个int就是 4个字节 其中一个字节由8个二进制位组成

Map的put方法返回值是什么?什么时候会返回null呢?

返回null的情况有两种,请分别说出

书写一小段代码,怎么快速证明Long类型是64位的?

怎么证明int是32位的? Long的十进制最多多少位呢?(正数19位,负数20位,因为符号也是个字符)

说说intValue、valueOf、parseInt三方法的区别:

贴源码,一切尽在不言中

// intValue  返回的是基本数据类型
    public int intValue() {
        return value;
    }
    public long longValue() {
        return (long)value;
    }
    public double doubleValue() {
        return (double)value;
    }
//valueOf 返回的包装类型 我们发现valueOf方法是有缓存的,因此效率高。如果需要转化的是字符串,会先调用parseInt方法
public static Integer valueOf(String s) throws NumberFormatException {
        return Integer.valueOf(parseInt(s, 10));
    }
public static Integer valueOf(String s, int radix) throws NumberFormatException {
        return Integer.valueOf(parseInt(s,radix));
    }
    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
//parseInt 返回的int类型
    public static int parseInt(String s) throws NumberFormatException {
        return parseInt(s,10);
    }
public static int parseInt(String s, int radix)
                throws NumberFormatException
    {"较为复杂的代码"}

valueof调用了parseInt方法的,底层有依赖
因此如果只是想把字符串变为数字这么简单,那parseInt效率比valueof效率高
Integer a=new Integer(1);
Integer a=Integer.valueOf(1);
两个都是得到一个Integer对象,但是Integer.valueOf的效率高,开销更小。

如何优雅的设计一个流水号生生成器?位运算熟吗?

要求流水号有规律,但是又不能完全有规律,且应该包含一些有用信息,且要求效率高
问题:有一串数字5937594375973495743,怎么样可以快速的萃取出最后面指定位数的数字?请书写一个函数实现。(提示:使用按位与 & 的语法)

说说你对String 常量池的理解?举几个相等的例子?什么时候被放进去?intern()方法有什么用?常量池在JVM内存什么位置呢?常量池有哪三种?

String a = "计算机" + "软件"; 这句话常量池里会放几个
答案:由于JVM存在编译期优化,对于两个直接双引号声明的String的+操作,JVM在编译期会直接优化为“计算机软件”一个字符串。同String a = “计算机软件”,效果是一样的。
参考例子:java7,8中的String pool

字面量是会直接放在String pool中的,其他的你可以通过intern自己放入

一个list,怎么把它转换为数组?

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);

//方式一:只能转换为Object[]数组  请注意使用
String[] array= (String[]) list.toArray(); //java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;

//方式二
Integer[] ints = list.toArray(new Integer[0]); //这里面写0还是写几效果是一样的

//方式三  这种写法也是ok的
       Integer[] ints = new Integer[][list.size()];
        list.toArray(ints);
        System.out.println(ints);
//方式四:这种错误很隐蔽 请类型方便千万不要搞错了
        Long[] longs = list.toArray(new Long[0]);
        System.out.println(longs); //Exception in thread "main" java.lang.ArrayStoreException

//方式五:如果你用Object接受,就肯定不会有问题了。同toArray()方法
        Object[] objects = list.toArray(new Object[0]);
        System.out.println(objects); 
//方式六:其余自己循环遍历的方式 此处省略

说说你对java中守护线程的理解,怎么创建一个守护线程?可以有多个吗?

1、User和Daemon两者几乎没有区别,唯一的不同之处就在于虚拟机的离开(但凡只要还有一个User线程在运行,守护线程就不会退出)
2、daemonThread.setDaemon(true); (必须在start()方法调用之前执行这句话,否则会跑出一个IllegalThreadStateException异常)
3、在Daemon线程中产生新的线程也是守护线程

如你可以线程池中自定义ThreadFactory,然后t.setDaemon(true);那么线程池中所有的线程都是守护线程了。也就不用显示调用pool.shutdown();才能关闭线程池了,自己就会结束了

4、不要认为所有的应用都可以分配给Daemon来进行服务,比如读写操作或者计算逻辑(因为这样的话,主线程在推出之前,无法知道守护线程是否已经完成读写任务)

守护线程–也称“服务线程”,在没有用户线程可服务时会自动离开。

试过getName、getCanonicalName、getSimpleName的区别吗?

方法 值
getName my.ExternalClassConfig
getCanonicalName my.ExternalClassConfig
getSimpleName ExternalClassConfig
getName my.ExternalClassConfig$InternalConfig
getCanonicalName my.ExternalClassConfig.InternalConfig
getSimpleName InternalConfig

getName()返回的是虚拟机里面的class的表示,而getCanonicalName()返回的是更容易理解的表示。其实对于大部分class来说这两个方法没有什么不同的。但是对于array或内部类来说是有区别的。

方法                 值
getName            [Ljava.lang.String;
getCanonicalName   java.lang.String[]
getSimpleName      String[]

implements后面可以写多个吗?extends后面可以写多个吗?

现在我有一个长度为1 的Map,怎么最快速,最简便的代码把里面的Entry拿出来(key和value)

答案:

Map.Entry<String, String> next = map.entrySet().iterator().next();

这里面主要考的是JavaEE的基本功眨不扎实,能不能运用自如

请写出数组初始化的四种方式:

  1. 动态初始化:数组定义与为数组分配空间和赋值的操作分开进行;
  2. 静态初始化:在定义数字的同时就为数组元素分配空间并赋值;
  3. 默认初始化:数组是引用类型,它的元素相当于类的成员变量,因此数组分配空间后,每个元素也被按照成员变量的规则被隐士初始化;
  4. 看代码吧:利用Array.newInstance。。。
Integer[] integers = (Integer[]) Array.newInstance(Integer.class, 10);
System.out.println(integers.length); // 10

hashCode()与equals()的相关规定

如下例子什么结果?

    public static void main(String[] args) {
        // 备注:若Child类没有重写equals方法,结果是怎样的?
        Child child1 = new Child();
        Child child2 = new Child();
        System.out.println(child1 == child2); // false
        System.out.println(child1.equals(child2)); // false
    }

//由此可以看出,假若你没有重写hashCode()方法,equals比较也会是false的
  1. 如果两个对象相等,则hashcode一定也是相同的
  2. 两个对象相等,对两个对象分别调用equals方法都返回true
  3. 两个对象有相同的hashcode值,它们也不一定是相等的
  4. 因此,equals 方法被覆盖过,则 hashCode 方法也必须被覆盖(这算是一个规定)
  5. hashCode() 的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode(),则该 class 的两个对象无论如何都不会相等(即使这两个对象指向相同的数据)

finally块什么时候不会被执行?try里的return和finally的return返回值问题你理解吗?

  1. 在finally语句块第一行发生了异常
  2. 在前面的代码中用了System.exit(int)已退出程序。 exit是带参函数 ;若该语句在异常语句之后,finally会执行
  3. 程序所在的线程死亡。
  4. 关闭CPU。

关于try finally返回值问题:
如果try语句里有return,返回的是try语句块中变量值。 详细执行过程如下:
5. 如果有返回值,就把返回值保存到局部变量中;
6. 执行jsr指令跳到finally语句里执行;
7. 执行完finally语句后,返回之前保存在局部变量表里的值。
8. 如果try,finally语句里均有return,忽略try的return,而使用finally的return.

所以如下返回结果,一目了然吧:

    public static void main(String[] args) {
        System.out.println(fun()); //2  最终返回的是finally里的值,这点需要注意   try里面是不会被返回的
    }

    private static String fun() {
        try {
            return "1";
        } finally {
            return "2";
        }
    }

子类继承父类,构造方法问题

class Parent {
    // 不给无参构造
    public Parent(String a) {
    }
}

class Son extends Parent {

    public Son() {
    }

    public Son(String s) {
    }
}

报错吗?
答案:编译报错

Java 程序在执行子类的构造方法之前,如果没有用 super() 来调用父类特定的构造方法,则会调用父类中“没有参数的构造方法”。因此,如果父类中只定义了有参数的构造方法,而在子类的构造方法中又没有用 super() 来调用父类中特定的构造方法,则编译时将发生错误,
因为 Java 程序在父类中找不到没有参数的构造方法可供执行。解决办法是在父类里加上一个不做事且没有参数的构造方法,,所以上面可以两种方法解决编译报错:
1、给Parent一个空构造
2、显示调用父类无参构造

class Son extends Parent {

    public Son() {
        super("a");
    }

    public Son(String s) {
        super(s);
    }
}

字符型(char)常量和字符串常量(String)的区别

1 形式上: 字符常量是单引号引起的一个字符 字符串常量是双引号引起的若干个字符
2 含义上: 字符常量相当于一个**整形值( ASCII 值),**可以参加表达式运算 字符串常量代表一个地址值(该字符串在内存中存放位置)
3 占内存大小 字符常量只占2个字节 字符串常量占若干个字节(至少一个字符结束标志) (注意: char在Java中占两个字节)

    public static void main(String[] args) {
        char a = 'a';
        System.out.println(a); //a
        System.out.println((int) a); //97
        System.out.println(a + 10); //107   可以直接做加法运算

        String b = "b";
        System.out.println(b); //b
        System.out.println(b + "10"); //b10  进行了拼接
    }

在这里插入图片描述

请举几个例子,你认为是JDK的bug的问题

例子一:三目运算法的bug
    public static void main(String[] args) throws Exception {
        int i = true ? null : 0;
        System.out.println(i);
    }

这样编译不为null,感觉i可议赋值为null一样。但是运行时报错:

Exception in thread "main" java.lang.NullPointerException
例子二:java泛型的bug

比如常见的从MyBatis查出来的数据,类型匹配出错~~




SQL

1、MySQL聚合函数count(1) sum(1)结果返回0还是NULL?

  • count(1)或者count(*)
    • 返回为0:如果所查询的表或者where条件筛选后得到的结果集为空,则 count(1)返回为 0。如:
      • select count(id) from test;
      • select count(id) from test where id < 0;
    • 返回为NULL
      • 如果所查询的表或者where条件筛选后得到的结果集为空且当前层查询中使用了group by ,则 count(1)返回为 NULL 如:
        • select count(id) from test where id < 0 group by id;
      • 那那种情况,怎么让它返回0呢??? 使用函数:
        • SELECT COUNT(*) FROM ( 原来的SQL )
  • sum(1)
    • 返回为NULL
      • 如果所查询的表或者where条件筛选后得到的结果集为空 ,则 sum(1)返回为 NULL 如
        • select sum(id) from test where id < 0;
      • 那怎么解决呢?可以使用IFNULL函数(注意:上面count用IFNULL函数无效) 如:
        • select IFNULL(sum(id),0) from lp_student where id < 0;

常见异常信息如下:org.apache.ibatis.binding.BindingException: Mapper method 'com.xx.xx.xx.xx.xx.getCount attempted to return null from a method with a primitive return type (int).

2、count(1)和count(*)和count(列)有什么区别呢?

往常我经常会看到一些所谓的优化建议不使用Count(* )而是使用Count(1),从而可以提升性能,给出的理由是Count( *)会带来全表扫描。而实际上如何写Count并没有区别。

解释:
Count(1)和Count(*)实际上的意思是,评估Count()中的表达式是否为NULL,如果为NULL则不计数,而非NULL则会计数。比如我们看代码1所示,在Count中指定NULL(优化器不允许显式指定NULL,因此需要赋值给变量才能指定)

对于Count(列)来说,同样适用于上面规则

在这里插入图片描述

System.out.println("写得可还行?收藏再看吧,点个赞吧,分享下吧");
echo("关注公号【Java方向盘】 https://yourbatman.cn  https://wangpan.yourbatman.cn");
console.log("私聊【方向盘】:fsx1056342982");

我是方向盘(YourBatman、方哥):一个前25年还不会写Hallo World、早已毕业的大龄程序员。网瘾失足、清考、延期毕业、房产中介、保险销售、送外卖…是我不可抹灭的黑标签

  • 🎓2013.07 清考、毕业答辩3次未通过、延期毕业
  • 🏷2013.08-2014.07 宁夏中介公司卖二手房1年,毕业后第1份工作
  • ️️🏷2014.07-2015.05 荆州/武汉,泰康人寿卖保险3月、饿了么送外卖2月,还有炸鸡排、直销等第2345份工作
  • 🏷2015.08 开始从事Java开发,闯过外包,呆过大厂!多年架构经验,任基础架构/中间件团队负责人
  • 🏷2021.08 因“双减政策”失业!历经9面,终获美团外卖L8的offer
  • 🙅🏻‍♀️Java架构师、Spring开源贡献者、CSDN博客之星年度Top 10、领域建模专家、写作大赛1/2届评委
  • 📚将出版书籍《Spring奇淫巧技》,致力于国内zui好、zui具深度、zui实用的专栏,为市场贡献微薄之力
  • 现在写纯粹技术专栏(公号后台回复专栏列表),不哗众取宠。如果你也有共鸣,可加我好友(fsx1056342982)一起进步

在这里插入图片描述

  • 0
    点赞
  • 0
    评论
  • 5
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 博客之星2020 设计师:CY__ 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值