Java基础知识整理

时间 2021-05-26

标签 java 编程设计模式数组安全多线程 app 框架 ide 函数栏目 Java 繁體版

原文原文链接

面向对象和面向过程的区别

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

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

获取用键盘输入经常使用的的两种方法

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

Java 面向对象编程三大特性: 封装继承多态

封装
把一个对象的属性私有化，同时提供一些能够被外界访问的属性的方法，若是属性不想被外界访问，咱们大可没必要提供方法给外界访问。可是若是一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。安全

继承
继承是使用已存在的类的定义做为基础创建新类的技术，新类的定义能够增长新的数据或新的功能，也能够用父类的功能，但不能选择性地继承父类。经过使用继承咱们可以很是方便地复用之前的代码。多线程

子类拥有父类非 private 的属性和方法。
子类能够拥有本身属性和方法，即子类能够对父类进行扩展。
子类能够用本身的方式实现父类的方法。

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

重载和重写的区别

方法重载是指同一个类中的多个方法具备相同的名字,但这些方法具备不一样的参数列表,即参数的数量或参数类型不能彻底相同
（相同名字，不一样参数）框架

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

为何函数不能根据返回类型来区分重载

由于调用时不能指定类型信息
如：函数

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

当调用max(1,2)时，没法肯定

抽象类（abstract）和接口（interface）

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

抽象的（abstract）方法是否可同时是静态的（static），是否可同时是本地方法（native），是否可同时被synchronized？

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

静态变量和实例变量的区别

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

String、StringBuffer、StringBulider

String是引用类型，底层由char数组实现
String：字符串常量，在修改时布改变自身，修改等于从新生成新的自符串对象；

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

线程安全：

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

当咱们使用"+"时，编译器转换成了StringBuilder，因此不要在for语句内使用；同时尽可能不要"+"和StringBuilder一块儿使用

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

一个类的构造方法的做用是什么若一个类没有声明构造方法,该程序能正确执行吗 ?为何?

主要做用是完成对类对象的初始化工做。能够执行。由于一个类即便没有声明构造方法也会有默认的不带参数的构造方法。

== 与 equals(重要)

== : 它的做用是判断两个对象的地址是否是相等。即，判断两个对象是否是同一个对象。。(基本数据类型比较的是值，引用数据类型比较的是内存地址)
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 (重要)

若是两个对象相等，则hashcode必定也是相同的
两个对象相等,对两个对象分别调用equals方法都返回true
两个对象有相同的hashcode值，它们也不必定是相等的
所以，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖
hashCode() 的默认行为是对堆上的对象产生独特值。若是没有重写 hashCode()，则该 class 的两个对象不管如何都不会相等（即便这两个对象指向相同的数据）

length,length(),size()三者的区别

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<String> col = new ArrayList<String>();
col.add("Hello");
col.add("World");
col.add("Java");
/**
* 类集框架用size()方法取元素个数
*/
int sizeCol = col.size();//此处sizeCol=3
System.out.println("Col size:"+sizeCol);

List的三个子类的特色

ArrayList 底层是数组，查询快，增删慢
LinkedList 底层是链表，增删快，查询慢
voctor 底层是数组，线程安全，增删慢，查询慢

如何实现数组和 List 之间的转换

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<String> a = new LinkedList<>();
        Queue<String> b = new LinkedList<>();
        List<String> 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 区别

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

poll，remove 区别：

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

peek，element区别：

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

HashMap和HashTable的区别

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和throws区别

throw：
throw在方法体内，表示抛出异常，执行throw必定是抛出了某种异常
throws ：
throws跟在方法声明的后面，表示可能出现某种异常

try和finally的返回值

若是try有返回值，就把返回值保存到局部变量中；
执行jsr指令跳到finally语句里执行；
执行完finally语句后，返回以前保存在局部变量表里的值。
若是try，finally语句里均有return，忽略try的return，而使用finally的return

迭代器 Iterator

迭代器是一种设计模式，它是一个对象，它能够遍历并选择序列中的对象，而开发人员不须要了解该序列的底层结构。迭代器一般被称为“轻量级”对象，由于建立它的代价小。
使用：

使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterator()方法是java.lang.Iterable接口,被Collection继承。
使用next()得到序列中的下一个元素。
使用hasNext()检查序列中是否还有元素。
使用remove()将迭代器新返回的元素删除。