封装多态抽象类接口

声明：转自shiyanlou.com

封装

封装，即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别

我们在开汽车的时候，只用去关注如何开车，我们并不在意车子是如何实现的，这就是封装。这样做有什么好处？

只能通过规定的方法访问数据

隐藏类的实例细节，方便修改和实现。

如何去实现类的封装呢？

修改属性的可见性，在属性的前面添加修饰符(private)

对每个值属性提供对外的公共方法访问，如创建 getter/setter（取值和赋值）方法，用于对私有属性的访问

在 getter/setter 方法里加入属性的控制语句，例如我们可以加一个判断语句，对于非法输入给予否定。

public class People {
//属性（成员变量）有什么，前面添加了访问修饰符private
//变成了私有属性，必须通过方法调用
    private double height;     //身高

//属性已经封装好了，如果用户需要调用属性
//必须用getter和setter方法进行调用
//getter和setter方法需要程序员自己定义
    public double getHeight(){    
    //getter 方法命名是get关键字加属性名（属性名首字母大写）
    //getter 方法一般是为了得到属性值
        return height;
    }

//同理设置我们的setter方法
//setter 方法命名是set关键字加属性名（首字母大写）
//setter 方法一般是给属性值赋值，所以有一个参数
    public void setHeight(double newHeight){
        height = newHeight;
    }
}

public class NewObject {
    public static void main(String[] args) {
        People LiLei = new People();
        LiLei.setHeight(170.0);
        System.out.println(LiLei.getHeight());
    }
}

多态

多态是指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。多态也称作动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

通俗地讲，只通过父类就能够引用不同的子类，这就是多态，我们只有在运行的时候才会知道引用变量所指向的具体实例对象。

Java 实现多态有三个必要条件：继承、重写、向上转型（即父类引用指向子类对象）。只有满足上述三个条件，才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。<p>

class Animal {
    //父类方法
    public void bark() {
        System.out.println("动物叫！");
    }
}

class Dog extends Animal {
    //子类重写父类的bark方法
    public void bark() {
        System.out.println("汪、汪、汪！");
    }
    //子类自己的方法
    public void dogType() {
        System.out.println("这是什么品种的狗？");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal a = new Animal();
        Animal b = new Dog();
        Dog d = new Dog(); 

        a.bark();    //动物叫！
        b.bark();    //汪、汪、汪！
        //b.dogType(); 
        //编译不通过
        d.bark();    //汪、汪、汪！
        d.dogType();
    }
}

抽象类

什么时候会用到抽象类呢？

在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。也就是说，抽象类是 约束子类必须要实现哪些方法，而并不关注方法如何去实现。

从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。

那抽象类如何用代码实现呢，它的规则如下：

用 abstract 修饰符定义抽象类

用 abstract 修饰符定义抽象方法，只用声明，不需要实现

包含抽象方法的类就是抽象类

抽象类中可以包含普通的方法，也可以没有抽象方法

抽象类的对象不能直接创建，通常是定义引用变量指向子类对象。

//抽象方法
public abstract class TelePhone {
    public abstract void call();  //抽象方法,打电话
    public abstract void message(); //抽象方法，发短信
}

public class CellPhone extends TelePhone {

    @Override
    public void call() {
        System.out.println("我可以打电话！");
    }

    @Override
    public void message() {
        System.out.println("我可以发短信！");
    }

    public static void main(String[] args) {
        CellPhone cp = new CellPhone();
        cp.call();
        cp.message();
    }
}

接口

接口用于描述类所具有的功能，而不提供功能的实现，功能的实现需要写在实现接口的类中，并且该类必须实现接口中所有的未实现方法。在Java8中：

interface不能用于实例化对象
interface中方法只能是abstract方法、default 方法、static方法
interface成员是 public static final 类型
interface支持多继承

在Java9中，接口可以拥有 private 方法和 private final 方法，但是只能被该接口中的 default 方法和 static 方法使用。

多继承实现方式：

修饰符 interface A extends 接口1，接口2{
}

修饰符 class A implements 接口1，接口2{
}

封装 多态 抽象类 接口

声明：转自shiyanlou.com

封装

多态

抽象类

接口

友情链接更多精彩内容

封装多态抽象类接口