一、Java 多态：

多态是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口，使用不同的实例而执行不同的操作。多态性是对象多种表现形式的体现。

多态的优点：消除类型之间的耦合关系；可替换性；可扩充性；接口性；灵活性；简化性。

多态存在的三个必要条件：继承；重写、父类引用指向子类对象。

class Shape {
     void draw() {}
} 
class Circle extends Shape {
      void draw() {
         System.out.println("Circle.draw()");
     }
} 
class Square extends Shape {
     void draw() {
         System.out.println("Square.draw()");
     }
} 
class Triangle extends Shape {
     void draw() {
         System.out.println("Triangle.draw()");
      }
}

多态的实现方式：

1、重写;

2、接口;

3、抽象类和抽象方法。

二、Java抽象类：

在面向对象的概念中，所有的对象都是通过类来描述的，但并不是所有的类都用来描述对象。如果一个类中没有包含足够的信息来描述一个具体的对象，那这样的类就是抽象类。

抽象类不能实例化，所以，抽象类碧玺被继承，才能被使用。在Java中抽象类表示一种继承关系，一个类只能继承一个抽象类。

在Java语言中，使用abstract class来定义抽象类：

public abstract class Employee {

private String name;

private String address;

private int number;

public Employee(String name, String address, int number) {

System.out.println("Constructing an Employee");

this.name = name;

this.address = address;

this.number = number;

}

public double computePay() {

System.out.println("Inside Employee computePay");

return 0.0;

}

public void mailCheck() {

System.out.println("Mailing a check to " + this.name + " " + this.address);

}

public String toString() {

 return name + " " + address + " " + number;

}

public String getName() {

return name;

}

public String getAddress() {

return address;

}

public void setAddress(String newAddress) {

address = newAddress;

}

public int getNumber() {

return number;

}

}

继承抽象类：

public class Salary extends Employee {

private double salary; //Annual salary

public Salary(String name, String address, int number, double salary) {

super(name, address, number);

setSalary(salary);

}

public void mailCheck() {

System.out.println("Within mailCheck of Salary class "); System.out.println("Mailing check to " + getName() + " with salary " + salary);

}

public double getSalary() {

return salary;

}

public void setSalary(double newSalary) {

if(newSalary >= 0.0) {

salary = newSalary;

}

}

public double computePay() {

System.out.println("Computing salary pay for " + getName());

return salary/52;

}

}

抽象方法：Abstract关键字用来声明抽象方法，抽象方法只包含一个方法名，没有方法体，抽象方法没有定义，方法名后面直接跟一个分号，而不是花括号。

public abstract class Employee {

private String name;

private String address;

private int number;

public abstract double computePay();

//其余代码

}

三、Java封装：

封装是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。封装可以被认为是一个保护屏障，放置该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制。实现java封装的步骤：

1. 、修改属性的可见性来限制对属性的访问（一般限制为private）
2. 、对各个值的属性提供对外的公共方法访问，即创建一对赋取值方法，用于对私有属性的访问。

public class EncapTest{

 private String name;

private String idNum;

private int age;

public int getAge(){

return age;

}

 public String getName(){

 return name;

}

public String getIdNum(){

return idNum;

 }

public void setAge( int newAge){

age = newAge;

}

public void setName(String newName){

name = newName;

}

public void setIdNum( String newId){

 idNum = newId;

}

}

四、Java接口：

接口（interface），在java编程语言中是一个抽闲类型，是抽象方法的集合，接口通常以interface来声明，一个类通过继承接口的方式，从而来继承接口的抽象方法。接口并不是类，类描述对象的属性和方法，接口则包含类要实现的方法。接口无法被实例化，但可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。

接口的声明：

[可见度] interface 接口名称 [extends 其他的接口名] {

// 声明变量

// 抽象方法

}

接口的语法：

...implements 接口名称[, 其他接口名称, 其他接口名称..., ...] ...

五、Java枚举：

Java枚举是一个特殊的类，一般表示一组常量。Java枚举类使用enum关键字来定义，各种常量使用逗号，来分隔。

enum定义的枚举类默认继承了java.lang.Enum类，并实现了 java.lang.Serializable 和 java.lang.Comparable 两个接口。values(), ordinal() 和 valueOf() 方法位于 java.lang.Enum 类中：values() 返回枚举类中所有的值；ordinal()方法可以找到每个枚举常量的索引，就像数组索引一样；valueOf()方法返回指定字符串值的枚举常量。

六、Java 包：

Java包用于区别类名的命名空间。包的作用：1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用；2、如果文件夹以信仰，包采用树形目录的存储方式，同一个包中的类名是不同的，不同包中的类名是可以相同的。当同时调用不同包中相同类名的类时，加上包名加以区别，可以避免名字冲突；3、包限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

Java使用包这种机制是为了防止命名冲突，访问控制，提供搜索和定位类、接口、枚举和注释等。

包语句的语法：package pkg1[．pkg2[．pkg3…]];

在Java中，import关键字用于导入其他类或包中定义的类型，以便在当前源文件中使用这些类型，import语句的语法：

import package1[.package2…].(classname|*);