java基础测试2_输入与枚举类 'basiccolors' 的成员不对应-优快云博客

本文链接：https://blog.youkuaiyun.com/politeness__/article/details/108757315

一、简答题（每题3分，共计60分）

请至少写出五个常用的java命令。

javac
Java
javadoc
jar
javap //Java class文件分解器,可以反编译,也可以查看
java 编译器生成的字节码等

package 是关键字吗？并简述它的作用。

是关键字

避免命名冲突
Throwable定义的关键字是什么?这个类型的作用是什么？

定义关键字 class

是产生所有异常的类
请简述this关键字的作用
指代当前类的对象

区别成员变量和局部变量

调用类中的其他方法

调用类中的其他构造器
那些关键字不能和abstract关键字连用。

private、static、final
现在有类A，类A内有一个静态内部类B，类C继承类A，且类C内也有一个
静态内部类B，那么这样两个静态内部类是否够构成了重写？
如果是请说明理由，如果不是也请说明理由。

不是类就不能存在重写的概念而且内部类的命名空间是外部类，
也就是说类A的静态内部类类名应该是A $B 而类 C 的内部类的类名应该是 C$ B
在子类中能否重写父类构造器，如果能请说明理由；如果不能也请说明理由。

不能因为重写的前提是继承但是构造器并不能被继承。
super(a) 调用父类有参构造器
为什么List集合和Set集合可以使用迭代器遍历而Map集合不行。

因为List和Set继承接口Collection 而接口Collection继承Iterable
在该接口中定义了获取迭代器的方法，
但是Map集合并没有继承接口Iterable
请声明一个静态的最终的泛型方法

public static final void tt(T t){

}
有一个枚举类型Color 能不能写一个SubColor类型去继承枚举类型Color，
如果能请说明理由，如果不能也请说明理由。

不能因为枚举类型本质上是一个final修饰的类所以不能写子类去继承
请简述泛型擦除的概念。
List list=new ArrayList<>();
泛型类型仅存在于编译期间，编译后的字节码和运行时不包含泛型信息，
所有的泛型类型映射到同一份字节码。
(创建一个集合，定义泛型，映射的就是集合的字节码)
HashSet集合的特点是不可重复且无序的，这里的无序指的是什么？
又是如何实现不可重复功能的。
传入的顺序和取出的顺序不一致
不可重复的功能是依靠equals方法实现的。
获取Class对象的方式有几种？分别用于什么场景。

三种
1. 类型.class 适用于任何类型的class对象获取
2. Class.forName()适用于接口和类类型的Class对象的获取，传一个类名或接口名
3. 对象.getClass() 只适用于类类型
创建一个线程之后调用run（）方法和调用start（）方法的区别。

调用run（）方法只是简单的方法调用并不会有新的线程创建，
是有执行方法调用的线程去执行run（）里边的代码。start()方法则是启动一个新的线程。
什么是精灵线程？setDaemon(true)；

这种线程是用来给前台线程服务的，给前台线程提供一个良好的运行环境，
地位比较低，JVM是否停止运行，根本不关心后台线程的运行情况和状态。
请简述sleep()方法和wait()的区别？

sleep（）方法是Thread类里边的方法

wait()方法是Object类的方法

sleep()方法不释放锁，wait()方法会释放锁
sleep()可以设置睡眠时间，wait()方法可以设置时间，也可以调用notify方法唤醒
静态方法上加上synchronized关键字修饰是保证线程同步的前提，
那么这里是以那个对象来当锁的？

*当前类的Class对象
InputSreamReader属于字节流还是字符流？它的作用是什么？
转换流，属于字符流，作用是字节流转换成字符流
简述序列化与反序列化？
序列化：对象转换为字节
反序列化，字节重构为对象
简述TCP和UDP协议的区别？
Tcp 面向连接，效率稍低，安全性高，三次握手：建立连接，形成传输通道，传输数据
UDP 面向无连接，效率高，安全性低

二、程序分析题（每题4分,共计40分）

分析以下代码的运行结果

public enum Color extends Thread{

 public void  run(){
  System.out.println(Thread.currentThread().getName());
 }
 public static void main(String [] args)
 {
  Color c= new Color("java");
  c.run();
 }
 public Color(String name){
  super(name);
 }

}

//编译报错，因为枚举已经继承了java.lang.Enum类
//枚举类默认final修饰，不能被继承

分析以下代码的运行结果

public static void main(String [] args)
 {
  System.out.println(1&2);
  System.out.println(1|2);
  System.out.println(~2);
  System.out.println(~-2);

 }

//0
//3
//-3

//0001&0010  0
//0001|0010  3


//0000 0010
//1111 1101
//-1
//1111 1100
//1000 0011  -3


//1000 0010
//1111 1101
//+1
//1111 1110
//0000 0001  1

分析以下代码的运行结果

 public static void main(String [] args)
 {
  int a=20;
  
  a=(new Integer(127)==new Integer(127)&&((13>>2)>3|a++==20))==(a>>>2>3)?~a:1^a;
  System.out.println(a);

 }

//0000 0001
//0001 0101				1^a
//0001 0100				相同为0，不同为1；
  
//21
//>>>是无符号右移和>>有符号右移

分析以下代码的运行结果

 public static void main(String [] args)
 {
  ArrayList<String> list = new ArrayList<>();
  list.add("tom");
  list.add("lily");
  list.add("Maggie");
  list.add("admin");
  list.sort((o1,o2)->o1.length()-o2.length());
  for (int i = 0; i < list.size(); i++) {
   System.out.println(list.get(i));
  }
 }
//tom
//lily
//admin
//Maggie

分析以下代码的运行结果

 public static void main(String [] args)
 {
  String [] str={"23","abc",null};
  for (int i=0;i<str.length;i++){
   try {
    int j = Integer.parseInt(str[i]);
    System.out.println(j);

   }
   catch (NullPointerException e){
    System.out.println("NullPointerException:"+str[i]);

   }catch (NumberFormatException e1){
    System.out.println("NumberFormatException:"+str[i]);
   }
  }
 }


//23
//NumberFormatException:abc
//NumberFormatException:null

分析以下代码运行结果

public static void main(String [] args)
 {
   String s=new String("abc"){};
   String s1=new String("abc"){};
   System.out.println(s==s1);
 }

//编译报错   因为String为final修饰的类，{}为匿名内部类,final修饰的类不能被继承

在以下代码的注释处为下面一行的代码添加合适的注释

 public static void main(String [] args) throws Exception {
        Class<?> class1 = Object.class;
        //注释处
        Constructor<?> constructor = class1.getDeclaredConstructor();
        //注释处
        constructor.newInstance();
        //注释处
        Field[] fields = class1.getDeclaredFields();
        //注释处
        Method[] methods = class1.getDeclaredMethods();
    }

  //反射通过对象获得所有构造器，包括私有构造器
  //反射通过构造器创建对象
  //反射通过对象获得所有属性包括私有属性
  //反射通过对象获得所有方法包括私有方法

分析以下代码的运行结果

public class Color<T>{

    public static void main(String [] args)  {
       Color.mathod(new String());
    }
    static  void mathod(T t){
        System.out.println(t.getClass());
    }
}
//编译报错   静态方法不能引用类的泛型

//   要引用必须自己声明
//   可改为  static <T> void mathod(T t){

java中的方法调用有一种情况称为递归,就是一个方法内部再调用自己,
同时提供一个退出方法条件即可.有如下代码
Test.java中:
main:
Test t = new Test();
int sum = t.go(100);
System.out.println(sum);

public int go(int i){

}

要求:
1.在go方法内部完成代码
2.实现从1累加到100的和
3.go方法内部的所写的代码不能超过俩句，注意一个分号就是一句代码。
```
     if(i==1) return  i；

     return  i+go(i-1);

//go方法里每次都调用go方法 
```
分析以下代码的运行结果：

package com.briup.test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

class Father{
    static {
        System.out.println("html");
    }
    void show(){
        System.out.println("css");
    }

    public static void main(String [] args)  {
        Father f= new Son();
        f.method();
        f.show();
    }
    static  void method( ){
        System.out.println("oracle");
    }
}
class Son extends  Father{
    static  void method( ){
        System.out.println("java");
    }
    {
        System.out.println("xml");
    }
    Son(){
        System.out.println("Jquery");
    }
    void show(){
        System.out.println("js");
    }
}

//html
//xml
//Jquery
//oracle		静态的不能重写，能继承 
//js			重写了show方法