一、封装（Encapsulation）
封装也称信息隐藏，是指利用抽象数据类型把数据和基于数据的操作封装起来，使其成为一个不可分割的整体，数据隐藏在抽象数据内部，尽可能的隐藏数据细节，只保留一些接口使其与外界发生联系
封装性的思想：
- 将类的属性私有化
- 提供公共的方法（setter & getter）来实现调用
package com.yyx.pratice; /** * JavaBean */ public class Person { private String name; private Integer age; public Person() { super(); } public Person(String name, Integer age) { super(); this.name = name; this.age = age; } /* * 封装属性 */ public String getName() { return name; } public void setName(String name) { this.name = name; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } }
二、继承（Inheritance）
继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力
继承所表达的就是一种对象类之间的相交关系，它使得某类对象可以继承另外一类对象的数据成员和成员方法。
若类B继承类A，则属于B的对象便具有类A的全部或部分性质(数据属性)和功能(操作)，我们称被继承的类A为基类、父类或超类，而称继承类B为A的派生类或子类
注意：java中类的继承性只支持单继承：一个类只能继承一个父类。反之，一个父类可以有多个子类；一个接口可以有多个父类，也就是接口可以是多继承
子类实例化对象会先创建父类的对象
package com.yyx.pratice; public class Person { private String name; private Integer age; public Person() { super(); System.out.println("我是父类的空参构造器"); } public Person(String name, Integer age) { super(); this.name = name; this.age = age; System.out.println("我是父类的有参构造器"); } public String getName() { return name; } public void setName(String name) { this.name = name; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } public void eat() { System.out.println("吃饭!"); } public void walk() { System.out.println("走路!"); } }
package com.yyx.pratice; public class Student extends Person { private String stuNo; public Student() { super(); } public Student(String name, Integer age, String stuNo) { super(name, age); this.stuNo = stuNo; } public String getStuNo() { return stuNo; } public void setStuNo(String stuNo) { this.stuNo = stuNo; } @Override public void eat() { super.eat();// 显示调用父类的eat()方法 System.out.println("我重写了父类的eat()方法"); } public void study() { System.out.println("子类自己的study()方法"); } }
package com.yyx.pratice; public class JavaPratice { public static void main(String[] args) { Student student=new Student(); student.eat(); student.walk(); student.study(); Student stu=new Student("李四", 23, "1232"); stu.eat(); stu.walk(); stu.study(); } }
运行结果：
我是父类的空参构造器
吃饭!
我重写了父类的eat()方法
走路!
子类自己的study()方法
我是父类的有参构造器
吃饭!
我重写了父类的eat()方法
走路!
子类自己的study()方法
三、多态（Polymorphism）
多态性，可以理解为一个事物的多种表型形态。 两种表现形式：1）方法的重载与重写 2）子类对象的多态性
子类对象的多态性即父类的引用指向子类对象，父类引用只能调用父类中存在的方法和属性，不能调用子类的扩展部分，因为父类引用指向的是堆中子类对象继承的父类；
但是如果强制把超类转换成子类的话，就可以调用子类中新添加而超类没有的方法了；同时，父类中的一个方法只有在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用；
对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接
子类对象的多态性使用的前提：①要有类的继承或实现②要有子类对父类方法的重写
程序运行分为编译状态和运行状态。对于多态性来说，编译时，"看左边"，将此引用变量理解为父类的类型；运行时，"看右边",关注于真正对象的实体：子类的对象。那么执行的方法就是子类重写的
package com.yyx.pratice; public class JavaPratice { public static void main(String[] args) { Person person = new Student(); person.eat();// 只能调用子类已经重写的父类Person的eat()方法 if (person instanceof Student) { Student stu1 = (Student) person; /* * 调用子类才有的方法 */ stu1.study(); stu1.walk(); } Behavior behavior = new Student(); behavior.walk();// 只能调用子类已经重写的接口Behavior的walk()方法 if (behavior instanceof Student) { Student stu2 = (Student) behavior; /* * 调用子类才有的方法 */ stu2.study(); stu2.eat(); } } } class Student extends Person implements Behavior { @Override public void eat() { super.eat(); } @Override public void walk() { System.out.println("人都要走路"); } public void study() { System.out.println("学生要学习"); } } class Person { public void eat() { System.out.println("人都要吃饭"); } } interface Behavior { void walk(); }
