1 - & 与 && 的区别：
&：不管左边是true还是false，右端都会进行运算；&&：当左端为false时，右端不再进行运算；- 即在
与运算时，前面为false，即可判断该条件为false了，后面没必要再算了 ----建议使用&&.
2 - | 与 || 的区别：
|：不管左端，右端照算；||：左端为true时，右端不用算（最终结果已经可以确定为true了）;- 建议用
||
3 - java中内存的基本结构：
4 - this关键字的使用:
- 1 - 当形参与成员变量重名时，如果在方法内部需要使用成员变量，必须添加
this来表明该变量的类成员；- 2 - 在任意方法内，如果使用当前类的成员变量或成员方法可以在其前面添加
this，增强程序的阅读性；- 3 - this可以作为一个类中，构造器相互条用的特殊格式；
public Person(String name){ this(); //调用本类中的无参构造方法 this.name = name; } public Person(String name, int age){ this(name); //调用有一个参数的构造方法 this.age = age; }
5 - this和super的区别：
| No. | 区别点 | this | super |
|---|---|---|---|
| 1 | 访问属性 | 访问本类中的属性，如果本类中没有此属性，则从父类中继续查找 | 访问父类中的属性 |
| 2 | 调用方法 | 访问本类中的方法 | 直接访问父类中的方法 |
| 2 | 调用构造器 | 调用本类构造器，必须放在构造器的首行 | 调用父类构造器，必须放在子类构造器的首行 |
| 4 | 特殊 | 表示当前对象 | 无此概念 |
6 - 权限修饰符的区别：
- private ：无法被子类继承，也无法被外部类调用；
- protected ：显示的表示可以被子类继承；
- public : 可以被外部类直接调用；
7 - java中的多态：
Person 父类，有eat(),walk();Man 和 Woman 为继承了 Person 类的子类,并且都重写了eat()和walk()方法，
另外，Woman类中有一个自己的方法，即shooping()
Man m = new Man(); m.eat(); m.walk(); System.out.println(); //*【子类对象的多态性】：父类的引用指向子类对象 Person p1 = new Man(); //向上转型 //虚拟方法调用:通过父类的引用指向子类对象的实体，当调用方法时，执行的是子类重写父类的方法 p1.eat(); p1.walk(); Person p2 = new Woman(); p2.eat(); p2.walk(); Woman w = (Woman)p2; //向下转型 w.shooping();
补充：instanceof：类型判断
//格式：对象p instanceof 类A if(p1 instanceof Woman){ //如果p1是Woman类型，则可以转型 Woman w1 = (Woman)p1; w1.shooping(); }
8 - static修饰属性（类变量）：
1.由类创建的所有对象，都共用这一个属性
2.当其中一个对象对此属性进行修改，会导致其他对象对此属性的一个调用。vs 实例变量（非static变量修饰的属性
3.类变量随着类的加载而加载的，而且独一份
4.静态的变量可以直接通过“类.类变量”的形式来调用
5.类变量的加载要早于对象。所以当有对象以后，可以“类.类变量”使用。但是“类.实例变量”是不行的。
6.类变量存在与静态域中。
class SportMan{ //实例变量（随着对象的创建而被加载的） String name; int age; //类变量 static String nation; }
8 - static修饰方法（类方法）：
1.随着类的加载而加载，在内存中也是独一份
2.可以直接通过“类.类方法”的方式调用
3.内部可以调用静态的属性或静态的方法，而不能调用非静态的属性或方法。反之，非静态的方法可以调用静态的属性或静态的方法
>静态的方法内是不可以有this或super关键字的！
注：静态的结构（static的属性、方法、代码块、内部类）的生命周期要早于非静态的结构，被回收也要晚于非静态的结构
>可以简单记住:加了static的方法和变量,可以不new一个对象而直接通过类.方法名或类.变量名来调用,例如:
class Black{ Test.bianliang; //直接调用，而不需要new一个 Test.fangfa(); //直接调用，而不需要new一个 } Class Test{ public static int bianliang = 666; public static void fangfa(){ System.out.println("测试方法"); } }
9 - 单例模式
【推荐阅读博客】：https://blog.csdn.net/goodlixueyong/article/details/51935526
1.解决的问题：使得一个类只能创建一个对象。
2.如何实现？见如下4步
//饿汉式 public class TestSingleton{ public static void main(String[] args){ Singleton s1 = Singleton.getInstance(); Singleton s2 = Singleton.getINstance(); System.out.println(s1 == s2); //比较两个对象的引用是否一样 //而equal()用来比较两个对象是否一样 } } //只能创建Singleton的单个实例 class Singleton{ //1.私有化构造器，使得在类的外部不能够调用次构造器 private Singleton(){ } //2.在类的内部创建一个类的实例 private static Singleton instance = new Singleton(); //3.私有化此对象，通过公共的方法来调用 //4.此公共的方法，只能通过类来调用，因为设置为static的，同时类的实例也必须为static声明的 public static Singleton getInstance(){ return instance; } }
ture
//懒汉式：可能存在线程安全问题 public class TestSingleton1{ public static void main(String[] args){ Singleton1 s1 = Singleton1.getInstance(); Singleton1 s2 = Singleton1.getINstance(); System.out.println(s1 == s2); } } class Singleton1{ //1.私有化构造器 private Singleton1(){ } //2.在类的内部创建一个类的实例，并使其为私有和静态的 private static Sintleton1 instance = null; //3.返回对象 public static Singleton1 getInstance(){ if(instance == null){ instance = new Singleton1(); } return instance; } }
10 - final修饰
- 1.final修饰类：这个类就不能被继承；
- 2.final修饰方法：这个方法不能被子类重写；
- 3.final修饰属性：此属性就是一个常量，一旦初始化，就不能再赋值。习惯上常量有大写字母表示；
11 - java集合
Collection接口：
Set：元素无序、不可重复的集合；List：元素有序，可重复的集合；
Map接口：具有映射关系“key-value”的集合；
12 - java中的接口
- 1.接口可以看作是一个特殊的抽象类。是常量与抽象方法的一个集合，不能包含变量、一般的方法。
- 2.接口是没有构造器的；
- 3.接口定义的就是一种功能。 此功能可以被类所实现（
implements）；比如：class CC extends DD implements AA
- 4.实现接口的类，必须要重写其中的所有的抽象方法，方可实例化。若没有重写，则仍为抽象类；
- 5.类可以实现多个接口。 -----
java中类的的继承是单继承的；- 6.接口与接口之间也是继承的关系，而且可以实现多继承。
- <5、6是面试的重点>
13 - 集合的使用
Collection接口：
List接口：存储有序的，可以重复的元素 ---- 相当于“动态”数组;
》添加进List集合中的元素（或对象）所在的类一定要重写equals()方法;
ArrayList(主要的实现类)LinkedList(链表形式的实现类，更适用于频繁的插入、删除操作)Vector(古老的实现类、线程安全的，但效率要低于ArrayList)
Set接口：存储无序的，不可重复的元素 ---- 相当于高中的集合概念
》添加进Set集合中的元素所在的类一定要重写equals()和hashCode()方法;
HashSet(主要的实现类)LinkedHashSet(是HashSet的子类，当我们遍历集合元素时，是按照添加进去的顺序实现的)TreeSet(可以按照添加进集合中的元素的制定属性进行排序)
- 要求
TreeSet添加进的元素必须是同一个类的！- 两种排序方式：
- 自然排序：
- ①要求添加进
TreeSet中的元素所在类implementS Comparable接口- ②重写
compareTo(Object obj)，在此方法内指明按照元素的哪个属性进行排序- ③向
TreeSet中添加元素即可，若不实现此接口，会报运行时异常
- 定制排序：
- ①创建一个实现
Comparator接口的实现类的对象，在实现类中重写Comparator的方法- ②在此
compare()方法中指明按照元素所在类的哪个属性进行排序- ③将此实现
Comparator接口的实现类的对象作为形参传递给TreeSet的构造器中- ④向
TreeSet中添加元素即可，若不实现次接口，会报运行时异常
- 》要求重写的
compareTo()或者compare()方法与equals()和hashCode()方法保持一致。
Map接口：存储“键-值”对的数据 ---- 相当与高中的“函数 y = f(x)”
- key是不可重复的，使用Set存放。value可以重复，使用Collection来存放的。一个key-value构成一个entry(Map.Entry),entry使用Set来存放
- HashMap：主要的实现类，可以添加null键，null值
- LinkedHashMap：是HashMap的子类，可以按照添加进Map的顺序实现遍历
- TreeMap：需要按照key所在类的制定属性进行排序，要求key是同一个类的对象，对key考虑使用自然排序 或 定制排序
- HashTable：是一个古老的实现类，线程安全的，不可以添加进null键，null值；不建议使用。
- 子类：Properties：重用来处理属性文件（如数据库的配置文件）
14 - java多线程
//使用实现Runnable接口的方式，售票 /** * 此线程会存在线程安全问题 * 2.如何来解决线程的安全问题？ * 必须让一个线程操作共享数据完毕后，其他线程才有机会参与共享数据的操作 * * 3.java如何实现线程的安全：线程的同步机制 * * 方式一：同步代码块 * synchronized(同步监视器){ * //需要被同步的代码（即为操作共享数据的代码） * } * 1.共享数据：多个线程共同操作的同一个数据（变量） * 2.同步监视器：由一个类的对象来充当。哪个线程获取此监视器，谁就执行大括号里被同步的代码。俗称：锁 * 要求：所有的线程必须共用同一把锁！ * 注：在实现的方式中，考虑同步的话，可以使用this来充当锁。但是在继承的方法中，慎用this * * 方式二：同步方法 * 将操作共享数据的方法声明为synchronized。即此方法为同步方法，能够保证当其中一个线程执行此方法时， * 其他线程在外等待直至此线程执行完此方法。 * * @author hasee * */ //实现的方式 //加锁实现同步（同步代码块） class Window1 implements Runnable { int ticket = 100; Object obj = new Object(); public void run() { while (true) { synchronized (obj) { if (ticket > 0) { System.out.println(Thread.currentThread().getName() + ":" + ticket--); } else { break; } } } } } //实现的方式（通过静态共享变量保证多个线程修改的是同一个变量） class Window2 implements Runnable { static int ticket = 100; public void run() { while (true) { if (ticket > 0) { try { Thread.currentThread().sleep(10); //将多线程的错误放大 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ":" + ticket--); } else { break; } } } } //同步的方式（通过继承的方式来实现多线程） class Window3 extends Thread { static int ticket = 100; static Object obj = new Object(); //静态的监视器，避免不同进程使用不同的监视器，造成无法同步的安全问题 public void run(){ while(true){ synchronized (obj) { if(ticket > 0){ try { Thread.currentThread().sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ":" + ticket--); } } } } } //同步的方法（通过接口实现） class Window4 implements Runnable { int ticket = 100; //共享数据 public void run() { while (true) { show(); } } //将该方法声明为synchronized方法 public synchronized void show(){ if (ticket > 0) { try { Thread.currentThread().sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ":" + ticket--); } } } public class TestWindow1 { public static void main(String[] args) { // 方式一：3个Thread共享一个Window1类对象 Window1 w = new Window1(); Thread t1 = new Thread(w); Thread t2 = new Thread(w); Thread t3 = new Thread(w); t1.start(); t2.start(); t3.start(); // 方式二：三个Window2类对象，各自分别对应了3个Thread // 这种方式必须保证共享的变量（即共享资源）为静态的，否则出错 // Window2 w21 = new Window2(); // Window2 w22 = new Window2(); // Window2 w23 = new Window2(); // Thread t21 = new Thread(w21); // Thread t22 = new Thread(w22); // Thread t23 = new Thread(w23); // t21.start(); // t22.start(); // t23.start(); } }