Java三大特性---封装，继承，多态

封装

• 封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口。
• java中可以通过关键字private，protected、default和public实现封装。

封装的作用：

1、封装能够减少耦合

2、类内部结构可以自由修改

3、对成员变量进行更精确的控制

代码实例

public class Person{
   private String name;//定义私有属性
   private int age;
}

在上面这段代码中，把属性定义成private私有的，只能在本类中访问，其他类访问不了。

  public class Person{
    private String name;
    private int age;​
    public int getAge(){//成员属性的get方法
         return age;
    }​
    public String getName(){
         return name;
    }
    public void setAge(int age){//成员属性的set方法
        this.age = age;
    }
    public void setName(String name){
       this.name = name;
    }
  }

在上面这段代码中，实现私有属性的get和set方法，并定义成public公共访问权限。

public方法是外部类访问该类成员变量的入口。通常我们把定义私有属性会选择实现属性的getter和setter方法，以实现被任何类调用。

具体如何调用通过如下例子说明：

public class Student{
    public static void main (String[] args){
         Person p = new Person(); //实例化Person对象
         p.setName("张三");//设置name的值
         p.setAge(19);    // 设置age的值

        System.out.println("我叫"+p.getName+"，我今年"+p.getAge+"岁");
    }
}

输出结果：

 我叫张三，我今年19岁

继承

• 继承的关键字 ：extends
• 继承的语法结构： class 子类名 extends 父类名{ }
• 子类就是当前的类，父类就是需要继承的类，子类能获得父类的属性和方法，子类也具有父类的功能，并且子类还具有自己特殊的功能。
• 在Java中，一个类只能有一个父类，也就是说java只支持单继承。
• 一个类如果没有明确写出继承哪个类，默认会继承Object类，也就是任何类的超类。

代码实例：

public class Person{  //定义父类
    public String name="张三";
    public int age = 20;
}

.定义父类，父类中有name，age属性，并为其赋值。

public class Student extends Person{//子类继承父类
    void Study(){
       System.out.println(name+"在学习");
    }
}

.定义子类，继承父类，子类中有自己的方法Study();

public class Test{//测试类
public static void main(String[] args){
    Student stu = new Student();//实例化子类
    stu.Study();   //调用子类方法
    System.out.print("名字：" + stu.name  + "，年龄：" + stu.age);//调用父类属性
    }
}

输出结果：

张三在学习
名字：张三，年龄：20

在测试类中，实例化子类。通过代码，我们可以发现子类能有自己特殊的方法，也可以调用父类属性。

重载

• 重载（Overload）就是方法名相同，参数列表不同。参数列表也就是参数的类型，参数的个数和参数的顺序这三者只要有一个不相同那就值得是参数列表不同。
• 重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。

代码实例：

 class A(){
    public void test(){
        System.out.print("无参方法被调用了");
    }
    public int test(int num){
        System.out.print("int类型的方法被调用了");
    }
    public String test(String str){
        System.out.print("String类型的方法被调用了");
    }
}

创建一个A类，定义三个方法，分别是无参的方法、返回int类型的方法和返回String类型的方法。

 class B{
   public static void main(String[] args) {
    A a = new A();
    a.test();
    a.test(1);
    a.test("abc");
   }
}

创建一个B类，实例化A类并调用A类中的三个方法。

通过代码我们发现，在A类中的三个方法的方法名相同，但是参数类型不同，在B类中，调用相同方法名的三个方法，只要传入不同的参数类型就可以调用。

重写

• 重写（Override）就是父类中的某些方法不能满足要求是，子类继承父类需要重写父类中的方法，子类需要调用父类的方法时，需要使用super()关键字。
• 子类重写父类的方法时，方法名称，参数列表，返回类型必须完全相同，而且子类的访问修饰符权限不能比父类低。
• 被重写的方法不能是final类型的，因为final修饰的方法时无法重写的。
• 被重写的方法也不能是static修饰的。

代码实例：

 public class A{
 public void test(){
     int num=10;
     System.out.println(num);
    }
 }

创建一个A类，A类中有个test()方法，定义num值为10；

public class B extends A{
@Override
public void test() {
    int num = 11;
    System.out.println(num);
   }
}

创建一个B类，继承A类，并重写test()方法，定义num值为11；

public class Test {

public static void main(String[] args) {
    B b = new B();
    b.test();
   }
}

创建一个Test类，实例化B类，也就是子类，调用子类test()方法。

输出结果为：

11

多态

含义：多态字面就是就是一个事物多种形态，专业定义为：多态就是父类引用指向子类对象。

举例来说：person为父类，student为子类。那么：person p=new student()；

实现多态的条件：

• 继承。 在多态中必须有继承关系的子类和父类。
• 重写。 子类对父类的某些方法重新定义，在调用这些方法时就会调用子类的方法。
• 转型（向上）。 在多态中需要将子类的引用指向父类的对象，只要这样该引用才能够具备调用父类的方法和子类的方法。

代码实例：

public abstract class Animal {

private String name;

public Animal(String name) {
    this.name = name;
}
public String getName() {
    return name;
}
public abstract void eat();

}

创建一个抽象的Animal类，定义私有属性name，实现name的get和set方法。定义一个抽象方法eat();

public class Dog extends Animal{

public Dog(String name) {
    super(name);
    // TODO Auto-generated constructor stub
}
@Override
public void eat() {  // 重写父类中eat()方法
    System.out.println(getName()+"吃肉");

}

}

创建一个Dog类，继承Animal类，并重写eat();方法。

public class Cat extends Animal{

public Cat(String name) {
    super(name);
    // TODO Auto-generated constructor stub
}
@Override
public void eat() {  // 重写父类中eat()方法
    System.out.println(getName()+"吃鱼");
}
}

创建一个cat类，也继承Animal类，同样重写eat();方法。

public class AnimalTest {
public static void main(String[] args) {
    Animal dog = new Dog("狗");// 父类引用指向子类对象。
    Animal cat = new Cat("猫");
    eat(cat);  
    eat(dog);
}
public static void eat(Animal animal){
    animal.eat();
}

}

创建一个AnimalTest类。

输出结果：

猫吃鱼
狗吃肉

从代码我们可以看出，要想实现多态，必须继承父类，并且重写父类中的方法，然后再测试类用父类引用指向子类对象来实现相应功能。