java面向对象必须掌握的知识点

1. 面向对象基础

1.1 什么是面向对象

对象是指具体的某一个事物，即现实生活中能够看得见摸得着的事物，比如生活中的一台电脑、一件衣服等都可以看做是对象。
在面向对象程序设计中，对象包含数据和动作，是数据和动作的结合体。

1.2 面向对象的三大特征

封装性：某些内容对外部不可见。比如一个女生不想别人知道自己的年龄，就需要把年龄进行封装，使得外界不能够知道她的年龄。
继承性：将其他的功能继承下来继续发展。比如儿子可以继承父亲的一些优良品格，但是儿子也有自己独立的不同于父亲的品格。
多态：对象的多种表现形式。比如每个人都具有运动的属性，但是每个人可以选择从事的运动方式会有不同。

1.3 类与对象的创建

类的创建格式：

class 类名{
	成员属性；
	成员方法；
}

类的创建例子：

class Person{
	String name;//成员属性
	//成员方法
	public void say(String name) {
		System.out.println("我是"+name);
	}
}

创建对象：

类名  对象名 = new 类名();
Person p = new Person();

调用属性与方法

p.name;//调用属性
p.say();//调用方法

1.4 对象创建的内存细节

java中栈用于存放局部变量，堆用于存放java对象实例。

1.5 构造方法

作用：用于对象初始化，在创建对象时自动调用。
定义的格式：与普通方法基本相同，区别在于方法名称必须与类名相同，没有返回值类型的声明。

class Person{
	Person(String n) {
		
	}
}

1.6 匿名对象

没有名字的对象就是匿名对象。

int sum = new Math2().sum(100, 200);
class Math2{
	int sum(int x , int y) {
		return x+y;
	}
}

2. 面向对象进阶

2.1 封装

目的：防止外部对属性进行修改和获取。
封装原则：隐藏对象的属性和实现细节，仅对外公开访问方法，并且控制访问级别。在开发中，为了避免出现逻辑错误，建议对所有属性封装，并为其提供setter和getter方法进行设置和取得操作。

class Person{
	private String name;//将名字私有化
	private int age;//将年龄私有化
	public String getName() {
		return name;
	}
	public void setName(String name1) {
		name = name1;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age1) {
		age = age1;
	}
	
}

2.2 this关键字

功能：
1.调用类中的属性。
2.调用类中的方法或构造方法（注意：在一个构造方法中调用另一个构造方法时，调用的代码必须编写在构造方法的第一行，这是为了避免操作对象时对象还没有构建成功。）。
3.表示当前对象。

class Person{
	private String name;
	private int age;
	Person(){}
	Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
}

2.3 静态static

作用：用来修饰成员变量和成员方法，创建独立于具体对象的域变量或方法（即static关键字修饰的方法或变量不需要依赖于对象进行访问，只要类被加载了就可以通过类名去访问，并且不会因为对象的多次创建而在内存中建立多份数据）。
注意：
1.静态成员在类加载时加载并初始化。
2.无论一个类存在多少个对象，静态的属性在内存中只有一份。
3.静态不能访问非静态，非静态可以访问静态；

Person.region;
class Person{
	static String region;
}

2.4 三种代码块

1.普通代码块：在执行的流程中出现的代码块。
2.构造代码块：对象创建时执行，随着对象的每次创建执行一次。
3.静态代码块：随着类的加载（第一次使用），静态代码块执行。
代码块执行顺序：3>2>1

class Person{
	static String region;
	{
		System.out.println("打印构造代码块");//构造代码块
	}
	public Person() {
		System.out.println("打印构造方法");//构造方法
	}
	static {
		System.out.println("打印静态代码块");//静态代码块
	}
}

3. 面向对象高级

3.1 继承

定义：继承就是子类继承父类的特征和行为，使得子类对象具有父类的实例域或方法，或子类从父类继承方法，使得子类具有父类相同的行为。
格式：

class 子类 extends 父类{}

注意：java中只有单继承，多重继承（C继承B，B继承A），没有多继承（一个类有多个父亲）。

3.2 super关键字

作用：可以访问父类的构造方法、属性和方法。

class Student extends Person {
	public Student() {
		super();
	}
}

注意：
1.调用super构造方法的代码必须卸载子类构造方法的第一行。
2.super是当前对象里面的父对象的引用。

3.3 重写与重载

重写规则：
1.参数列表必须完全与被重写方法相同。
2.返回值类型必须完全与被重写方法的返回类型相同。
3.访问权限不能比父类中被重写的方法的访问权限更低。
4.父类的成员方法只能被它的子类重写。
5.声明为static和private的方法不能重写，但是能够被再次声明。
重写与重载的区别：

区别类型	重载	重写
发生的位置	一个类中	子父类中
参数列表限制	必须不同	必须相同
返回值类型	与返回值无关	返回值类型必须一致
访问权限	与访问权限无关	子的访问权限不能小于父的访问权限
异常处理	与异常无关	异常范围可以更小，但不能抛出新的异常

3.4 final关键字

修饰属性和变量：变量变为了常量，无法再次进行赋值。如果修饰的是成员属性，必须在声明时赋值；修饰的是局部变量可以先声明后赋值。
public static final为全局常量，命名时单词所有字母大写，单词与单词之间用_隔开。如MAX_SUM。
修饰类：不可以被继承
修饰方法：不能被子类重写

3.5 抽象类与接口

3.5.1 抽象类

格式：abstract class 类名{}
抽象方法：只声明而未实现的方法称为抽象方法，必须用abstract关键字声明。

abstract class Person{
	public abstract void say();
}

使用原则：
1.本身不能直接实例化操作，即不能直接使用new关键字完成。
2.一个抽象类必须被子类所继承，被继承的子类必须重写抽象类中的全部抽象方法。

3.5.2 接口

定义：如果一个类中的全部方法都是抽象方法，全部属性都是全局常量，则定义为接口。
格式：

interface Person/*接口名称*/{
	String INFO;//全局常量
	void print();//抽象方法
}

接口的实现：
class 子类 implements 父接口1，父接口2…{}

3.5.3 抽象类与接口的区别

抽象类	接口
被子类继承	被类实现
可以声明抽象和非抽象	只能声明抽象方法
变量是普通变量	变量是公共的静态变量
无法多继承	可以多实现
可以包括static方法	不允许包括static方法
可有构造方法	不能有构造方法

3.6 多态

定义：对象的多种表现形式。
多态的实现方式：
1.子类就是父类的一种形态（对象多态性）。
2.方法的重载和重写也是多态的一种（方法的多态）。
多态的使用：
1.向上转型：将子类实例变为父类实例
父类 父类对象 = 子类实例；
2.向下转型：将父类实例变为子类实例
子类 子类对象 = （子类）父类实例；

3.7 内部类

定义：将一个类定义在另一个类里面或者一个方法里面。
分类：
1.成员内部类
2.局部内部类
3.匿名内部类
4.静态内部类