Java知识整理——面向对象

一、基础知识

（1）、面向对象的编程关注于类的设计

（2）、成员变量 vs 局部变量

相同点：遵循变量声明的格式、都有作用域

不同点：声明的位置、修饰符、初始化值、内存中位置、生命周期

局部变量：方法局部变量、代码块局部变量

（3）、两同：同名、同参 两小：返回值类型、异常类型 一大：访问权限

（4）、每个子类构造方法的第一条语句,都是隐含地调用super(),如果父类没有这种形式的构造函数,那么在编译的时候就会报错

父类中没有无参构造，可以显示调用父类带参完成父类的初始化

（5）、类对象的属性赋值：默认初始化、显式初始化、构造器初始化、"对象.方法"赋值

（6）、super(...) this(...) 必须是第一条语句

（7）、this关键字：使用在类中,可以用来使用属性、方法、构造器

（8）、垃圾回收：protected void finalize() throws Throwable

（9）、static可以用来修饰属性、方法、代码块（或初始化块）、内部类

（10）、静态的结构(static的属性、方法、代码块、内部类)的生命周期要早于非静态的结构,同时被回收也要晚于非静态的结构

（11）、super,可以修饰属性、方法、构造器：显式的调用父类的指定属性或方法

通过“super(形参列表)”,显式的在子类的构造器中,调用父类指定的构造器！

（12）、权限从大到小为：public（公共） protected（子类） 缺省（包） private（私有）

二、内部类访问特点

内部类可以直接访问外部类的成员,包括私有的。外部类不可以直接访问内部类成员,外部类要想访问内部类成员就必须要创建对象访问

成员内部类：

创建对象格式：外部类名.内部类名 对象名 = new 外部类对象().new 内部类对象();

修饰符:可以有访问修饰符、final

class文件名：外部类类名$内部类类名.class

常用修饰符：private为了保证数据的安全性,static 为了方便访问数据

静态内部类：

创建对象格式：外部类名.内部类名 对象名 = new 外部类对象.内部类对象();

方法（局部）内部类：

可以直接访问外部类成员(包括私有)

class文件名是：外部类类名$+序号+内部类类名.class

可以在局部位置创建内部类对象,通过对象调用内部类的方法

局部内部类访问局部变量必须用final修饰

原因：局部变量是随着方法的调用而存在,随着方法的调用完毕而消失,但是堆中的内容并不会马上消失。所以要加上final修饰,变量变成常量,就会存在常量池中,因为方法调用完了就消失了

匿名内部类：

匿名类会生成OuterClass$+序号.class文件，数字根据是第几个匿名类而类推

（局部内部类的特例）由于没有类名,所以在产生对象是时候用语句告诉虚拟机它的结构,而且只能用一次。

三、Java帮助文档

格式：javadoc -d 目录（文件夹路径） -author -version 文件名.java

@author 标识一个类的作者

@version 指定类的版本

@param 说明一个方法的参数

@return 说明返回值类型

四、类的初始化过程

Dog dog = new Dog()在内存中都做了哪些操作

加载Dog.class文件进内存

在栈内存给dog变量开辟空间

在堆内存中给Dog对象开辟空间

给对象的成员变量进行默认初始化

给对象的成员变量进行显示初始化

给对象的成员变量进行构造初始化

把对象的地址值赋值给了dog变量

五、main方法

public static void main(String[] args){}

public:公共,被jvm调用的,访问权限要够大

static：静态,被jvm调用,不用创建对象,方便jvm调用

void：被jvm调用，不需要给jvm返回值

main: 一个通用的名字,不是关键字,但是能被jvm识别

String[] args：是一个字符串数组,没有Scanner之前用来接收键盘录入的

六、继承

（1）、Java官方文档的解释：子类不能继承父类的私有属性，但是如果子类中公有的方法影响到了父类私有属性，那么私有属性是能够被子类使用的

（2）、继承的好处：提高了代码的复用性、维护性

弊端：类的耦合性增强

（3）、开发原则：低耦合,高内聚

七、多态

（1）、多态：就是用基类的引用指向子类的对象。

（2）、多态下成员访问特点

成员变量：编译看左边,运行看左边

成员方法：编译看左边,运行看右边

构造方法：创建子类对象,会访问父类构造方法,对父类进行数据初始化

静态方法：编译看左边,运行看左边，(静态和类相关,不算重写,所以,访问的是左边的)

（5）、多态的优点和缺点：

多态的好处[工具类]：提高了程序的维护性（继承）、提高了程序的扩展性（多态）

多态的弊端：无法访问子类中特有的功能

如何访问到子类中特有的功能：用多态转型。

（6）、多态性的表现：①方法的重载（传入不同对象）与重写②子类对象的多态性

（2）、Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定,运行时类型由实际赋给该变量的对象决定。若编译时类型和运行时类型不一致,就出现多态

（5）、子类可看做是特殊的父类,所以父类类型的引用可以指向子类的对象：向上转型(upcasting)

（6）、一个引用类型变量如果声明为父类的类型,但实际引用的是子类对象,那么该变量就不能再访问子类中添加的属性和方法

（7）、虚拟方法调用(多态情况下)

Person e = new Student();

e.getInfo();//调用Student类的getInfo()方法

（8）、编译时类型和运行时类型

编译时e为Person类型,而方法的调用是在运行时确定的,所以调用的是Student类的getInfo()方法——动态绑定

（9）、向下转型(对Java对象的强制类型转换称为造型)

①向下转型,使用强转符：()

②为了保证不报ClassCastException(类型转换异常),最好在向下转型前,进行判断： instanceof

boolean result = object instanceof class

如果 object 是 class 的一个实例,则 instanceof 运算符返回 true。如果 object 不是指定类的一个实例,或者 object 是 null,则返回 false。

八、 异常

（1）、体系结构

|--java.lang.Throwable

        |--java.lang.Error：错误，java程序对此无能为力，不显式的处理

        |--java.lang.Exception:异常。需要进行处理

                |----RuntimeException:运行时异常

                        |---ArrayIndexOutOfBoundsException/NullPointerException

                        |-----ArithmeticException/ClassCastException

                |--非RuntimeException:编译时异常

（2）、异常分类

因为java程序分为javac.exe和java.exe两个过程，在每个过程中，都有可能出现异常。故分为编译时异常、运行时异常 对于运行时异常比较常见，可以不显式的来处理，对于编译时异常，必须要显式的处理 编译时异常，不是说有异常才处理，而是存在异常的隐患，必须在编译前，提示程序，万一出现异常，如何处理

（3）、java 中的“抓抛模型”

"抛"：当我们执行代码时，一旦出现异常，就会在异常的代码处生成一个对应的异常类型的对象，并将此对象抛出。(自动抛出/手动抛出) >一旦抛出此异常类的对象，那么程序就终止执行 >此异常类的对象抛给方法的调用者。 "抓"：抓住上一步抛出来的异常类的对象。如何抓？即为异常处理的方式 （4）、异常处理的两种方式

【处理的方式一】

  try--catch--finally

注意： 1、catch及finally是可选的。

2、getMessage();获得错误信息

printStackTrace();在控制台打印出异常种类，错误信息和出错位置等 3、try-catch是可以嵌套的。

4、System.exit(0)表示推出当前的虚拟机。

【处理方式二】

在方法的声明处，显式的使用throws+异常类型

（5）、手动抛出一个异常

在方法的内部，可以使用throw+异常类对象，来手动的抛出一个异常！

（5）、自定义一个异常类

1、自定义的异常类继承现有的异常类

2、提供一个序列号，提供几个重载的构造器

public class Demo {
	public static void main(String[] args) {
		try {
			int result = divide(4,0);
			System.out.println(result);
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("程序继续执行");
	}
	public static int divide(int i, int j) throws DivideByMinusException {
		if (j<0) {
			//使用throw关键字声明异常对象
			throw new DivideByMinusException("被除数是负数",100);
		}
		return i/j;
	}
}
class DivideByMinusException extends Exception {
    static final long serialVersionUID = 1L;
    private int idnumber;
    public DivideByMinusException(String message, int id) {
		super(message);
		this.idnumber = id;
 	} 
	public int getId() {
		return idnumber;
 	}
}