面向对象的编程思想力图使计算机语言中对事物的描述与现实世界中该事物的本来面目尽可能的一致。即：分析问题时，以问题所涉及的事或物为中心的分析方式，具体的事或物就称为对象。
● 面向对象的三大特征
○ 继承 (Inheritance)
○ 封装 (Encapsulation)
○ 多态 (Polymorphism)

一、基本概念

1.1 类

类(class)和对象(object)是面向对象方法的核心概念。类是对一类事物描述，是抽象的、概念上的定义（归纳和整理）；对象是实际存在的该类事物的每个个体，因而也称实例(instance)。（例如：动物是一个类，猫是类的一个对象；类设计的可大可小，例如也可以将猫设计为一个类，波斯猫是一个实例）

1.2 属性

所谓属性，其实就是类的对象的相同特征（例如猫、狗都有耳朵）。

变量和属性的区别？

1. 变量的作用域非常小，只在当前的大括号内有效
2. 属性不仅仅在当前类中有效，而且可以随着对象在其他地方使用
3. 变量使用前必须初始化，否则会出现错误；属性可以不用初始化，因为JVM会帮助我们自动完成初始化，默认初始化的值取决于属性的类型。
   • 基本数据类型，默认值
     byte ,short, int ,long => 0
     float, double => 0.0
     boolean flg = false
     char = 空字符
   • 引用数据类型 => null

1.3 方法

所谓方法，其实就是类的对象的相同行为和功能（例如猫、狗都可以跑）。

1.4 静态

针对于具体对象的属性/方法称之为对象属性/方法，成员属性/方法，实例属性/方法。把和对象无关，只和类相关的称之为静态。和类相关的属性称之为静态属性 ，和类相关的方法称之为·静态方法

静态语法：就是在属性和方法前增加static 关键字

public class Test{public static void main(String[] args) {User.Sleep();System.out.println(User.name);}
}
class User{public static String name= "a ha";public static void Sleep() {System.out.println("睡觉...");}
}

注意点

• 成员方法可以访问静态属性和静态方法。
• 静态方法不可以访问成员属性和成员方法。

静态代码块和代码块

1. 类的信息加载完成后，会自动调用静态代码块，可以完成静态属性的初始化功能
2. 对象准备创建时，也会自动调用代码块，但不是静态的.
3. 执行的顺序如下代码所示：

public class Java08_Object_Static_2 {public static void main(String[] args) {/*静态代码块执行1静态代码块执行2静态代码块执行3test...*/User.test();/*静态代码块执行1静态代码块执行2静态代码块执行3代码块执行1代码块执行2*/new User();	}
}
class User{static {// 静态代码块System.out.println("静态代码块执行1");}static {// 静态代码块System.out.println("静态代码块执行2");}static void test() {System.out.println("test...");}{System.out.println("代码块执行1");}static {// 静态代码块System.out.println("静态代码块执行3");}{System.out.println("代码块执行2");}
}

1.5 包

1. 基本语法： package 包完整路径; 路径中的多个包使用点隔开，例如：package java.lang;
2. 功能：package中容纳类，主要功能用于分类管理
3. 一个类可以没有包，但是package不可以在同一个源码文件中使用多次
4. 包名为了区分类名，所以一般全部都是小写。例如：java.lang.Object 这样我们一看就指定Object是类名。
5. Java中存在不同包的相同名称的类，可以使用包进行区分
6. 一般情况下，在使用类的情况下，我们都会使用类的全名（包名+ 类型），称为全类名.

1.6 import

1. import 主要用于在使用类前准备好了。
2. import语句只能使用在package后，class前。
3. import关键字可以多次使用，导入多个类
4. 如果同一个包中需要导入大量的类，那么可以使用通配符* 号来简化操作。
5. 如果import了不同包中相同名称的类，那么还是需要在使用时增加包名。
6. 本类包中的类，可以不需要导入

import java.sql.Date;
import java.util.*;

二、高级概念

2.1 构造方法

1. 构造方法：专门用于构建对象
2. 如果一个类中没有任何的构造方法，那么JVM会自动添加一个公共的，无参的构造方法，方便对象的调用
3. 基本语法： 类名() {}
4. 构造方法名和类名完全相同
5. 如果类中有构造方法，那么JVM不会提供默认的构造方法
6. 构造方法也是方法，所以也可以传递参数，但是一般传递参数的目的是用于对象属性的赋值。
7. 类中的代码块是在构造方法之前执行的。

2.2 继承

1. 类存在父子关系：子类可以直接获取到父类的成员属性和成员方法。
2. 类的继承只能是单继承，一个类只能有一个父类，不能存在多个父类。
3. 一个父类可以有多个子类。
4. 语法： 子类 extends 父类

2.3 super & this

1. 如果父类和子类含有相同的属性，那么可以采用特殊的关键字进行区分，super & this
2. this 关键字默认可以不写，默认就是当前的。
3. this 和super 不能再静态代码块和静态方法中，因为这两个关键字默认是对象中的。

class Parent {String name = "zhangsan";
}
class Child extends Parent {String name = "lisi";void test() {System.out.println(super.name);System.out.println(this.name);System.out.println(name);}
}

2.4 多态

1. 所谓的多态，其实就是一个对象在不同场景下表现出来的不同状态和形态。
2. 多态语法其实就是对对象的使用场景进行了约束。
3. 一个对象可以使用的功能取决于引用变量的类型。

public class Test{public static void main(String[] args) {Person p = new Person();p.testPerson();Person p1 = new Boy();p1.testPerson();//p1.testBoy();	//不可以Person p2 = new Girl(); p2.testPerson();//p2.testGirl(); //不可以Boy boy = new Boy();boy.testBoy();Girl girl = new Girl();girl.testGirl();}
}class Person {void testPerson() {System.out.println("test person...");}
}
class Boy extends Person {void testBoy() {System.out.println("test boy...");}
}
class Girl extends Person {void testGirl() {System.out.println("test girl...");}
}

2.5 方法重载

1. 一个类中，不能重复声明的相同的方法，也不能声明相同的属性
2. 这里相同的方法指的是方法名，参数列表相同,和返回值类型无关
3. 如果方法名相同，但是参数列表（个数，顺序，类型）不相同，会认为是不同的方法，只不过名称一样，这个操作在Java称之方法的重载
4. 构造方法也存在方法的重载。

2.6 方法重写

1. 方法的重写：父类对象的方法其实主要体现通用性，无法在特殊的场合下使用。
2. 如果子类对象需要在特殊的场合下使用，那么就需要重写方法的逻辑，这个操作在Java中称之为方法重写
3. 这里的重写，并不意味着父类的方法被覆盖掉，只是在当前场合不使用。如果使用super关键字还是可以访问
4. 方法重写的要求：子类的方法和父类的方法，方法名相同，返回值类型相同，参数列表要相同

2.7 访问权限

Java中的访问权限主要分为4种：

1. private : 私有的, 同一个类中可以使用 （同类）
2. (default) : 默认权限, 当不设定任何权限时，JVM会默认提供权限，包(路径)权限，即：同一个包下可以使用，子包也不可以访问（同类，同包）
3. protected : 受保护的权限, 子类可以访问。（同类、同包、子类。）
4. public : 公共的, 任意使用

2.8 内部类

1. 外部类：所谓的外部类，就是在源码中直接声明的类
   • Java不允许外部类使用private, protected修饰
2. 内部类：所谓的内部类，就是类中声明的类
   • 内部类就当成外部类的属性使用即可

public class Test{public static void main(String[] args) {OuterClass outer = new OuterClass();OuterClass.InnerClass innerClass = outer.new InnerClass();}
}
class OuterClass {public class InnerClass {}
}

2.9 final

1. Java中提供了一种语法，可以在数据初始化后不允许被修改,使用关键字final
2. final 可以修饰变量：变量的值一旦初始化后无法修改
3. final可以修饰属性：那么JVM无法自动进行初始化，需要自己进行初始化, 属性值不能发生变化
4. 一般将final修饰的变量称之为常量，或者叫不可变变量
5. final可以修饰方法，这个方法不能被子类重写
6. final可以修饰类，这样类就没有子类了
7. final不可以修饰构造方法
8. final可以修饰方法的参数，一旦修饰，参数就无法修改。

2.10 抽象

1. 抽象类 : 不完整的类，就是抽象类
   a. abstract class 类名
   b. 因为类不完整，所以无法直接构造对象
   c. 如果一个类是抽象类，它的方法不一定是抽象方法。

2. 抽象方法 ： 只有声明，没有实现的方法
   a. abstract 返回值类型 方法名（参数）
   b. 如果一个类中含有抽象方法，那么这个类是抽象类
   c. 抽象类无法直接构建对象，但是可以通过子类间接构建对象
   d. 如果抽象类中含有抽象方法，那么子类继承抽象类，需要重写抽象方法，将方法补充完整。

3. abstract关键字不能和final同时使用。（因为final不允许有子类或方法不能被子类重写）

2.11 接口

1. 所谓的接口，可以简单理解为规则
   a. 基本语法 ： interface 接口名称 { 规则属性，规则的行为 }
   b. 接口其实是抽象的，所以无法构建对象
   c. 规则的属性必须为固定值，而且不能修改。
   d. 属性和行为的访问权限必须为公共的。
   e. 属性应该是静态的，和某个对象无关
   f. 行为应该是抽象的，由每一个具体的对象补充完整
2. 接口和类是两个层面的东西
   a. 接口可以继承其他接口
   b. 类的对象需要遵循接口，在java中，这个遵循，称之为实现(implements )，类需要实现接口,而且可以实现多个接口.

2.12 匿名类

1. 在某些场合下，类的名字不重要，我们只想使用类中的方法或功能。那么此时我们可以采用特殊的语法：匿名类
2. 所谓的匿名类，就是没有名字的类

public class Test{public static void main(String[] args) {Me me = new Me();me.sayHello( new Person() {public String name() {return "wangwu";}});}}class Me {public void sayHello(Person person) {System.out.println("Hello " + person.name());}
}
abstract class Person {public abstract String name();
}