对于一个zero基础的小白学习到“Java的面向对象”那头不是一点点的大，头发瞬间感觉稀疏了不少，讲的啥？在干啥？我该从哪里下手？
问题一大堆，但是方法总比困难多，换一种思路或许就能豁然开朗。下面就是我整理的整个面向对象的知识点，希望能对大家学习面向对象有所帮助。（异常部分还没整理完待续......）
面向对象
类和对象
范围：类（Pet,Person）>对象（Student,Cat）>属性（name,age,health）
定义类
public class Person {
}
访问修饰符 class 类名{
}
定义方法
public void show(){
}
访问修饰符 返回值类型 方法名（）{
}
方法重写：
当父类方法不能满足子类需求，多个子类的属性不同，无法添加进父类的（子类）共有属性的时候，可以在子类中使用“supper.父类方法()”来调用父类中的子类共有的方法，下面再写子类独有的属性。
方法重载：
正常情况下，同一个类中不能定义多个相同名称的方法，这样会导致后面调用方法时候电脑无法识别你所调用的具体是哪一个方法。但是，在方法名称相同时，当方法的参数个数或者参数类型不同时候，是可以成立的，就实现了方法重载！
例①：
Public Student(){
}
Public Student(int age){
}
Public Student(int age,String name){
}
例②：
public void Demo003(int A){
}
public String Demo003(){
return Demo003();
}
public Demo003(int B,int A){
}
private Demo003(String C,String B){
}
构造方法
无参构造方法无返回值（void），需return一个返回值，方法名与类名相同。
Public Student(){
}
带参构造方法无返回值（void），需return一个返回值，方法名与类名相同。可以有参数。
String name;
Int age;
Public Student(String name;Int age;){
this.name = name;
this.age = age;
}
this指代当前构造器中的对象
this()特点：
1.必须在第一行
2.必须在构造器中
构造方法作用：创建对象，完成对象初始化。
语法结构：
Public person(){
}
访问修饰符 构造方法名（）{
}
封装与继承
封装的关键字：private
步骤：1.隐藏(private) 2.方法(get()/set()) 3.控制语句(if else)
封装：当某一个类中的属性，比如在一个Person类中的int age;属性，定义好了以后让客户去输入age的值，这个值可以输入一个任意的数字（-50，50，400......），在程序里面是不会报错的，这个值满足了int的类型。但是在现实生活中人的年龄并不会出现负数和400岁等，不符合常理，所以需要使用封装，将这个age限制起来，只能在一定的范围内给age 赋值。创建属性的时候在int 前面加上private。
setter/getter（公开的public修饰，快捷键：alt+shift+s==>Generate Getters and setters）
setter是用来设置一个值的，getter是用来读取一个值的。
例子：
package test;
public class Person{
private int age;
private String name = "张三";
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
static
普通成员变量：“类名 对象名 = new 类名();”通过“对象名.”的形式
①可以用来修饰
成员变量
静态变量，可以直接通过类名访问，比如：”Person.”的形式
成员方法
静态变量，可以直接通过类名访问
代码块
静态代码块，直接static{代码}
继承（关键字：extends）
语法： A extends B
(1)A类是B类的子类，B类是A的父类。
(2) java中只支持“单继承”(只有一个直接父类)。
使用继承可以将多个子类中相同的属性或方法提取出来放到同一个父类中，直接在父类中做一次声明，不需要在多个子类中重复声明，减少代码量。
Super()可以直接调用父类的属性，但必须在写第一行，必须在构造器当中。
public class Father{
String name = "张三";
}
public class Son extends Father{
String name = super.name;
}
public class Test{
public static void main(String[] args) {
Son son = new Son();
System.out.println(son.name);
}
}
多态（父类引用指向子类对象）
多态性是面向对象编程的一个重要特征,它是指在父类中定义的属性和方法被子类继承之后,可以具有不同的数据类型或表现出不同的行为,这使得同一个属性或方法在父类及其各个子类中具有不同的含义。比如：在游戏中，每一个角色都有一个动作“行走”，但是战士和法师的行走方式就不一样，但是他们都有“行走”这个父类，只不过走的方式在子类中自己定义就好了，以后再添加一个新的角色，直接继承“行走”这个父类，具体方式稍加修改就可以了。
public class Pet {//父类
public void eat(){
}
public class Cat extends Pet{//子类
public void eat(){
System.out.println("吃猫粮...");
}
public class Dog extends Pet{//子类
public void eat(){
System.out.println("吃狗粮...");
}
public class Master {
public void feed(Pet pet){
System.out.println("喂食...");
pet.eat();
}
public class Test {
public static void main(String[] args) {
Master master = new Master();
Pet pet =new Dog();//多态：父类引用指向子类对象（输出Dog子类的吃狗粮...）
master.feed(pet);
}
抽象类和抽象方法（关键词：abstract）
普通方法：
public class Pet {
public void eat(){
}
}
抽象方法：
public abstract class Pet {
public abstract void eat();
}
①抽象方法没有方法体。
②抽象方法必须在抽象类当中。
③抽象方法必须在子类中被实现，除非子类是抽象类。
接口（关键字：interface）
接口不能被实例化，默认使用Public abstract修饰。实现类必须实现接口的所有方法(implements 接口)接口中的常量都是用public static final修饰的。
在面向对象编程中可以有多继承!但是只支持接口的多继承,不支持“继承”的多继承。
接口有点类似于继承，可以放一起比较相同和不同点。继承可以理解为儿子继承父亲，父亲继承爷爷，这是一条单一的路线继承，且单个类只能继承一个父类。而接口相当于摄像头、电池、麦克风、屏幕等，一部手机拥有摄像头、电池、麦克风、屏幕，则摄像头、电池、麦克风、屏幕等都是手机的接口。接口是由一个类同时向多个类连接，而继承是类和类之间单线继承。
public interface Door {
public abstract void openDoor();
public abstract void closeDoor();
}
public interface Lock {
public abstract void openLock();
public abstract void closeLock();
}
public class SafeDoor implements Lock, Door{
public void closeDoor() {
System.out.println("关门....");
}
public void openDoor() {
System.out.println("开门....");
}
public void closeLock() {
System.out.println("上锁。。。。");
}
public void openLock() {
System.out.println("解锁。。。");
}
}
public class Test {
public static void main(String[] args) {
SafeDoor safeDoor = new SafeDoor();
safeDoor.openLock();
safeDoor.openDoor();
safeDoor.closeDoor();
safeDoor.closeLock();
}
}
//运行结果：
解锁。。。
开门....
关门....
上锁。。。。
异常
在程序运行中不生了“不正常”的事件，它会中断正在运行的程序。
异常处理5个关键字：try,catch,finally,throw,throws
try:尝试去执行这段代码；
catch：捕获异常；
finally：不管是否发生了异常，代码都会执行；
throw：手动抛出异常；
throws:声明可能出现的异常；
Try-catch异常三种情况
①正常情况无异常
public void method(){
try{
//代码段（此处可能会出现异常）
}
catch(异常类型){
//对异常进行处理的代码段
}
//异常处理之后需要继续进行的代码段
}
②出现异常，异常是一种特殊的对象，类型为Java.lang.Exception或其子类。
public void method(){
try{
//代码段1
//产生异常的代码段2
//代码段3
}
catch(Exception.e){
//对异常进行处理的代码段4
}
//异常处理之后需要继续进行的代码段
}
③异常类型不匹配，没有catch到真正的异常，代码段2出现问题，代码段3,4不会运行，程序中断运行。
public void method(){
try{
//代码段1
//产生异常的代码段2
//代码段3
}
catch(异常类型){
//对异常进行处理的代码段4
}
//异常处理之后需要继续进行的代码段
}
System.err.println("");
这段代码使用.err输出的信息会变成红色，起到警示作用！
e.ptintStackTrace();
帮助我们输出具体的异常或者名称，和位置。上面报错的位置可能不是具体的位置，也可能是由于报错位置前面的代码出错导致了这边的错误。
System.err.println(e.getMessage());
可以帮助我们输出造成异常的原因，描述异常信息字符串，属于e.ptintStackTrace()异常的一部分。
常见的异常类型
InputMismatchException 输入不匹配异常
ArithmeticException 算术异常
ArrayIndexOutOfBoundsException 数组下标越界异常
NullPointerException 空指针异常
NumberFormatException 数字格式转换异常
Exception 异常层次结构的父类
ClassNotFoundException 不能加载所需的类
LllegalArgumentException 方法接收到非法参数
ClassCastException 对象强制类型转换出错
在try-catch块后面加入finally块，无论是否发生异常都会执行。但是当catch块后面加了System.exit(1)则会中断操作，不会再去执行finally块。
在try-catch-finally块中存在return，先执行finally，然候return结束方法。
在try-catch-finally结构语句中，try语句块是必须要有的，catch和finally是可选的，两者至少出现一个。
引发多种类型的异常（多catch）
排列catch语句的顺序：先子类后父类
发生异常时候按顺序逐个匹配
只执行第一个与异常类型匹配的catch语句