一、封装
封装，即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别；将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和方法都是类的成员。封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，以特定的访问权限来使用类的成员。
-
理解
- 开车时，我们不需要知道发动机的运转原理；
- 开飞机时，我们不需要知道是什么驱动螺旋桨来转动的；
-
思想
- 高内聚，低耦合；
-
原则
- 把尽可能多的东西藏起来.对外提供简捷的接口，尽量降低对外的暴露；
- 把所有的属性藏起来；
如何实现封装：
1、权限修饰符
-
public
- 公开的，作用范围一个工程内；
-
protected
- 保护的，作用范围一个体系内；
-
默认
- 默认的，作用范围一个包内；
-
private
- 私有的，作用范围一个类内；
作用点：
- 修饰类
- 修饰方法
- 修饰属性
- 修饰构造器
总结：
- 在不同的包内，只能调用修饰符为public的属性和方法；
- 在不同的包内，如果是继承父类，则可调用修饰符为public和protected的属性和方法；
- 在同一个包内，可以调用修饰符为public、protected和默认的属性和方法；
- 在同一个包内，如果是继承父类，则可调用修饰符为public、protected和默认的属性和方法；
2、getter&setter方法
我们先来看下面一个类：
public class User { private Integer id; private String name; private Integer age; public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } 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; } @Override public String toString() { return "User{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + '}'; } }
再来看下这个类中getter和setter方法的调用
public class Test { public static void main(String[] args) { User user = new User(); user.setId(1); System.out.println("id = " + user.getId()); user.setName("jack"); System.out.println("name = " + user.getName()); user.setAge(25); System.out.println("age = " + user.getAge()); System.out.println("user = " + user); } }
private的属性只有对象自己才可以访问，其他任何对象不行，包括它的子类和父类。安全性高，其他对象只能通过它的public方法（getter&setter）来获取或设置原对象的private属性。如果属性设置为public，其他对象可以直接访问，安全性就不高了。定义为private，实现数据的隐藏和封装；
3、静态工厂方法（of）
我们再来看下下面这个类：
public class User { private Integer id; private String name; private Integer age; private User() { } private User(String name) { this(); this.name = name; } private User(Integer id, String name) { this(name); this.id = id; } private User(Integer id, String name, Integer age) { this(id,name); this.age = age; } public static User of() { return new User(); } public static User of(String name) { return new User(name); } public static User of(Integer id, String name) { return new User(id, name); } public static User of(Integer id, String name, Integer age) { return new User(id, name, age); } public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } 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; } @Override public String toString() { return "User{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + '}'; } }
可以看到，我们在类中提供了多个 public 的方法 of()，返回的是该类的对象，这样我们使用时就不用再 new 一个对象出来，只要使用 User.of() 方法就可以了，如下：
public class Demo { public static void main(String[] args) { User user = User.of(1,"jack", 22); System.out.println("user = " + user); } }
类中的 of() 是我们自己定义的名称，可以根据传入的参数不同来自定义，其中除了可以返回当前类的对象，还可以返回其子类的对象。
二、继承
-
优点
- 减少了重复代码的编写，提高了代码的复用性；
-
语法
- extends关键字
- class Sub extends Super {}
-
注意
- Java中不支持多继承，一个类只能继承自一个父类；
- 可以多个子类继承同一个父类；
- 多层继承时，继承依然有效；
-
思考
- 实例化子类时，父类会被实例化吗？
super关键字：
-
定义
- 指向父类的指针；
-
作用
- 在子类中，调用父类的属性、方法、构造器；
-
语法
- super.name
- super.run()
- super("jack", 35)
-
注意
- super查找顺序是先找自己的直接父类；
- super调用父类的构造器必须在首行；
总结：
-
语法
- 基于关键字extends实现类和类之间的继承关系；
- 实现继承之后，属性、方法等都会被子类继承；
- 在子类中如果有和父类相同的属性和方法，且想调父类的实现时，可使用关键字super；
-
思想
- 把相同的东西抽出来，don't copy yourself；
-
继承的弊端
- 破坏了类的封装性；
三、多态
多态，简单解释就是一种事物的多种形态，我们先来看下以下几段代码：
public class Car { /** * 品牌 */ private String brand; /** * 排量 */ private String output; /** * 速度 */ private int speed; public Car(String brand, String output) { this.brand = brand; this.output = output; } public int getSpeed() { return speed; } public void setSpeed(int speed) { this.speed = speed; } public String getBrand() { return brand; } public void setBrand(String brand) { this.brand = brand; } public String getOutput() { return output; } public void setOutput(String output) { this.output = output; } }