Java基础知识

1. 面向过程和面向对象

面向过程性能高，面向对象易维护，易复用，易扩展。

2. java 特点

• 面向对象（封装，继承，多态）
• 平台无关性
• 安全可靠
• 支持多线程

3. JVM:Java 虚拟机，是运行 Java 字节码（.class文件）的虚拟机。

   JDK:Java开发工具包

   JRE:Java运行环境

   关系：JDK包含JRE和JAVA的开发工具

   ​ JRE包含JVM和JAVA的核心类库

   

4. JAVA 与C++比较

• 都是面向对象的语言，都支持封装、继承和多态。
• Java 不提供指针来直接访问内存，程序内存更加安全
• Java 的类是单继承的，C++ 支持多重继承；虽然 Java 的类不可以多继承，但是接口可以多继承。
• Java 有自动内存管理机制，不需要程序员手动释放无用内存。

5. 重写和重载

重写：子类重新编写父类的方法，方法名相同，参数相同。

重载：方法名相同，参数不同

6. 面向对象的特点：抽象，封装，继承，多态
7. String:不可变的 （可变的含义：指针是否指向新的对象）

​ StringBuilder：可变的，线程不安全，可在单线程中使用

​ StringBuffer： 可变的，线程安全，多线程中使用

8. 自动装箱和拆箱

装箱就是 自动将基本数据类型转换为包装器类型；拆箱就是 自动将包装器类型转换为基本数据类型。

Integer i = 10;  //装箱
int n = i;   //拆箱

9. 接口和抽象类的区别

• 接口的方法默认是 public，所有方法在接口中不能有实现，而抽象类可以有非抽象的方法。
• 一个类可以实现多个接口，但只能实现一个抽象类。
• 抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。
• 接口中基本数据类型为static 而抽类象不是的。

10. 成员变量和局部变量

成员变量是属于类的，而局部变量是在方法中定义的变量或是方法的参数；成员

变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所

修饰；但是，成员变量和局部变量都能被 fifinal 所修饰。

11. ==与equals()

== : 它的作用是判断两个对象的地址是不是相等。

equals() : 它的作用也是判断两个对象内容是否相等

12. hashcode 和equals

两个obj，如果equals()相等，hashCode()一定相等

两个obj，如果hashCode()相等，equals()不一定相等

HashSet 检查重复 ：先获取hashcode 如果相等，再用equals（) 比较

12. oracle 查询那些表锁

    select * from v$locked_object a, dba_objects b where b.object_id=a.object_id
    

13. 值传递（值调用）和引用传递（引用调用）

值传递是对基本型变量而言的,传递的是该变量的一个副本,改变副本不影响原变量. 引用传递一般是对于对象型变量而言的,传递的是该对象地址的一个副本, 并不是原对象本身 ，所以一个方法可以修改引用传递所对应的变量值，而不能修改值传递所对应的变量值。

一般认为,java内的传递都是值传递

14. 线程和进程

一个进程可以包含多个线程。

进程是程序执行的基本单位，线程是cpu调度的基本单位。
一般来说，
进程是为了程序的并发执行，线程是为了并发的执行程序！

进程是操作系统资源分配的基本单位，而线程是任务调度和执行的基本单位。

线程的状态：

影响线程的方法：

https://blog.csdn.net/Andya_net/article/details/106206807

package com.company;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class Mianshi extends  Thread{

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CreateThread createThread = new CreateThread();
        createThread.start();

        NewThread newThread = new NewThread();
        newThread.run();
        Thread thread = new Thread(newThread);
        thread.start();
        
        CreateThreadByOtherWay chy =new CreateThreadByOtherWay();
        chy.CallableThread();

        BasicThreadPool basicThreadPool = new BasicThreadPool();
        basicThreadPool.ThreadPool();

    }


    //继承Thread类
    public static class CreateThread extends Thread{

        @Override
        public void run() {
            System.out.println("通过thread创建了一个线程");
        }
    }

    //实现Runnable接口
    public static class NewThread implements Runnable{
        @Override
        public void run() {
            System.err.println("通过接口Runnable创建线程");
        }
    }

    //通过ExecutorService 和Callable<T>实现有返回值的线程
    public static  class  CreateThreadByOtherWay implements Callable<String> {
        private String num;
        public CreateThreadByOtherWay(String num){
            this.num =num;
        }
        public CreateThreadByOtherWay(){

        }

        @Override
        public String call() throws Exception {
            return num;
        }

        public  void CallableThread () throws ExecutionException, InterruptedException {
            ExecutorService pool = Executors.newFixedThreadPool(5);
            List<Future> list = new ArrayList<>();

            for (int i = 0; i < 10; i++) {
                Callable<String>  chy = new CreateThreadByOtherWay(i+"yyds");
                Future<String> future = pool.submit(chy);
                list.add(future);
            }
            for (Future<String> f:list
            ) {
                System.err.println(f.get());
            }
        }
    }

    //基于线程池创建
    public static class BasicThreadPool {
        public void ThreadPool() {
            ExecutorService threadPool = Executors.newFixedThreadPool(10);
            for (int i = 0; i < 10; i++) {
                threadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println(Thread.currentThread().getName() + " is running !");
                    }
                });
            }
        }
    }
}

15. final

• final 修饰的类无法被继承
• final 修饰的方法无法被重写
• final 修饰的基本类型变量，一旦在初始化之后便不能更改。
• final修饰的实例变量一般添加static修饰 变成静态的

15. 异常处理

• Throwable是所有错误或异常的父类

• 异常和错误的区别：异常能被程序本身处理，错误是无法处理。

• Throwable 类常用方法： getMessage():返回异常发生时的详细信息，toString():返回异常发生时的简要信息getLocalizedMessage()：返回异常对象的本地化信息，printStackTrace() 在控制台上打印Throwable对象封装的异常信息

• 异常处理方式：抛出异常、使用try catch finally捕获并处理异常。finally：无论是否捕获或处理异常，fifinally 块里的语句都会被执行。当在 try 块或 catch 块中遇到 return 语句时，fifinally 语句块将在方法返回之前被执行

• throw和throws的区别：

  位置不同：throws作用在方法上，后面跟着的是异常的类；而throw作用在方法内，后面跟着的是异常的对象

  功能不同: throws用来声明方法在运行过程中可能出现的异常，throw用来抛出封装了异常信息的对象

• 常见面试题：[https://blog.csdn.net/ThinkWon/article/details/104390689](https://blog.csdn.net/ThinkWon/article/details/104390689

16. Java序列化是不想序列的变量添加transient关键字修饰，只能修饰变量，不能修饰方法和类

17. 键盘输入变量的值的两种方式：

方式一：
Scanner input = new Scanner(System.in); 
String s = input.nextLine(); 
input.close();
方式二：
BufferedReader input = new BufferedReader(new InputStreamReader(System.in)); 
String s = input.readLine();    

18. Java 中的IO流

    

    Java I0 流的 40 多个类都是从如下 4 个抽象类基类中派生出来的。

    • InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
    • OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。

15. 深拷贝和浅拷贝

浅拷贝：对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝，此为浅拷贝。

深拷贝：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容。

15. 集合和工具类