Java 面向对象知识结构

文章目录

@[toc] Java 面向对象知识结构

面向对象和面向过程

Java 有没有 goto?

关键字 switch

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

Java 创建对象的方式有哪些？

面向对象的特征有哪些？

override（重写，覆盖）和 overload（重载，过载）

什么是不可变对象？

Java 面向对象的内容很多，而且不像 jdk 那样成体系，可以粗略地分为两部分：

Java 语法及关键字，属于形而下的语言规范，如接口与类、内部类，final/finally/finalize，throw/throws，域访问符权限等；

Java 面向对象思想及体系，属于形而上的设计思想。

面向对象和面向过程

就是先分解过程步骤：

Java 有没有 goto?

参-：

goto 是 Java 中的保留字，在目前版本的 Java 中没有使用。

Java 中跳出多重循环有三种方式：

1、break + 标签。在最外层循环前加一个标签如 label，然后在最里层的循环使用用 break label。

public static void main(String[] args) { label: //标记 for (int i = 0 ; i < 10; i++) { for (int j = 0; j < 10; j++) { System.out.println("i = " + i + ", j = " + j); if(j == 5) { //满中一定条件跳到某个标记 break label; } } } }

1

2

3

4

5

6

7

8

9

10

11

2、通过捕获异常。

public static void main(String[] args) { try { for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { System.out.println("i = " + i + ", j = " + j); if (j == 5) {// 满足一定条件抛异常 throw new RuntimeException("test exception for j = 5"); } } } } catch (RuntimeException e) { //循环外层捕获异常 e.printStackTrace(); } }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

3、通过标置变量。

public static void main(String[] args) { boolean flag = false; //初始化标置变量 for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { System.out.println("i = " + i + ", j = " + j); if (j == 5) { //满足一定条件进行设置标置变量 flag = true; } if (flag) { //内层循环判断标置变量 break; } } if (flag) {//外层循环判断标置变量 break; } } }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

点评：

该问题属于 Java 语法中的关键字考察。

James Gosling（Java 之父）编写的《The Java Programming Language》一书的附录中给出了一个 Java 关键字列表，

其中有 goto 和 const，但是这两个是目前无法使用的关键字，

因此有些地方将其称之为保留字，其实保留字这个词应该有更广泛的意义，因为熟悉 C 语言的程序员都知道，在系统类库中使用过的有特殊意义的单词或单词的组合都被视为保留字。

Java 中支持带标签的 break 和 continue 语句，作用有点类似于 C 和 C++ 中的 goto 语句，但是正因为如同避免使用 goto 一样，应该避免使用带标签的 break 和 continue，因为它不会让你的程序变得更优雅，很多时候甚至有相反的作用。

所以可以在答案的最后加上一些自己的看法，比如说：goto 会破坏程序的可读性，java 中没有大范围使用 goto 反而是好事，而且还应该避免使用带标签的 break 语句。

关键字 switch

switch可作用于char byte short int

switch可作用于char byte short int对应的包装类

switch不可作用于long double float boolean，包括他们的包装类

switch中可以是字符串类型,String(jdk1.7之后才可以作用在string上)

switch中可以是枚举类型

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

参-：

相同点：

（1）不能直接实例化。如果要实例化，抽象类变量必须实现所有抽象方法，接口变量必须实现所有接口未实现的方法。

（2）都可以有实现方法（Java8 以前的接口不能有实现方法）。

（3）都可以不需要实现类或者继承者去实现所有方法（Java8 以前的接口，Java8 及以后的接口中可以包括默认方法，不需要实现者实现）。

不同点：

Java 创建对象的方式有哪些？

（1）使用 new 关键字；

（2）反射，使用 java.lang.Class 类的 newInstance 方法。

这种方式会调用无参的构造函数来创建对象，有两种实现方式。

//方式一，使用全路径包名 User user = (User)Class.forName("com.imooc.interview.demo.User").newInstance();　 //方法二,使用class类 User user = User.class.newInstance();

1

2

3

4

（3）反射，使用 java.lang.reflect.Constructor 类的 newInstance 方法。

Constructor constructor = User.class.getConstructor(); User user = constructor.newInstance();

1

2

（4）使用 clone 方法。

public class User implements Cloneable { /** 构造方法 */ public User(Integer age) { this.age = age; } public Integer getAge() { return age; } private Integer age; // 重写（Overriding）Object的clone方法 @Override protected User clone() throws CloneNotSupportedException { return (User) super.clone(); } public static void main(String[] args) throws Exception { User person = new User(new Integer(200)); User clone = person.clone(); System.out.println("person == clone, result = " + (person == clone)); // false，拷贝都是生成新对象 System.out.println("person.age == clone.age, result = " + (person.getAge() == clone.getAge())); // true，浅拷贝的成员变量引用仍然指向原对象的变量引用 } }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

首先需要明确两个概念：浅拷贝和深拷贝。

浅拷贝：被复制对象的所有变量都含有与原来的对象相同的值，对拷贝后对象的引用仍然指向原来的对象。

深拷贝：不仅要复制对象的所有非引用成员变量值，还要为引用类型的成员变量创建新的实例，并且初始化为形式参数实例值。

其他需要注意的是，clone () 是 Object 的 native 方法，但如果要标注某个类是可以调用 clone ()，该类需要实现空接口 Cloneable。

（5）使用反序列化。【深拷贝】

为了序列化 / 反序列化一个对象，需要该类实现空接口 Serializable。

序列化时首先创建一个输出流对象 oos, 使用 oos 的 writeObject () 方法将 p 对象写入 oos 对象中去。使用反序列化创建对象时，首先创建一个输入流对象 ois，使用输入流对象 ois 的 readObject () 方法将序列化存入的对象读出，重新创建一个对象。

java 中继承类用 extends，继承接口用关键字 implements。都是继承，为什么要用两个关键字呢？

面向对象的特征有哪些？

1.抽象：

抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。

2.继承：

继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。

3.封装：

封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。

4.多态性：

多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

override（重写，覆盖）和 overload（重载，过载）

重写(Override)也称覆盖，它是父类与子类之间多态性的一种表现，而重载(Overload)是一个类中多态性的一种表现。

什么是不可变对象？

参-：

不可变对象指对象一旦被创建，状态就不能再改变。任何修改都会创建一个新的对象，如 String、Integer及其它包装类。

Java 面向对象编程

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。