java基础回顾java基础回顾，内容很多，但是很基础。主要论述了集合，IO流，异常，线程，静态等基本用法。是基础中的

一、填空题

Java的原始数据类型包括：int，short，long，byte，char，boolean，float，double
java的代码风格：包名使用小写字母，类名的命名要首字母大写
int a=2，int b=a++，int c= ++a;则b等于2，c=4
String name=5!=2?"张三"：“李四"；name的值是张三
数组创建后其大小不可改变
List接口的特点是具备索引值，可采用普通for循环遍历；能够存储重复元素；存储的元素可以重复；存储的顺序就是遍历的顺序；Set接口的特点是不能存储重复元素，遍历的顺序未必是存储的顺序；Map接口的特点是元素是双列，其中value可以重复，key不可以重复
java中所有的错误都继承自 Throwable 类,在该类的子类中，Error类表示严重的底层错误，对于这类错误一般处理方式是改代码或改元件，Exception类表示异常，可以定义正对性的处理方式对这种情况进行处理
final修饰变量，则这个变量必须是常量，而且不可改变；修饰类，则该类不能被继承；修饰方法，则方法不能被重写
多态应用的前提是（有关系，继承关系或实现关系），好处是（提高了代码的维护性和扩展性）
创建线程的两种方式分别为（继承Thread类），（实现Runable接口）

二、选择题

下列语句的输出结果是（a）
```
System.out.println(5+7+"tarena"+5+7);
```
A. 12tarena57 B.57tarena12 C.57tarena57 D.12tarena12

下列代码块中，循环执行的次数是（c）

public static void main(String[]args){
    int word=27;
    do{
        word--;
    }while(word<=18);
}

A.9次 B.0次 C.1次 D.超过9次

下列语句会造成数组new int[10]越界的是（d）

A.a[0]+=9 B.a[9]=10 C.-a[9] D.for(int i=0;i<=10;i++) a[i]++;
请看下列代码编译和运行的结果是（b）

public class Demo{
    public static void main(String[]args){
        new Thread(new C()).start();
    }
}
class C implements Runable{
    public void run(){
        for(int a=3;a<=10;a+=2){
            if(isPrime(a)){
                System.out.println(a+"");
            }
        }
    }
    private boolean isPrime(int a){
        boolean flag=true;
        for(int i=2;i<a-1&&flag;i++){
            if((a%i)==0){
                flag=false;
            }
        }
        return flag;
    }
}

A.输出 2,4,6 B. 输出3,5,7 C. 输出3,6,9 D.输出2,5,8

三、简答题

分析以下代码是否能编译通过？如果编译不通过，为什么？如何修改？修改后，结果是什么

class Person{
    public Person(int x){
      System.out.println("person run"+x);
    }
}
class Son extends Person{
    public Son(int x){
        System.out.println("son run"+x);
    }
}
public class ExtendDemo{
    public static void main(String[]args){
	Son son=new Son(5);
	}
}

答：不能通过，修改后代码如下

class Person{
        public Person(int x){
            System.out.println("person run"+x);
        }
    }
    class Son extends Person{
        public Son(int x){
            //子类构造方法第一行代码必须是super
            super(x);
            System.out.println("son run"+x);
        }
    }
    public class ExtendDemo{
        public static void main(String[]args){
            Son son=new Son(5);
        }
    }

结果

person run5
son run5

简述抽象类和接口的异同？

相同点

1.都不能实例化,都不能创建对象 
2.都可以有抽象方法 
3.都是为了当父类 
4.都为多态、代码复用提供了基础 
5.都为大型项目的开发提供了约束

不同点

1.抽象类关键字是class;接口的关键字是interface 
2.抽象类的方法可以有普通方法;接口的方法全是抽象方法 
3.抽象类有构造方法;接口没有构造方法 
4.抽象类是单一继承;接口之间可以多继承 
5.抽象类成员变量可以是普通成员变量;接口中的成员变量都是静态常量，被final和static修饰 
6.抽象类的方法可以使用public、protected;接口中的方法只能使用public修饰 
7.抽象类是继承关系，关键字是extends;接口是实现关系，关键字是implements 
8.一个类继承了抽象类，只需重写抽象方法;一个类实现了一个接口，必须实现接口中的所有方法 
9.子类和抽象类的关系是is a 的关系。实现类和接口的关系是have a的关系

有如下代码（不全）

public static void main(String[]args){
	List list=new ArrayList();
    list.add("Hello");
    list.add("World");
    list.add(1,"Learn");
    list.add(1, "java");

printList(list);
}
public static void printList(List list) {
   // 1 全部代码如下
for(Object s:list){
    System.out.println(s);
	}
    }


}

要求：

1）把//1处的代码补充完整，要求输出list中所有元素的内容

//补充代码
for(Object s:list){
    System.out.println(s);
}
//输出结果
Hello
java
Learn
World

2）如果把实现类由ArrayList换为LinkedList，应该改哪里？ArrayList和LinkedList使用上有什么区别？实现上有什么区别？

答：直接将ArrayList换为LinkedList，ArrayList底层数据结构是数组，有索引，适合遍历和查找，不适合插入和删除；LinkedList底层数据结构是双向循环链表，适合插入和删除，不适合历和查找，线程不安全

静态代码块的特点？

1.静态代码块随着类的加载而加载，而且先于静态方法执行，无论位置如何。 
2.静态代码块只执行一次，即只有在类第一次加载的时候运行 
3.静态代码块能访问静态成员变量，且在静态成员变量显式初始化后执行

简述什么是多态？（重点论述多态的使用规则）

多态：一个引用在不同情况下的多种状态，即任何一个子类对象都可以赋值给父类的引用，父类的引用调用方法的运行结果不确定。

使用规则：前提是必须有继承关系或实现关系（接口讲实现）；
具体规则如下：
1.父类有，子类无,则调用父类 
2.父类有，子类重写,则调用子类 
3.父类无，子类有,则编译失败 
4.父类的引用只能调用自己的成员

Thread 类中的 start（）和 run（）方法有什么区别？

调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行。这两个方法应该都比较熟悉，把需要并行处理的代码放在run()方法中，start()方法启动线程将自动调用 run()方法，这是由jvm的内存机制规定的。并且run()方法必须是public访问权限，返回值类型为void。

四、编程题

IO流拷贝一个mp3文件到指定位置

public class CopyVedio {
     public static void main(String[] args) throws FileNotFoundException,IOException {
		long start = System.currentTimeMillis();
		//1.指定字节输入流的源头
		FileInputStream fis = new FileInputStream("E:\\io定义及基本体系.mp4");
		//2.指定字节输出流的目的
		FileOutputStream fos = new FileOutputStream("E:\\io定义及基本体系(1).mp4");
		//3.创建字节流缓冲数组
		byte[] cbuf = new byte[1024];
		//4.循环读取并写入
		int len = 0;
		while((len = fis.read(cbuf))!=-1) {
			fos.write(cbuf,0,len);
		}
		//5.关闭资源
		fos.close();
		fis.close();
		long end = System.currentTimeMillis();
        //没有使用高效流，查看执行的毫秒数
		System.out.println("系统的执行时间是:"+(end-start));
    }
}

什么是单例？以及单例模式的控制代码（懒汉，饿汉单例设计模式都可以）

单例：内存中只有该类的一个实例，即只有一个对象的设计模式，作用是保证对象的唯一性（Servlet就是单例的）。

饥汉模式

class Singleton{
    
    //1.构造器私有化
    private Singleton(){
        
    }
    //2.在内部创建对象，成员变量
    private static final Singleton s=new Singleton();
    //3.创建一个公共方法返回对象
    public static Singleton getResult(){
        return s;
    }
 
}
 //4.验证
 public class test{
    public static void main(String[]args){
		Singleton s1=Singleton.getResult();
        Singleton s2=Singleton.getResult();
        System.out.println(s1==s2);//验证两者是否相同，结果是true则证明只创建了一个对象；false则证明创建了两个对象
	}
}

写出jdbc连接数据库的代码(以查找user表中的所有数据为例)

user表的结构

字段名称	类型	含义
id	int	主键
name	varchar（20）	姓名
department	varchar(40)	所在部门
age	int	年龄

public class SelectAll {
    public static void main(String[] args) {
        Connection conn=null;
        PreparedStatement ps=null;
        ResultSet rs=null;

        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            String url="jdbc:mysql://localhost:3306/mydb";
            String user="root";
            String pwd="js199803";
            conn= DriverManager.getConnection(url,user,pwd);
            String sql="select * from student";
            ps=conn.prepareStatement(sql);
            rs = ps.executeQuery();
            while(rs.next()){
                int id=rs.getInt(1);
                String name = rs.getString(2);
                String department = rs.getInt(3);
                int age = rs.getInt(4);
               

                System.out.println(id+" "+name+" "+department+" "+age);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (rs!=null) {
                    rs.close();
                }
                if (ps!=null) {
                    ps.close();
                }
                if (conn!=null) {
                    conn.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }



    }
}

编写一个冒泡排序算法

public class Bubble_sort {
	public static void main(String[] args) {
		// 冒泡排序思想:两两比较，如果他们的顺序错误就把他们交换过来。每一次循环找出一个最大或最小的数据。
		// 最坏时间复杂度：n^2
		// 最优的时间复杂度：n
		// 稳定性：稳定。主要看是否相邻的两个数进行了两两比较
		
		int[] array = { 10, 31, 2, 23, 23, 1, 5, 4 };
		int temp = 0;//临时变量
		for (int i = 0; i < array.length-1; i++) {//趟数  n
			int count = 0;
			for (int j = 0; j < array.length-1-i; j++) {//每趟比较的次数  n
				//升序排列的条件就是两两相邻的数进行比较，如果array[i]>array[i+1],互换位置
				if(array[j]>array[j+1]){//1
					temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
					count++;
				}
			}
			if(count==0){
				break;
			}
		}
		System.out.println(Arrays.toString(array));
	}
}

五名同学在校园内共同发200张传单，打印每个同学所发传单信息，并确保信息无误

public class Ticket {
    
    public static void main(String[] args) {
        Ticket1 ticket = new Ticket1();
        //创建5个线程，注入对象
        new Thread(ticket,"Student1").start();
        new Thread(ticket,"Student2").start();
        new Thread(ticket,"Student3").start();
        new Thread(ticket,"Student4").start();
        new Thread(ticket,"Student5").start();
    }
}

//静态代码块,实现Runnable接口
//运行结果可能显示单线程，但是只要达到一定数量级，就一定能看到多线程

class Ticket1 implements Runnable {
    private int t = 200;
    private Object object = new Object();

    @Override
    public void run() {
        for (int i = 1; i <= 200; i++) {
            synchronized (Ticket.class) {
                if (t > 0) {
                    System.out.println(Thread.currentThread().getName() + "已发传单号" + t);
                    t--;
                }
            }
        }
    }
}

java基础 回顾

java基础回顾