基础也是Java面试里最基本的考查~ 下面就以我遇到的较为常见的点来整理，比较零散，仅供参考。
1、switch……case
要注意case之间要用break来分隔，否则将会一直执行下去直到有break的地方：
public static void switchTest(int i) {
switch(i) {
case 1:
System.out.println("============1");
break;
case 2:
System.out.println("============2");
// break;
case 3:
System.out.println("============3");
break;
default:
System.out.println("==========more");
}
}
case 2的时候，break是注释的，此时调用：
for(int i=0; i<5; i++) {
switchTest(i);
}
打印结果为：
==========more
============1
============2
============3
============3
==========more
default为所有case都不满足的时候走的逻辑；因为case 2的时候没有break，所以case 2的时候走完2的逻辑也会走case 3的逻辑。而如果把注释的break放开，打印结果将会是：
==========more
============1
============2
============3
==========more
注意：在jdk1.7+后，case里不仅支持整型，也支持字符串。当case判断条件为整型且为变量时，需注意该变量一定是final int的~
2、Java异常处理机制
1）异常的分类
Java中用Throwable类代表异常，而Throwable类会派生出Exception和Error两个子类。
Error（错误）:是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题；
Exception（异常）:是程序本身可以处理的异常。
运行时异常：都是RuntimeException类及其子类异常，也称非检查异常，是指在编译期间，不检查这类异常是否捕获。如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。
运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。
非运行时异常 （编译异常）：是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常。
throw主动抛出异常；throws声明异常（在方法定义上），则调用此方法的地方必须捕获或者继续throws~
2）需要注意的点
2.1：如果一段代码用try{} catch(){} 包围起来，就算发生了异常，但catch后面的代码还是会执行；如果在for循环中，try catch把整个for都包起来，那么循环到某次发生异常时，整个循环就会中断；如果把try catch写在for里面包围每次循环的内容，那么本次如果发生异常将不会影响整个循环的继续进行。
2.2：try后面可以跟多个catch，最好在所有特殊异常最后写一个顶级的父类异常：Exception必须写在最后，其子类写在前面。当所有子类异常都没有catch到它时，就会进入Exception的分支。
2.3：当try catch finally遇上return
原则：任何执行try 或者catch中的return语句之前（无论try或catch里面有没有被return掉），都会执行finally语句，如果finally存在的话。 如果finally中有return语句，那么程序就以finally里的return为准，否则以try或catch里的return为准。
public static void main(String[] args) {
System.out.println("调用结果：" + test());
}
static int test()
{
int x = 1;
try
{
x++;
System.out.println("x:" + x);
System.out.println(x/0);
return x;
} catch(Exception e) {
e.printStackTrace();
return 0;
}
finally
{
++x;
System.out.println("x:" + x);
// return x;
}
}
打印结果为：
x:2
java.lang.ArithmeticException: / by zero
at com.nineclient.Test5.test(Test5.java:17)
at com.nineclient.Test5.main(Test5.java:6)
x:3
调用结果：0
而把finally的注释放开，结果为：
x:2
java.lang.ArithmeticException: / by zero
at com.nineclient.Test5.test(Test5.java:17)
at com.nineclient.Test5.main(Test5.java:6)
x:3
调用结果：3
说明以finally的return为准了。而如果这样：
static int test()
{
int x = 1;
try
{
x++;
System.out.println("x:" + x);
return x;
} catch(Exception e) {
e.printStackTrace();
return 0;
}
finally
{
++x;
System.out.println("x:" + x);
}
}
打印结果为：
x:2
x:3
调用结果：2
说明即时try里已经return了。finally里的代码还是会继续执行的~但是finally里的++x并不会影响最终return的值，虽然x此时变成3了，但是return的时候还是try里第一次x++后的值。
3、String
1）基本
java.lang.String类的实例用于封装一个字符序列，字符串对象为“不变对象”，一旦对字符串进行修改操作，会创建新的对象。Java中允许我们将一个字面量赋值给字符串引用类型变量，处于性能的考虑，Java对字面量产生的字符串进行了缓存，将他们缓存在字符串的常量池中，对于重复出现的字面量赋值，JVM会先查找常量池中是否存在这个字符串，有就直接引用，减少字符串对象的创建，节省内存资源。
String s = new String("abc");//创建了2个对象，内容都是"abc"：一个在字符串常量池，一个在堆里。s只是对象的引用，下同
String s1 = "abc";//s1指向字符串常量池里内容为"abc"
String s2 = new String("abc");//创建了1个对象，在堆里，内容指向堆里的"abc"
String s3 = "abc";//s3指向了字符串常量池里内容为"abc"，跟s1一样都指向池里的相同内容
System.out.println(s == s1);//false
System.out.println(s == s2);//false
System.out.println(s1 == s2);//false
System.out.println(s1 == s3);//true
System.out.println();
String o = "o";
String k = "k";
String ok = "ok";
System.out.println(ok == "o" + k);//false, "o"+k会在堆里新生成一个对象
System.out.println(ok == "o" + "k");//true, 都是在常量池里，相加也是返回池里的"ok"
System.out.println(ok == o + k); //false
2）String的封装类
StringBuilder和StringBuffer都是String的封装类，对于字符串的操作建议用这个
StringUtils.countMatch(String str, String subStr);//统计subStr在str里出现的次数
StringBuilder：线程非安全的
StringBuffer：线程安全的
String test = "Today" + "is" + "sunny"; String test2 = "Todayissunny"; String t1 = "Today"; String t2 = "is"; String t3 = "sunny"; System.out.println(test == test2);//true System.out.println(test == (t1+t2+t3));//false
4、基本类型的包装类
数值型：整型—— byte(8位)<short(16位)<int(32位)<long(64位)（按所占字节数从小到大排列，数值范围-2n~2n-1 n为幂） 1字节=8位
浮点型：float(32位)<double(64位) 定义float类型时，如果值是非整数，则需加f后缀。可以将float类型的值赋给double型的变量，反之则不行~
文本型：char——字符常量为单引号括起来的单个字符
布尔型：boolean——true/false
public static void main(String[] args) {
Integer a = 1;
int b = 1;
Integer c = 1;
Integer d1 = new Integer(1);
System.out.println(a == b);//true, a会自动"拆箱"变成int
System.out.println(a ==c);//true
System.out.println(a ==d1);//false,因为d1指向的是通过new出来的值
//需注意：在通过valueOf方法创建Integer对象的时候，如果数值在[-128,127]之间，
//便返回指向IntegerCache.cache中已经存在的对象的引用；否则创建一个新的Integer对象
//所有整型都同理(Byte,Short,Long),有自己的cache范围~
Integer a1 = 200;
Integer b1 = 200;
System.out.println(a1 == b1);//false
System.out.println();
//在某个范围内的整型数值的个数是有限的，而浮点数却不是。所以每次都会创建一个新的Float对象
//所有浮点类型都同理(Double)
Float f = 1.0f;
float f1 = 1.0f;
Float f2 = 1.0f;
double d = 1.0;
System.out.println(f == f1);//true
System.out.println(f == f2);//false,两个对象 都是Float
System.out.println(f1 ==d);//true,double自动转型成float
System.out.println();
Boolean bool1 = true;
Boolean bool2 = true;
System.out.println(bool1 == bool2);//true
}
double/float在计算时会有舍入误差，想要得到更加精确的结果，可以使用java.math.Bidecimal
add(), subtract(), multiply(), divide()
5、集合
1）接口
Java的集合框架用Collection顶级接口来表示，该接口又派生出List和Set两个接口。
List：规定了子类实现的特征为有序且元素可重复，常用实现类有ArrayList和LinkedList。ArrayList使用数组实现，所以更适合读取存储的数据；LinkedList使用链表实现，所以更适合插入、删除元素。
Set：规定了子类实现的特征为无序且元素不可重复。常用实现类有HashSet和TreeSet。HashSet使用散列算法实现的Set集合，而TreeSet则使用二叉树算法实现。
2）集合转为数组
Set<String> set = new HashSet<String>();
set.add("3");
set.add("1");
set.add("1");
set.add("2");
//集合转为数组，list和set都有这个语法
String[] arr = (String[]) set.toArray(new String[0]);
System.out.println(Arrays.toString(arr));//[3, 2, 1]
数组转为集合：Arrays.asList(数组);
3）排序
Collections.sort(list);//一般用于数值排序
Collections.sort(Collection c, Comparator cc);//new Comparator 则必须实现方法compare(T o1, T o2)
4）Map
key不能为空且不能重复。
containsKey(Object key)——查看当前Map中是否包含给定的key
containsValue(Object value)——查看当前Map中是否包含给定的value
遍历Map的3种方式：遍历所有key，遍历所有键值对Entry，遍历所有value
//遍历key
for(String key : map.keySet()) {
System.out.println("key:" + key + ", value:" + map.get(key));
}
//遍历键值对
for(Entry<String, String> entry : map.entrySet()) {
System.out.println("key:" + entry.getKey() + ", value:" + entry.getValue());
}
//遍历value
for(String value : map.values()) {
System.out.println("value:" + value);
}
6、数组
主要是注意一些数组的语法~
int[] a = {1,2,3,4,5,6};
int[] b = {4,5,6,7,8};
int[] c = {11,9,10,13,7};
//打印
System.out.println(Arrays.toString(a));
//排序
Arrays.sort(c);
System.out.println(Arrays.toString(c));
//复制
int[] a2 = a;
a2[1]++;
System.out.println("a：" + Arrays.toString(a) + ", a2:" + Arrays.toString(a2));//相互影响
int[] d = new int[a.length];
System.arraycopy(a, 0, d, 0, a.length);//src, srcPos, dest, destPos, length
System.out.println(Arrays.toString(d));
int[] d2 = Arrays.copyOf(a, a.length);
System.out.println(Arrays.toString(d2));
//扩容
int[] e = new int[a.length + b.length];
System.arraycopy(a, 0, e, 0, a.length);
System.arraycopy(b, 0, e, a.length, b.length);
System.out.println("e:" + Arrays.toString(e));
还有二维数组等~
7、面向对象
几大特性：封装、继承、多态
1）接口和抽象类的区别（选择答出几点即可）：
抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。
抽象类要被子类继承，接口要被类实现。
接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现
接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。
抽象方法只能申明，不能实现，接口是设计的结果 ，抽象类是重构的结果
抽象类里可以没有抽象方法
如果一个类里有抽象方法，那么这个类只能是抽象类
抽象方法要被实现，所以不能是静态的，也不能是私有的。
2）重载和重写的区别
重写，是指子类重新定义父类的虚函数的做法。它是覆盖了一个方法并且对其重写，以求达到不同的作用。重写要注意以下的几点：
1、重写的方法的标志必须要和被重写的方法的标志完全匹配，才能达到覆盖的效果；
2、重写的方法的返回值类型必须和被重写的方法的返回一致；
3、重写的方法所抛出的异常必须和被重写方法的所抛出的异常一致，或者是其子类；
4、被重写的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。
重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，在使用重载要注意以下的几点：
1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int,float)，但是不能为fun(int,int)）；
2、不能通过访问权限、返回类型、抛出的异常进行重载；
3、方法的异常类型和数目不会对重载造成影响；
4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。
3）访问修饰符范围
|
访问级别 |
访问控制修饰符 |
同类 |
同包 |
子类 |
不同的包 |
|
公开 |
public |
√ |
√ |
√ |
√ |
|
受保护 |
protected |
√ |
√ |
√ |
-- |
|
默认 |
没有访问控制修饰符 |
√ |
√ |
-- |
-- |
|
私有 |
private |
√ |
-- |
-- |
--
|
8.final
final修饰的方法不可以被重写（但可以重载哈~），final修饰的类不可以有子类。
当final修饰基本变量类型时，不能对基本类型变量重新赋值，因此基本类型变量不能被改变 。
当final修饰引用类型变量时，final只保证这个引用类型变量所引用的地址不会改变，即一直引用同一个对象，但是这个对象(对象的非final成员变量的值可以改变)完全可以发生改变。
final修饰的类成员，程序员最好显示地指定其初始值；使用final修饰局部变量时，既可以在定义时指定默认值，也可以不指定默认值。但是只能初始化一次。
（注：全局变量，即成员变量会被默认赋值；而局部变量的值必须由程序员显式初始化）
9、常见设计模式
1）工厂模式
这里直接从拓展性最好的抽象工厂模式说起~
public interface Sender {
public void Send();
}
//两个实现类：
public class MailSender implements Sender {
@Override
public void Send() {
System.out.println("this is mailsender!");
}
}
public class SmsSender implements Sender {
@Override
public void Send() {
System.out.println("this is sms sender!");
}
}
//两个工厂类：
public class SendMailFactory implements Provider {
@Override
public Sender produce(){
return new MailSender();
}
}
public class SendSmsFactory implements Provider{
@Override
public Sender produce() {
return new SmsSender();
}
}
//再提供一个接口：
public interface Provider {
public Sender produce();
}
测试类：
public class Test {
public static void main(String[] args) {
Provider provider = new SendMailFactory();
Sender sender = provider.produce();
sender.Send();
}
}
2）单例模式
超常见，这里以线程安全的单例模式为例：
public class Singleton {
private static Singleton instance = null;
private Singleton() {
}
private static synchronized void syncInit() {
if (instance == null) {
instance = new Singleton();
}
}
public static Singleton getInstance() {
if (instance == null) {
syncInit();
}
return instance;
}
}
3）代理模式
代理：类似专业的中介，代替我们去做某些事。
public interface Sourceable {
public void method();
}
public class Source implements Sourceable {
@Override
public void method() {
System.out.println("the original method!");
}
}
public class Proxy implements Sourceable {
private Source source;
public Proxy(){
super();
this.source = new Source();
}
@Override
public void method() {
before();
source.method();
atfer();
}
private void atfer() {
System.out.println("after proxy!");
}
private void before() {
System.out.println("before proxy!");
}
}
测试类：
public class ProxyTest {
public static void main(String[] args) {
Sourceable source = new Proxy();
source.method();
}
}
结果：
before proxy!
the original method!
after proxy!
代理模式的应用场景：
如果已有的方法在使用的时候需要对原有的方法进行改进，此时有两种办法：
1、修改原有的方法来适应。这样违反了“对扩展开放，对修改关闭”的原则。
2、就是采用一个代理类调用原有的方法，且对产生的结果进行控制。这种方法就是代理模式。
使用代理模式，可以将功能划分的更加清晰，有助于后期维护！
4）桥接模式
把事物和其具体实现分开，使他们可以各自独立的变化。桥接的用意是：将抽象化与实现化解耦，使得二者可以独立变化，像我们常用的JDBC桥DriverManager一样，JDBC进行连接数据库的时候，在各个数据库之间进行切换，基本不需要动太多的代码，甚至丝毫不用动，原因就是JDBC提供统一接口，每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了。
public interface Sourceable {
public void method();
}
//分别定义两个实现类：
public class SourceSub1 implements Sourceable {
@Override
public void method() {
System.out.println("this is the first sub!");
}
}
public class SourceSub2 implements Sourceable {
@Override
public void method() {
System.out.println("this is the second sub!");
}
}
//定义一个桥，持有Sourceable的一个实例：
public abstract class Bridge {
private Sourceable source;
public void method(){
source.method();
}
public Sourceable getSource() {
return source;
}
public void setSource(Sourceable source) {
this.source = source;
}
}
public class MyBridge extends Bridge {
public void method(){
getSource().method();
}
}
测试类：
public class BridgeTest {
public static void main(String[] args) {
Bridge bridge = new MyBridge();
/*调用第一个对象*/
Sourceable source1 = new SourceSub1();
bridge.setSource(source1);
bridge.method();
/*调用第二个对象*/
Sourceable source2 = new SourceSub2();
bridge.setSource(source2);
bridge.method();
}
}
打印结果：
this is the first sub!
this is the second sub!
5）享元模式（参考数据库连接池）
享元模式的主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，通常与工厂模式一起使用
6）策略模式
策略模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。
策略模式的决定权在用户，系统本身提供不同算法的实现，新增或者删除算法，对各种算法做封装。因此，策略模式多用在算法决策系统中，外部用户只需要决定用哪个算法即可。
public interface MemberStrategy {
/**
* 计算图书的价格
* @param booksPrice 图书的原价
* @return 计算出打折后的价格
*/
public double calcPrice(double booksPrice);
}
//初级会员折扣类
public class PrimaryMemberStrategy implements MemberStrategy {
@Override
public double calcPrice(double booksPrice) {
System.out.println("对于初级会员的没有折扣");
return booksPrice;
}
}
//中级会员折扣类
public class IntermediateMemberStrategy implements MemberStrategy {
@Override
public double calcPrice(double booksPrice) {
System.out.println("对于中级会员的折扣为10%");
return booksPrice * 0.9;
}
}
//高级会员折扣类
public class AdvancedMemberStrategy implements MemberStrategy {
@Override
public double calcPrice(double booksPrice) {
System.out.println("对于高级会员的折扣为20%");
return booksPrice * 0.8;
}
}
//价格类
public class Price {
//持有一个具体的策略对象
private MemberStrategy strategy;
/**
* 构造函数，传入一个具体的策略对象
* @param strategy 具体的策略对象
*/
public Price(MemberStrategy strategy){
this.strategy = strategy;
}
/**
* 计算图书的价格
* @param booksPrice 图书的原价
* @return 计算出打折后的价格
*/
public double quote(double booksPrice){
return this.strategy.calcPrice(booksPrice);
}
}
测试类：
public class StrategyTest{
public static void main(String[] args) {
//选择并创建需要使用的策略对象
MemberStrategy strategy = new AdvancedMemberStrategy();
//创建环境
Price price = new Price(strategy);
//计算价格
double quote = price.quote(300);
System.out.println("图书的最终价格为：" + quote);
}
}
打印结果：
对于高级会员的折扣为20%
图书的最终价格为：240.0
………………
策略模式基本上答了这些就够了~
相关推荐
Java是一种广泛使用的...以上是Java基础知识及面试题的概览，涵盖了语言特性、面向对象、集合框架、异常处理、I/O流、多线程和新特性等方面。深入理解并熟练掌握这些内容，将为你的Java开发和面试之路打下坚实基础。
1. **Java基础知识**：Java语法、数据类型（原始类型与引用类型）、运算符（算术、比较、逻辑等）、流程控制（条件语句、循环语句）是编程的基础，理解并熟练运用这些知识是必要的。 2. **面向对象**：面向对象编程...
最近的java 面试知识点， 比较全的java基础知识面试知识，linux
java基础知识点总结及面试问题java基础知识点总结及面试问题java基础知识点总结及面试java基础知识点总结及面试问题
Java基础知识：包括Java语言特性、面向对象编程、集合框架、异常处理等基础知识点。 数据库和SQL：涵盖数据库基础知识、SQL语句的编写和优化、数据库事务等相关内容。 Web开发：包括常用的Web开发框架（如Spring、...
这是一套Java核心技术基础使用手册，包含Java 基础核心总结、Java核心基础、Java核心知识、Java 基础面试题总结等，内含最强 Java 核心知识点整理及思维导图，需要的朋友可下载试试！ Java是一门编程语言，Java发展...
在Java编程领域，面试题是评估求职者技术能力的...这些知识点构成了Java基础知识的核心，对于准备Java面试或进一步深入学习Java编程至关重要。了解和掌握这些概念，将有助于编写出高效、可靠且可维护的Java应用程序。
本资源包"Java 面试全解析：核心知识点与典型面试题.zip"包含了多个关键主题，帮助求职者深入理解和掌握 Java 的核心概念，以及应对面试中的各种问题。 1. **设计模式** - 34-设计模式常见面试题汇总.html 设计...
这份"Java基础面试题源码资料.zip"包含了丰富的面试题目和源代码，旨在帮助求职者或开发者提升Java技术水平，更好地应对面试挑战。以下将对Java基础面试题中的核心知识点进行详细解读。 1. **Java语法基础** - **...
Java面试笔记 225道Java面试题JAVA面试基础知识点总结Java数据结构题 JAVA笔试面试WORD资料汇总(19个): 2014年最新Java笔试题及答案.docx 225道Java面试题 学会了Java面试随你问.docx Ant和Maven的作用是什么？两者...
介绍Java求职面试过程过程中的相关知识点，分为java基础，web，框架等基础知识
基础知识点/面试题总结：（必看）：Java基础常见知识点&面试题总结（上）Java基础常见知识点&面试题总结（中）Java基础常见知识点&面试题总结（下）重要知识点详解：为什么Java中只有值传递？Java序列化详解泛型&...
Java面试题必备——Java基础知识部分汇总 本文总结了Java基础知识部分的重要知识点，涵盖了Java面试中常见的问题，包括作用域、String类、int和Integer的区别、String和StringBuffer的区别、运行时异常与一般异常的...
Java基础知识面试题 Java是一种广泛使用的编程语言，具有平台独立性、面向对象、简单性和安全性等特点。Java基础知识是每个Java开发人员必须掌握的基本技能。以下是Java基础知识面试题的相关知识点： 1. Java语言...
基础 知识点/面试题总结 : (必看 )： ...IO 基础知识总结 IO 设计模式总结 IO 模型详解 并发 知识点/面试题总结 : (必看 ) Java 并发常见知识点&面试题总结（上） Java 并发常见知识点&面试题总结（中） Jav
标题：“2021 - JAVA秋招基础知识点面试题”的知识点总结 1. JDK与JRE的区别： JDK是Java开发工具包，它包含了JRE和一些其他工具，如编译器javac和调试工具等。JRE是Java运行环境，仅用于运行Java程序。简单来说，...
一篇Java进阶架构师之路的核心知识，同时也是面试时面试官必问的知识点，篇章也是包括了很多知识点，其中包括了有基础知识、Java集合、JVM、多线程并发、spring原理、微服务、Netty 与RPC 、Kafka、日记、设计模式、...
了解和熟练掌握这些Java基础知识对于面试至关重要，它们涉及到Java的内存管理、对象创建、字符串处理等多个核心概念。在面试中，面试官可能会通过这些问题来评估候选人的基础知识掌握程度和问题解决能力。