封装
封装就是将对象的属性和方法相结合，通过方法将对象的属性和实现细节保护起来，实现对象的属性隐藏。做法就是：修改属性的可见性来限制对属性的访问，并为每个属性创建一对取值（getter）方法和赋值（setter）方法，用于对这些属性的访问。
public class Person
{
private String name; //姓名
private int age; //年龄
private String phone; //联系电话
private String address; //家庭住址
public String getName()
{
return name;
}
public void setName(String name)
{
this.name=name;
}
public int getAge()
{
return age;
}
public void setAge(int age)//封装的常用表现，在内部进行业务逻辑的控制，外部只调用即可
{
if(age<18||age>40)//对年龄进行限制
{
System.out.println("年龄必须在18到40之间！");
this.age=20; //默认年龄
}
else
{
this.age=age;
}
}
public String getPhone()
{
return phone;
}
public void setPhone(String phone)
{
this.phone=phone;
}
public String getAddress()
{
return address;
}
public void setAddress(String address)
{
this.address=address;
}
}
继承
继承是代码复用的一种形式，即在具有包含关系的类中，从属类继承主类的全部属性和方法，从而减少了代码冗余，提高了程序运行效率。例如，一个矩形（Rectangle类）属于四边形（Quadrilateral），正方形、平行四边形和梯形同样都属于四边形。从类的角度来解释，可以说成 Rectangle 类是从 Quadrilateral 类继承而来的，其中 Quadrilateral 类是基类，Rectangle 类是派生类。
继承是通过扩展其他类而形成新类来实现的，原来的类称为父类（super class）或基类，新类称为原来类的子类或派生类。在子类中，不仅包含父类的属性和方法，还可以增加新的属性和方法，使得父类的基本特征可被所有子类的对象共享。类的继承并不改变类成员的访问权限。也就是说，如果父类的成员是公有的、被保护的或默认的，它的子类仍具有相应的这些特性。
class class_name extends extend_class
{
//类的主体
}
public class Person
{
public String name; //姓名
public int age; //年龄
public String sex; //性别
}
public class Student extends Person
{
private String stuNo; //学号
private String department; //所学专业
}
//学生继承了人类，同时具有了，姓名、年龄、性别属性
多态
多态性是面向对象编程的又一个重要特征，它是指在父类中定义的属性和方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为，这使得同一个属性或方法在父类及其各个子类中具有不同的含义。
对面向对象来说，多态分为编译时多态和运行时多态。其中编译时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的方法。通过编译之后会变成两个不同的方法，在运行时谈不上多态。而运行时多态是动态的，它是通过动态绑定来实现的，也就是大家通常所说的多态性。
public class Figure
{
double dim1;
double dim2;
Figure(double d1,double d2)//有参的构造方法
{
this.dim1=d1;
this.dim2=d2;
}
double area()//用于计算对象的面积
{
System.out.println("通过多态，在子类中重写。");
return 0;
}
}
public class Rectangle extends Figure
{
Rectangle(double d1,double d2)
{
super(d1,d2);
}
double area()
{
System.out.println("长方形的面积：");
return super.dim1*super.dim2;
}
}
public class Triangle extends Figure
{
Triangle(double d1,double d2)
{
super(d1,d2);
}
double area()
{
System.out.println("三角形的面积：");
return super.dim1*super.dim2/2;
}
}
public static void main(String[] args)
{
Figure figure; //声明Figure类的变量
figure=new Rectangle(9,9);
System.out.println(figure.area()); //输出：长方形的面积：81。
figure=new Triangle(6,8);
System.out.println(figure.area()); //输出：三角形的面积：24。
}
重载
重载是 Java 多态性的表现。在 Java 语言中，同一个类中的两个或多个方法可以共享同一个名称，只要它们的参数声明不同即可，这种情况被称为方法重载
在 JDK 的 java.io.PrintStream 中定义了十多个同名的 println() 方法
public void printin(int i){…}
public void println(double d){…}
public void println(String s){…}
System.out.println(102); //调用println(int i)方法
System.out.println(102.25); //调用println(double d)方法
System.out.println("价格为 102.25"); //调用println(String s)方法
方法重载时必须要注意以下两点：
重载方法的参数列表必须和被重载的方法不同，并且这种不同必须足以清楚地确定要调用哪一个方法。
重载方法的返回值类型可以和被重载的方法相同，也可以不同，但是只有返回值类型不同不能表示为重载。
pubic class Person{
private String name;
//方法一
public Person(){
}
//重载方法，可直接设置姓名
public Person(String _name){
this.name = _name;
}
}
重写
子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写，又称为方法覆盖。
在重写方法时，需要遵循下面的规则：
参数列表必须完全与被重写的方法参数列表相同，否则不能称其为重写。
返回的类型必须与被重写的方法的返回类型相同，否则不能称其为重写。
访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private）。
重写方法一定不能抛出新的检査异常或者比被重写方法声明更加宽泛的检査型异常。例女口，父类的一个方法声明了一个检査异常 IOException，在重写这个方法时就不能抛出 Exception，只能拋出 IOException 的子类异常，可以抛出非检査异常。
public class Person
{
public String name; //名字
public int age; //年龄
public Person(String name,int age)
{
this.name=name;
this.age=age;
}
public String getInfo()
{
return "我叫"+name+"，今年"+age+"岁";
}
}
public class Student extends Person
{
private String hobby;
public Student(String name,int age,String hobby)
{
super(name,age);
this.hobby=hobby;
}
public String getInfo()
{
return"我叫"+this.name+"，我今年"+this.age+"岁，我爱吃"+hobby+"。";
}
}
public static void main(String[] args)
{
Person person=new Student("小明",20,"鸡");
System.out.println(animal.getInfo()); //输出：我叫小明，我今年20岁，我爱吃鸡。
}