Java基础--面向对象以及相关知识

2019-05-22 06:35:29来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

一、 面向对象特征与原则

  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/l-y-h/p/10899374.html
如有疑问请与原作者联系

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:Java添加、提取、替换和删除PDF图片

下一篇:Spring Cloud(9):Config配置中心