Java基础

一、 面向对象特征与原则

　　1、三大特征：封装、继承、多态。

　　　　（1）封装：将客观的事物封装成抽象的类，封装代码逻辑，并通过访问控制符来控制访问的方式，从而保护程序（使用反射时，可以获取对象的私有方法和成员，会破坏封装性）。

　　　　（2）继承：某个类通过继承可以获取另外一个类的大部分方法（非私有的方法），同时可以编写属于自己的方法，便于程序的扩展。

　　　　（3）多态：指一个类的实例的相同方法在不同的情形下有不同的结果。一般与继承、重写、向上转型等概念相关。

　　2、五大原则：单一职责原则、开放封闭原则、里氏替换原则、依赖倒置原则（多用于框架）、接口分离原则。

　　3、任一事物均可抽象为对象,事物状态可以抽象为对象的变量,事物的行为可以抽象为对象的方法，类似的多个对象可以归为一类。简单的讲，类是对象的模板，对象是类的实例。

 

二、构造方法、方法重载（overload）与方法重写（override）

　　1、构造方法，通过构造方法实现对象的初始化，若没写构造方法，则系统默认提供一个无参构造。

　　　　格式：　　

　　　　　　（1）构造方法的名称必须与类名相同。

　　　　　　（2）构造方法没有返回值，但是也不能用void修饰。

　　　　　　（3）子类继承父类时，构造方法中最好使用super关键字来调用父类的构造方法。若子类中没写，那么编译器会自动加入super()，且此时若父类中没有无参构造方法，会报错。

　　2、方法重载，出现在同一类中，其方法名相同,但参数类型或者参数个数不同。

　　3、方法重写，出现在子类中，其方法名，参数类型，参数个数，返回类型与父类相同，且方法的访问修饰符要比父类的方法权限高。

　　4、重载与重写的区别：

　　　　（1）重载为编译期绑定，即编译时根据参数变量的类型、个数来判断应该调用哪个方法。
　　　　（2）重写为运行期绑定，即运行时根据引用变量实际指向的对象调用方法。即实例是谁，就调用谁的方法。

　　5、 由static修饰的方法，属于静态方法，编译、运行时根据引用类型来判断，即引用类型是谁，就调用谁的方法。

 1 /**
 2  * 父类
 3  */  4 class Father {  5 public void talk() {  6 System.out.println("This is father");  7  }  8  9 public static void run() { 10 System.out.println("Running"); 11  } 12 13 } 14 15 /** 16  * 子类 17 */ 18 class Son extends Father { 19 public void talk() { 20 System.out.println("This is son"); 21  } 22 23 public static void run() { 24 System.out.println("Swimming"); 25  } 26 } 27 28 /** 29  * 演示类 30 */ 31 class Demo { 32 public void show(Father obj) { 33 System.out.println("Father"); 34  obj.talk(); 35  } 36 37 public void show(Son obj) { 38 System.out.println("Son"); 39  obj.talk(); 40  } 41 } 42 43 /** 44  * 测试类，演示成员函数与类函数的编译、运行时的区别 45  * 46  * 测试结果为： 47  * Father 48  * This is father 49  * Son 50  * This is son 51  * Father 52  * This is son 53  * Running 54  * Swimming 55  * Running 56 */ 57 public class Test { 58 public static void main(String[] args) { 59 Father father = new Father(); // 实例化一个Father对象 60 Son brother = new Son();// 实例化一个Son对象 61 Father sister = new Son();// 向上转型，实例化一个Father对象 62 63 Demo demo = new Demo();// 实例化一个演示类 64 demo.show(father);// 由于方法重载，father属于Father类，故执行第一个show方法，执行Father类的talk方法。 65 demo.show(brother);// 由于方法重载，brother属于Son类，故执行第二个show方法，执行Son类的talk方法。 66 demo.show(sister);// 由于方法重载，sister属于Father类，故执行第一个show方法，但由于方法重写，执行的是Son类的talk方法。 67 68 // 由static修饰的方法，属于静态方法，编译、运行时根据引用类型来判断 69 father.run();//引用类型为Father，故相当于执行Father.run()，输出 Running 70 brother.run();//引用类型为Son，故相当于执行Son.run()，输出Swimming 71 sister.run();//引用类型为Father，故相当于执行Father.run()，输出Running 72  } 73 }

 

 

三、JVM内存结构（方法区、栈、堆）

　　1、方法区：方法区用于存放类的信息。当java程序运行时，首先通过类装载器载入字节码信息（.class文件），经过解析后将其装入方法区。即类的各种信息均在方法区保存。

　　2、栈：栈用于存放程序运行中所有的局部变量。一个java程序运行直到结束的过程中会调用多个方法，而JVM会为每个方法在栈中分配一个对应的空间，这个空间称为方法的栈帧。栈帧中存储了该方法的参数、局部变量等数据，当一个方法结束，则清除对应的栈帧。

　　3、堆：堆用来存放对象，比如使用new关键字实例化一个对象，则其相关的成员变量将存于堆中某个区域。

 

四、抽象类、接口、extends、implements、向上造型、instanceof

　　1、抽象类：使用abstract关键字修饰，若方法没有方法体，必须由abstract关键字修饰。不能被实例化，其子类必须重写所有abstract方法才可以被实例化。

　　2、接口：使用interface关键字修饰，java1.8之前方法没有方法体，java1.8之后方法可以有方法体，但必须由default关键字修饰。不能被实例化，其子类必须重写所有abstract方法才可以被实例化。

　　3、通过extends关键字实现继承，子类可以继承父类的方法以及成员变量，且可以声明自己的成员变量、方法。

　　4、通过implements关键字实现接口，原理类似继承。

　　5、Java不支持多继承，但可以通过实现多个接口来达到多继承的效果。一个类可以实现多个接口，一个接口可以继承多个接口。

　　6、向上造型：一个子类可以向上造型为父类，即父类的引用指向子类的实例（对象）。比如：Father father = new Son();

　　7、一个父类的引用可以指向该父类的对象，也可以指向其子类的任意一个对象。可通过instanceof关键字可以判断某变量具体指向的数据类型。

 

五、访问控制符

　　1、private：只能在本类中访问。

　　2、default：可以在本类以及同包中访问。即private + 同包。

　　3、protected：可以在本类、同包、以及子类中访问。即default + 子类。

　　4、public：可以在任意一个地方访问。即protected + 不同包。

 

六、static、final关键字

　　static关键字：

　　1、static修饰成员变量：

　　　　（1）static修饰的成员变量不属于对象的数据结构。

　　　　（2）static变量属于类的变量，通过（类名.变量名）来访问。
　　　　（3）static变量存在方法区中，不在堆里。
　　　　（4）一个类只用一份static变量，无论创建多少个对象，此变量均共享。
　　2、static修饰方法：（类似于修饰成员变量）
　　　　（1）static方法属于类的方法，直接使用（类名.方法名）调用。
　　　　（2）通常用于提供一些工具方法、工厂方法等。
　　3、static修饰代码块：（类似于修饰成员变量）　　

 

　　final关键字：

　　1、final修饰类：
　　　　final修饰的类不能被继承。
　　2、final修饰方法：
　　　　final修饰的方法不能被重写。
　　3、final修饰成员变量：
　　　　该成员变量需在初始化时赋值，对象创建后不可被修改，通常用于声明常量。

 

七、参数传值（值传递还是引用传递？）

　　1、对于基本类型，参数传递指的是值传递。其传递的是参数的复制值，即将参数拷贝一份再传入，此时修改参数是对拷贝的值进行修改，不会影响原来的值。

　　2、对于引用类型，参数传递可以理解为引用传递，也可以理解为值传递。其传递的是参数的地址的复制值，即将参数的地址拷贝一份再传入，此时若通过参数（引用地址）修改参数的值，会影响原来的值。若修改参数（引用地址），则不会影响原来的值。

 1 /**
 2  * 测试类，用于测试参数传递为引用传递还是值传递。
 3  * 测试结果为：  4  * hello  5  * hello world  6  * hi  7  * hi  8 */  9 public class Test { 10 public static void main(String[] args) { 11 StringBuilder str = new StringBuilder("hello"); 12 System.out.println(str); //输出为hello 13 test1(str); //由于引用传递，将str所指向的地址拷贝，通过地址修改地址上的参数，所以会修改地址上的参数。 14 System.out.println(str);//输出为hello world 15 16 String str1 = "hi"; 17 System.out.println(str1);//输出为hi 18 test2(str1);//由于引用传递，将str1的地址拷贝，由于String的不可变性，其会导致拷贝后的地址重新指向另一个地址，故不会修改原地址上的参数 19 System.out.println(str1);//输出为hi 20 21  } 22 23 /** 24  * 将参数的地址拷贝，并根据参数的地址，向参数中追加字符串。 25  * 此时原地址的参数被修改。 26  * @param str 27 */ 28 public static void test1(StringBuilder str) { 29 str.append(" world"); 30  } 31 32 /** 33  * 将参数的地址拷贝，由于String的不可变性，所以拷贝的地址将被替换为一个新的地址，新的地址指向"world"参数。 34  * 即相当于给拷贝的地址修改了地址，不会对原有的地址造成影响。 35  * 此时原地址未被修改，且参数未被修改。 36  * @param str 37 */ 38 public static void test2(String str) { 39 str = "world"; 40  } 41 }

 

八、异常类（java.lang.Throwable）

　　1、Throwable类的子类为Exception与Error两类，其中Error指运行环境出错，即虚拟机级别的错误，如内存溢出。而Exception指程序级别的错误，如网络故障，文件损坏，设备错误，输入非法等。

　　2、 异常就是程序运行时可能出现的错误，而异常处理将会改变程序的控制流程。

　　3、Java通过throw关键字抛出一个Exception子类的实例（即抛出异常对象）表示异常的发生，通过throws关键字抛出异常类。

　　4、java允许定义方法时声明该方法调用过程中可能出现的异常，即允许方法调用过程中抛出异常对象，从而终止当前方法的执行。

　　5、异常类中的方法：

　　　　public String getMessage();//查看错误信息
　　　　public void printStackTrace();//输出执行堆栈信息，跟踪异常事件的发生。

　　　　public String toString();//输出异常类的信息

　　　　Throwable getCause(); 获取异常产生的真实原因，实际开发中，为了抛出异常的风格统一，通常将实际异常包装后再抛出，可以通过getCause获取真实原因。

　　6、异常处理方式：

　　　　（1）捕捉：

　　　　　　try {

　　　　　　　　需要被检测的代码；

　　　　　　} catch（异常类 变量名） {

　　　　　　　　异常处理代码；

　　　　　　}finally {

　　　　　　　　一定会执行的代码；（除非程序因某原因退出，比如System.exit(0)）

　　　　　　}

·　　　　（2）抛出：

　　　　　　throw 关键字抛出一个异常类实例， 比如 throw new Exception(e);

　　　　　　throws 关键字抛出一个异常类，写在方法上， 比如 public static void run() throws Exception(){}

　　7、对于try-catch-finally中出现return的情况，若finally中无return，则返回try或catch中return的结果。若finally中有return，则返回finally中return的结果。

　　8、自定义异常，需要继承Exception类或RuntimeException，然后通过throw，throws关键字来抛出异常。

　　9、异常分类：

　　　　（1）运行时异常（非检查异常）：指RuntimeException及其子类，不需要检查（即编译器不处理），一旦出错，程序将停止运行。

　　　　（2）编译时异常（检查异常）：除RuntimeException外的异常，需要检查并处理，否则会编译失败。

 1 public class Test {
 2     public static void main(String[] args) { 3 try { 4 run(); 5 } catch (RuntimeException e) { 6 System.out.println(e.getMessage());// 输出实际异常，java.lang.NullPointerException 7 System.out.println(e.toString());// 输出所有异常，java.lang.RuntimeException: 8 // java.lang.NullPointerException 9 System.out.println(e.getCause());// 打印实际的异常，java.lang.NullPointerException 10 } 11 12 System.out.println(demo1());// finally中无return，且未抛出异常，执行try代码，finally代码后，输出0. 13 System.out.println(demo2());// finally中无return，且抛出异常，执行catch代码，finally代码后，输出1. 14 System.out.println(demo3());// finally中有return，且未抛出异常，执行try代码，finally代码后，输出2. 15 System.out.println(demo4());// 程序中途退出，没有输出结果 16 } 17 18 public static void run() throws RuntimeException { 19 try { 20 String str = null; 21 System.out.println(str.length());// 空指针异常 22 } catch (NullPointerException e) { 23 // 将异常包装一下,throw关键字抛出一个异常类的实例，由throws关键字抛出异常类 24 throw new RuntimeException(e); 25 } 26 } 27 28 public static int demo1() { 29 try { 30 return 0; 31 } catch (NullPointerException e) { 32 return 1; 33 } finally { 34 // return 2; 35 } 36 } 37 38 public static int demo2() { 39 try { 40 String str = null; 41 System.out.println(str.length());// 空指针异常 42 return 0; 43 } catch (NullPointerException e) { 44 return 1; 45 } finally { 46 // return 2; 47 } 48 } 49 50 public static int demo3() { 51 try { 52 return 0; 53 } catch (NullPointerException e) { 54 return 1; 55 } finally { 56 return 2; 57 } 58 } 59 60 public static int demo4() { 61 try { 62 System.exit(0); 63 return 0; 64 } catch (NullPointerException e) { 65 return 1; 66 } finally { 67 return 2; 68 } 69 } 70 }

转载于:https://www.cnblogs.com/jc1997/p/10900550.html