java points[复习]

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();

    }
}

15 - 工具方法一般都声明为static方法