java面向对象的三大特性（封装、继承、多态）

1、封装

将同一类事物的特征和功能包装在一起，只对外暴露需要调用的接口而已。想让你看到的你就看得到，不想让你看到的就见不到。对于封装也称为信息的隐藏，体现的最淋漓尽致的地方就是来定义接口了，在接口中我们没有任何功能的实现，只是定义了一系列抽象的方法声明。在Java中接口是体现封装最常用的方法

1、封装的概念： 将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来对隐藏的信息进行操作和访问。

2、好处： （1）只能通过规定的方法访问数据 （2）隐藏类的实例细节，方便修改和实现。

3、封装的实现步骤 （1）修改属性的可见性设为（private） （2）创建getter/setter方法（用于属性的读写）（通过这两种方法对数据进行获取和设定，对象通过调用这两种发方法实现对数据的读写） （3）在getter/setter方法中加入属性控制语句（对属性值的合法性进行判断 ）

/**
 * @author EA_emran
 	用户类
 */
public class FenZhuang {

    private int id;

    private int age;

    private String name;

    private char gender;

    private String password;

    public void show(){
        System.out.println("用户编号：" +this.id);
        System.out.println("用户名：" +this.name);
        System.out.println("密码：" +this.password);
        System.out.println("性别：" +this.gender);
        System.out.println("年龄：" +this.age);
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        if (id<0){
            this.id = 1;
        }else {
            this.id = id;
        }
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

/**
 * @author EA_emran
 测试类
 */
public class Test {
    public static void main(String[] args) {
        FenZhuang user = new FenZhuang();
        user.setAge(21);
        user.setName("小王");//放值
        user.setGender('男');
        user.setPassword("emran123456789");
        user.setId(-1);
        System.out.println(user.getName());//获取值
        user.show();
    }
}

2、继承

所谓继承是Java中面向对象最显著的一个特征，继承是从已有的类中派生出新的类，新的类可以吸收已有的属性、行为，并扩展新的能力。在Java中不支持多继承，单继承使Java的继承关系很简单，一个类只能有一个父类，这样易于我们的管理，同时父类也是子类的抽象化，而子类反过来就是父类的具体化.

代码可以复用

继承(extends)只要解决的问题是：共性抽取

 

在继承的关系中,子类可以被当做父类看待定义父类的格式：

（一个普通的类定义）

public class 父类名称{

}

定义子类的格式：

public class 子类名称 extends 父类名称{

}

变量名相同情况下

局部变量： 直接写

本类成员变量： this.成员变量名

父类的成员变量：super.成员变量名

3、多态

多态是三大特性中最后出现也是最重要的特性，前面的封装和继承都是为多态来服务的。

多态是同一个行为具有多个不同表现形式或形态的能力

1、多态的理解：一个事物的多种形态或一个行为的多种表现形式

2、何为多态性：对象的多态性:父类的引用指向子类的对象（或子类对象赋给父类的的引用）

3、多态的使用：虚拟方法调用有了对象的多态性以后，在编译期间我们只能调用在父类中声明的方法，但运行期间我们实际执行的是子类重写父类的方法

4、多态的使用前提：1没有继承关系就没有多态、2、方法的重写

5、对象的多态性只适用于方法，不适用于属性(编译与运行都看左)

public class Person {
    String name;

    int age;

    int id=44;

    public  void eat(){
        System.out.println("吃");
    }

    public  void walk(){
        System.out.println("走");
    }
}

public class Man extends Person{
    boolean isSmoking;
    int id=1222;

    public  void earnMoney(){
        System.out.println("男人赚钱养家");
    }
    @Override
    public  void eat(){
        System.out.println("多吃肉，也长肉");
    }

    @Override
    public  void walk(){
        System.out.println("走路，减肥");
    }


}

public class Women extends Person{
    boolean isBeauty;

    public  void goShopping(){
        System.out.println("女人喜欢购物");
    }

    @Override
    public  void eat(){
        System.out.println("少吃，减肥");
    }

    @Override
    public  void walk(){
        System.out.println("窈窕走路");
    }
}
public class PersonTest {
    public static void main(String[] args) {

        Person person1 = new Person();
        person1.eat();

        Man man = new Man();
        man.eat();
        man.age=10;
        man.earnMoney();
        //对象的多态性:父类的引用指向子类的对象
        Person p1 = new Man();

        Person p2 = new Women();
        //多态的使用：当调用父类同名同参数的方法时，实际调用的是子类重写父类的方法---虚拟方法调用
        p1.eat();
        p1.walk();

        p2.age = 88;
        System.out.println(p1.id);

    }
}