Java是一门面向对象的语言，不同于C语言的面向过程的是，Java中编写代码都是基于对象的。但是写了这么多代码，还是不能完整的表达出Java面向对象四大特征的一些特性，实践是基于理论的 ，于是总结一下：
抽象就是说把一些具有相同特征的对象的共同特征抽取出来，构成一个类，类的属性便是这些对象共有的特征。抽象只关注对象的哪些属性和行为,并不关注这此行为的细节是什么。
封装就是将类中属性即成员变量以及操作成员变量的方法绑定起来，对数据的访问只能通过已定义的接口。可以说，封装就是隐藏一切可以隐藏的东西，只向外界提供最简单的接口，封装给对象提供了隐藏内部特性和行为的能力，对象提供一些能这被其它对象访问的方法来改变它内部的数据。
1.提供构造方法(有了构造方法才能通过new去构建一个对象 1.构造方法必须和类名称一样2.构造方法不能有返回值)，如果没有设置构造方法，会默认生成一个无参构造方法。
1 private Integer id; 2 private String name; 3 private Integer age; 4 private String gender; 5 6 public Person() { 7 } 8 9 public Person(Integer id, String name, Integer age, String gender) { 10 this.id = id; 11 this.name = name; 12 this.age = age; 13 this.gender = gender; 14 }
构造方法也可以进行重载，这也是类中多态的表现，也叫编译时多态，下面将会讲解多态
1 public Person(Integer id, String name, Integer age, String gender) { 2 this.id = id; 3 this.name = name; 4 this.age = age; 5 this.gender = gender; 6 } 7 8 public Person(Integer id, Integer age, String gender) { 9 this.id = id; 10 this.age = age; 11 this.gender = gender; 12 this.name = "andy"; 13 }
2.静态代码块(做的类的初始化的工作,执行在new之前)
说到静态代码块，就得说一下类的加载过程，类加载总共经过这几个步骤：加载（将.class文件加载到jvm虚拟机)->验证(验证代码的格式，变量的类型，方法的返回值等等是否正确)->准备(这一步也就是将方法区的静态变量，静态代码块中的内容，常量啊等等赋予初始值，如Integer就为0，引用类型就为null等等)->解析(解析就是将代码中的符号引用变为直接引用，符号引用是以字面量的实形式明确定义在常量池中，直接引用是指向目标的指针，或者相对偏移量)->初始化->使用->销毁
1 static { 2 System.out.println("注册"); 3 4 System.out.println("报到"); 5 6 }
3. 控制访问，权限关键字
如成员变量被private修饰，则只在当前类可以访问，于是便实现了屏蔽了外部来直接访问类内部的数据，而是通过类的内部接口即setter和getter来访问其成员变量和修改成员变量，但修饰的只是当前对象的，并没有改变类中的数据。
1 public Integer getId() { 2 return id; 3 } 4 5 public void setId(Integer id) { 6 this.id = id; 7 } 8 9 public String getName() { 10 return name; 11 } 12 13 public void setName(String name) { 14 this.name = name; 15 } 16 17 public Integer getAge() { 18 return age; 19 } 20 21 public void setAge(Integer age) { 22 this.age = age; 23 } 24 25 public String getGender() { 26 return gender; 27 } 28 29 public void setGender(String gender) { 30 this.gender = gender; 31 }
目的：对父类和方法的复用，也可以说是对父类的扩展。
继承是从已有类得到继承信息创建新类的过程,继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段。子类继承父类属性(静态特征)和方法(动态特征)，继承必须遵循封装当中的控制访问。
Peson类中定义的通用方法
1 public void eat(){ 2 System.out.println("吃东西"); 3 }
子类Student继承Person，定义了自己的成员变量，定义了自己特有的方法，当然也可以对父类方法进行重写，这是多态中的内容。
1 public class Student extends Person { 2 3 private String classId; 4 5 public Student() { 6 } 7 8 public Student(Integer id, Integer age, String gender,String classId) { 9 super(id, age, gender); 10 this.classId = classId; 11 } 12 13 public void shangke(){ 14 System.out.println("去上课"); 15 } 16 }
1 Student student = new Student(1,21,"boy","3年2班"); 2 System.out.println(student); 3 student.eat(); 4 student.shangke();
运行结果：
1、 重载:同一个动作作用在同一个对象上拥有不同的解释 ，在同一个类中，方法的参数列表不同，用关键字注解@overload
如Person类重载的构造方法：
public Person(Integer id, String name, Integer age, String gender) { this.id = id; this.name = name; this.age = age; this.gender = gender; } public Person(Integer id, Integer age, String gender) { this.id = id; this.age = age; this.gender = gender; this.name = "andy"; }
重载又称静态多态，编译时多态
2、 重写:
父类引用指向子类对象，在编译时，student就是Person对象，只能调用Person类中的方法，但在运行时，进行动态绑定，调用的却是子类重写父类中调用的那个方法。
1 Person person = new Student(1,21,"boy","3年2班"); 2 person.eat();
public void eat(){ System.out.println("吃东西"); } }
@Override public void eat() { System.out.println("吃饭"); }
同一个动作作用在不同的对象上拥有不同的解释 ，在子类与父类中，子类重写父类的方法，用关键字注解@override
重写又称动态多态，运行时多态
原文：https://www.cnblogs.com/zxgCoding/p/13725770.html