Java基础知识

面向过程和面向对象

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

java 特点

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

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

JDK:Java开发工具包

JRE:Java运行环境

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

JRE包含JVM和JAVA的核心类库
JAVA 与C++比较

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

重写和重载

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

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

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

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

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

自动装箱和拆箱

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

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

接口和抽象类的区别

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

成员变量和局部变量

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

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

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

==与equals()

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

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

hashcode 和equals

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

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

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

oracle 查询那些表锁

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

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

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

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

线程和进程

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

进程是程序执行的基本单位，线程是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 !);                     }                 });             }         }     } }

final

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

异常处理

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

Java序列化是不想序列的变量添加transient关键字修饰，只能修饰变量，不能修饰方法和类
键盘输入变量的值的两种方式：

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

Java 中的IO流

Java I0 流的 40 多个类都是从如下 4 个抽象类基类中派生出来的。
- InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
- OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。