Java基础知识整理

摘要：有两个重要的子类异常和错误，二者都是异常处理的重要子类，各自都包含大量子类。错误是程序无法处理的错误，表示运行应用程序中较严重问题。异常由虚拟机抛出。迭代器通常被称为轻量级对象，因为创建它的代价小。

面向过程
优点： 性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。
缺点： 没有面向对象易维护、易复用、易扩展

面向对象
优点： 易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护
缺点： 性能比面向过程低

通过 Scanner

Scanner input = new Scanner(System.in);
String s  = input.nextLine();
input.close();

通过 BufferedReader

BufferedReader input = new BufferedReader(new InputStreamReader(System.in)); 
String s = input.readLine(); 

封装
把一个对象的属性私有化，同时提供一些可以被外界访问的属性的方法，如果属性不想被外界访问，我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。

继承
继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承我们能够非常方便地复用以前的代码。

子类拥有父类非 private 的属性和方法。

子类可以拥有自己属性和方法，即子类可以对父类进行扩展。

子类可以用自己的方式实现父类的方法。

多态
指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。
在Java中有两种形式可以实现多态：继承（多个子类对同一方法的重写）和接口（实现接口并覆盖接口中同一方法）。

方法重载是指同一个类中的多个方法具有相同的名字,但这些方法具有不同的参数列表,即参数的数量或参数类型不能完全相同
（相同名字，不同参数）

方法重写是存在子父类之间的,子类定义的方法与父类中的方法具有相同的方法名字,相同的参数表和相同的返回类型
（相同名字，相同类型）（继承）

因为调用时不能指定类型信息
如：

float max(int a,int b)
int max(int a,int b)

当调用max(1,2)时，无法确定

选择使用接口和抽象类的依据：抽象类是对最本质的抽象，接口是对动作的抽象
如：男人、女人是两个类，那可以抽象出一个类，人；人可以吃东西，学习等等，这些行为就是一个个接口

都不能。抽象方法需要子类重写，而静态的方法是无法被重写的；本地方式是由本地代码实现的方法，而抽象方法是没有实现的；synchronized和方法的实现细节有关，抽象方法不涉及实现细节，因此都不能。

静态变量：被static修饰的变量，也称为类的变量，属于类，不属于类的任何一个对象，一个类不管创建多少对象，静态变量在内存只有一个拷贝，可以实现让多个对象共享内存
实例变量：必须依存某一实例，需要创建对象才能通过对象去访问它。

String是引用类型，底层由char数组实现

String：字符串常量，在修改时布改变自身，修改等于重新生成新的自符串对象；

StringBuffer：在修改时会改变对象自身，每次操作都是对StringBuffer对象本身进行修改，不是生成新的对象，使用场景是：对字符串经常改变情况下，主要方法：append()

线程安全：

String：定义对象后不可变，线程安全
StringBuffer：线程安全，对调用的方法加入同步锁，执行效率较慢，适用于多线程下操作字符串缓冲区大量数据
StringBuilderer：线程不安全，适用于单线程下操作字符串缓冲区大量数据

当我们使用"+"时，编译器转换成了StringBuilder，所以不要在for语句内使用；同时尽量不要"+"和StringBuilder一起使用

对于三者使用的总结：
操作少量的数据 String
单线程操作字符串缓冲区下操作大量数据 StringBuilder
多线程操作字符串缓冲区下操作大量数据 StringBuffer

主要作用是完成对类对象的初始化工作。可以执行。因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。

== : 它的作用是判断两个对象的地址是不是相等。即，判断两个对象是不是同一个对象。。(基本数据类型比较的是值，引用数据类型比较的是内存地址)
equals() : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况：
情况1：类没有覆盖 equals() 方法。则通过 equals() 比较该类的两个对象时，等价于通过“==”比较这两个对象。
情况2：类覆盖了 equals() 方法。一般，我们都覆盖 equals() 方法来两个对象的内容相等；若它们的内容相等，则返回 true (即，认为这两个对象相等)。

public class test1 {

    public static void main(String[] args) {

        String a = new String("ab"); // a 为一个引用

        String b = new String("ab"); // b为另一个引用,对象的内容一样

        String aa = "ab"; // 放在常量池中

        String bb = "ab"; // 从常量池中查找

        if (aa == bb) // true

            System.out.println("aa==bb");

        if (a == b) // false，非同一对象

            System.out.println("a==b");

        if (a.equals(b)) // true

            System.out.println("a.equals(b)");

        if (42 == 42.0) { // true

            System.out.println("true");

        }

    }

}

说明：

String 中的 equals 方法是被重写过的，因为 object 的 equals 方法是比较的对象的内存地址，而 String 的 equals 方法比较的是对象的值。

当创建 String 类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个 String 对象。

如果两个对象相等，则hashcode一定也是相同的

两个对象相等,对两个对象分别调用equals方法都返回true

两个对象有相同的hashcode值，它们也不一定是相等的

因此，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖

hashCode() 的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode()，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）

length属性:用于获取数组长度

int ar[] = new int{1,2,3}
/**
* 数组用length属性取得长度
*/
int lenAr = ar.length;//此处lenAr=3
System.out.println("Arr length:"+lenAr);

length()方法：用于获取字符串长度

String str = "Hello World Java";

/**
* 字符串用length()方法取得长度
*/

int lenStr = str.length();//此处lenStr=16
System.out.println("Str length():"+lenStr);

size()方法：用于获取泛型集合有多少个元素

/**
* Collection是整个类集之中单值保存的最大父接口，所以使用时需要用具体子类实例化
*/
Collection col = new ArrayList();
col.add("Hello");
col.add("World");
col.add("Java");
/**
* 类集框架用size()方法取元素个数
*/
int sizeCol = col.size();//此处sizeCol=3
System.out.println("Col size:"+sizeCol);

ArrayList 底层是数组，查询快，增删慢

LinkedList 底层是链表，增删快，查询慢

voctor 底层是数组，线程安全，增删慢，查询慢

List转换成为数组：调用ArrayList的toArray方法。
数组转换成为List：调用Arrays的asList方法。

思路：队列a和b

  入栈：a队列为空，b为空，将“a,b,c,d,e”先放入a中，a进栈为“a,b,c,d,e”  
  出栈：将a队列依次加入ArrayList集合c中，以倒序的方法，将c中的集合取出，放入b中，再将b队列出列
  

 public static void main(String[] args) {
        Queue a = new LinkedList<>();
        Queue b = new LinkedList<>();
        List c = new ArrayList<>();

        a.offer("a");
        a.offer("b");
        a.offer("c");
        a.offer("d");
        a.offer("e");
        System.out.print("进栈：");
        for(String s:a){
            c.add(s);
            System.out.print(s);
        }

        for(int i=c.size()-1;i>=0;i--){
            b.offer(c.get(i));
        }

        System.out.println();
        System.out.print("出栈：");
        for(String s:b){
            System.out.print(s);
        }
    }

一些队列有大小限制，因此如果想在一个满的队列中加入一个新项，多出的项就会被拒绝。
这时新的 offer 方法就可以起作用了。它不是对调用 add() 方法抛出一个 unchecked 异常，而只是得到由 offer() 返回的 false。

remove() 和 poll() 方法都是从队列中删除第一个元素。remove() 的行为与 Collection 接口的版本相似， 但是新的 poll() 方法在用空集合调用时不是抛出异常，只是返回 null。因此新的方法更适合容易出现异常条件的情况。

element() 和 peek() 用于在队列的头部查询元素。与 remove() 方法类似，在队列为空时， element() 抛出一个异常，而 peek() 返回 null。

HashMap是线程不安全的，是Map的一个子接口，是将键映射到值的对象，不允许键值重复，允许空键和空值，由于非线程安全，HashMap的效率要较HashTable高

HashTable是线程安全的一个集合，不允许null作为一个key或者value值，是线程安全的

在 Java 中，所有的异常都有一个共同的祖先java.lang包中的 Throwable类。
Throwable： 有两个重要的子类：Exception（异常） 和 Error（错误） ，二者都是 Java 异常处理的重要子类，各自都包含大量子类。
Error（错误）:是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题
Exception（异常）:是程序本身可以处理的异常

RuntimeException。RuntimeException 异常由Java虚拟机抛出。

NullPointerException（要访问的变量没有引用任何对象时，抛出该异常）

ArithmeticException（算术运算异常，一个整数除以0时，抛出该异常）

ArrayIndexOutOfBoundsException （下标越界异常）。

SQLException，SQL异常，一般都是SQL语句错误

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

throw：
throw在方法体内，表示抛出异常，执行throw一定是抛出了某种异常

throws ：
throws跟在方法声明的后面，表示可能出现某种异常

如果try有返回值，就把返回值保存到局部变量中；

执行jsr指令跳到finally语句里执行；

执行完finally语句后，返回之前保存在局部变量表里的值。

如果try，finally语句里均有return，忽略try的return，而使用finally的return

迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。
使用：

使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterator()方法是java.lang.Iterable接口,被Collection继承。

使用next()获得序列中的下一个元素。

使用hasNext()检查序列中是否还有元素。

使用remove()将迭代器新返回的元素删除。