Java类成分图、面向对象简述

摘要: 一张图和java面向对象的一些概述

三大特征：

封装：将类的具体实现方式隐藏起来，提高代码安全性、复用性

继承：让类与；类直接产生关系，继承的过程就是从一般到特殊的过程。

多态：父类引用指向子类对象，提高了代码的扩展性。

包：

标识符都是小写

import：

导入类；静态导入

static：

作用：用于修饰成员（成员变量、成员方法）

何时用：

1、当类中有作为共享数据的成员变量，可以写成静态变量

2、当功能内部没有访问非静态数据时，可以写成静态函数

特点：

1、静态随着类的加载而加载，存在于方法区，随着类的消失而消失，生命周期最长。

2、优先于对象而存在，是所有对象的关系数据。（静态不能访问非静态数据，静态方法不可以有this、super关键字）

3、对共享数据进行单独存储，节省空间。

4、可以用类名直接调用（用于设计工具类）

弊端：

生命周期长；访问有局限性（只能访问静态）。

静态代码块：

随着类的加载而加载，用于给类进行初始化，只运行一次。

构造代码块：

随着每个对象的建立而运行，一个对象只运行一次。优先于构造函数运行，用于给所有对象进行初始化。

变量：

成员变量：

（包括非静态的实例变量、静态的类变量）

定义在类中，整个类都可以访问到。

随着类的加载而存在于堆内存中。

有默认初始化值。

局部变量：

定义在局部（方法中、语句中）。

存在于栈内存中，作为范围结束，会自动释放空间。

没有默认初始化值。

类变量：

（即静态变量，特性同static关键字描述。）

函数：

一般函数：

实现一些功能，被调用才会执行。

构造函数：

作用：

用于给对象进行初始化

特点：

名称与类名一致

没有返回值类型

可以不写return语句

注意：

1、如果类中没有构造函数，系统会默认加上一个空参数构造函数。

2、多个构造函数是以重载的形式存在的。

匿名对象：

当一个对象只调用一次方法时，可以用匿名对象。

匿名对象可以作为参数进行传递。

对象的初始化过程：

Person p = new Person("zhangsan",20);

1，因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。//栈内存中有了p对象

2，执行该类中的static代码块，如果有的话，给Person.class类进行初始化。

3，在堆内存中开辟空间，分配内存地址。

4，在堆内存中建立对象的特有属性。并进行默认初始化。

5，对属性进行显示初始化。//private String name = "hah";类声明属性时，有默认值

6，对对象进行构造代码块初始化。

7，对对象进行对应的构造函数初始化。

8，将内存地址赋给栈内存中的p变量。

内部类：

概述：

1、内部类的好处就是可以访问外部类的私有属性；而外部类要访问内部类属性，就先要建立内部类对象。

2、当内部类定义在局部位置时，可以访问类中的成员，但是只能访问局部中被final修饰的参数、变量。

3、外面访问的格式： 外部类.内部类 内部类对象名称 = new 外部类().new 内部类();

4、当内部类中定义了静态成员，那么内部类必须被静态修饰。被静态修饰的内部类就成了外部类，这时不可以访问外部类中非静态成员。（静态是修饰成员的，当内部类定义在局部时，不能定义静态成员）

（类可以被私有，当内部类定义在外部类成员位置时，可以被私有修饰。外部类不可以被私有，没有这种格式）

匿名内部类：

1，匿名内部类其实就是内部类的简写格式。

2，定义匿名内部类的前提：

内部类必须是继承一个类或者实现接口。（其实所有的类都满足，因为所有的类都有一个父类Object）

3，匿名内部类的格式： new 父类或者接口(){定义子类的内容}；（new 父类或者接口() 这一步在调用父类构造函数）

AbsDemo d = new AbsDemo(){ //覆写方法 }；多态，父类引用指向子类对象。这里虽然给new AbsDemo(){ //覆写方法 }；起了个名字，但这个是子类对象的名字，不是类的名字，类仍然是匿名内部类。

public static void show(Inter in){ } 方法中要传入一个接口类型的对象。这里可以用匿名内部类。

show(new Inter()

{

public void method()

{

System.out.println("method show run");

}

});

} 表示： 这个子类空间

) 表示：参数空间结束

; 表示：语句结束

final：

概述;

作为一个修饰符，可以修饰类、函数、变量

1、修饰类，类不可以被继承

2、修饰函数，函数不可以被覆写

3、修饰变量，这个变量就成了常量，只赋值一次。

继承：

（概述同上）

查阅父类功能，创建子类对象使用功能。

重载、覆写

重载：只看同名函数的参数列表

覆写：要一模一样

（函数名相同，参数列表相同，仅返回值不同，是同一个函数，不可以存在于同一个类中）

变量、函数、构造函数

变量：this访问本来对象；super访问父类对象

函数-覆盖：

覆盖时，需要保证子类的权限大于等于父类。

静态只能覆盖静态。

覆盖后，子类对象调用该函数，会运行子类函数的内容。

构造函数-子类的实例化过程：

1、子类的所有构造函数，默认都会访问父类的空参数构造函数。因为子类的构造函数第一行都有一句隐式的super语句。

2、如果父类中没有空参数构造函数，那么子类就要手动的通过spuer来指定访问父类的那一个构造函数。

3、当然子类的第一行也可以通过this语句指定访问本来中构造函数，但是子类中至少有一个构函会访问父类构函。

抽象类：

1、抽象类、抽象方法都要abstract声明

2、包含一个抽象方法的类必须是抽象类，抽象方法只需要声明不需要实现。抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

3、抽象类必须被子类继承，非抽象类子类必须覆写抽象类中的全部方法

4、抽象类不可以创建对象，抽象类中的抽象方法要被使用，必须由子类复写其所有的抽象方法后，建立子类对象调用。

接口：

接口用interface定义

接口中的成员都有固定修饰符。

常量：public static final

方法：public abstract

接口与接口之间是继承关系，而且可以多继承。接口不允许继承抽象类。

抽象类和接口异同：

相同：

1，都可以在内部定义抽象方法。

2，通常都在顶层。

3，都不可以实例化，都需要子类来实现。

不同点：

1，抽象类中可以定义抽象方法和非抽象方法，而接口中只能定义抽象方法。

2，接口的出现可以多实现。抽象类只能单继承。也就是说：接口的出现避免了单继承的局限性。

3，继承和实现的关系不一致。继承：is a，实现：like a

多态：

成员函数在多态调用时，编译看左边，运行看右边。（编译时，对象还没产生）

成员变量无论编译和运行，都参考左边(引用型变量所属的类)。

静态成员无论编译和运行，都参考做左边。即不会被覆盖。

1，多态的体现（父类或接口）

父类的引用指向了自己的子类对象。

父类的引用也可以接收自己的子类对象。

2，多态的前提

必须是类与类之间有关系。要么继承，要么实现。

通常还有一个前提：存在覆盖。

3，多态的好处

多态的出现大大的提高程序的扩展性。

4，多态的弊端

提高了扩展性，但是只能使用父类的引用访问父类中的成员。

异常：

问题分两种，一种是严重的erro一般不写针对性代码对其进行处理；一种是非严重的exception。

处理方法：捕获、抛出。

erro、exception都是Throwable子类

Throwable中的方法

l String getMessage() 获取异常信息，返回字符串。

l String toString() 获取异常类名和异常信息，以及异常出现在程序中的位置。

l void printStackTrace() 将异常信息输出到指定的PrintWriter。

l void printStackTrace(PrintWriter s) 通常用该方法将异常内容保存在日志文件中，以便查阅。

throws和throw

成对出现（除了RuntimeException时不需要throws）

throws用在函数上，后面跟异常类名。用于标识出函数的异常。l

throw用在函数内，用于抛出异常对象。

当函数内部用了throw关键字时，要么在内部trycatch，要么在函数上throws声明让，调用者处理。

因为父类已经把异常信息的操作都完成了，所以子类只要在构造时，只要将异常信息super传递给父类，那么就可以用getMessage方法获取自定义异常信息。

（可以这么理解，自定义的异常类只要写一个构造函数就行了。）

Class DemoException extends Exception

{

DemoException(String message)

{

super(message);

}

}

RuntimeException：

当有些异常出现时，程序无法继续运算，那么就要让程序停掉。否则异常被处理完，程序继续执行没有意义。

所以只需要在函数内抛出RuntimeException对象，不需要在函数上声明，所以调用者不知道有可能发生异常，所以也就不会用try catch处理，所以当发生异常时，程序会直接停掉。

1、RuntimeException以及其子类如果在函数中被throw抛出，可以不用在函数上声明。

2、一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类。

3、如果父类抛出多个异常，那么覆盖方法必须抛出那些异常的一个子集，不能抛出新的异常。