java面向对象的封装继承多态特性

  面向对象编程有三大特性，也有说四个特性的。我这里只说传统的三大特性：继承，封装，多态。

1.继承：

  在王者荣耀中，武器是物品的一种，也是有名称和价格。在设计这个类的时候，可以让武器继承物品，从而继承名称和价格属性。

  物品类Item，有属性name，price

public class Item {
    String name;
    int price;
}

  武器类：Weapon，不继承的写法

  独立设计name和price属性，同时多了一个属性，攻击力。

public class Weapon{
    String name;
    int price;
    int damage; //攻击力
 
}

  武器类：Weapon，继承的写法

  现在Weapon继承了Item，虽然Weapon自己没有设计name和price，但是通过继承Item类，也具备了name和price属性。

public class Weapon extends Item{
    int damage; //攻击力
     
    public static void main(String[] args) {
        Weapon infinityEdge = new Weapon();
        infinityEdge.damage = 65; //damage属性在类Weapon中新设计的
         
        infinityEdge.name = "无尽战刃";//name属性，是从Item中继承来的，就不需要重复设计了
        infinityEdge.price = 2070;
         
    }
     
}

2.封装：

  网上有一堆讲这个的概念的文字描述，我的理解就是保护类里面的属性和方法，防止被外部类定义的代码随机访问。还有一种理解就是面向接口编程，我定义一个抽象类（或接口），只给一个方法签名（只有修饰符（一般是public），返回值，方法名，参数），内部实现只有实现方看见，调用方只能使用这个方法。

  实现方式：

  成员变量（属性）和方法有如下的修饰符：

private 私有 本类才可以访问

package\default\不写（默认是这个）同一个包下的类可以访问

protected 受保护的 子类可以访问父类的

public 公共的 任意类都可以访问

各个修饰符有不同的访问这个成员变量（属性）或方法的权限。

public class Weapon{
    private String name;
    private int price;
    private int damage; //攻击力
    
    public String getName(){
        return this.name;
    }
  
    public void setName(String name){
        this.name = name;
    }

    public int getPrice(){
        return this.price;
    }
  
    public void setPrice(String price){
        this.price = price;
    }

    public int getDamage(){
        return this.danage;
    }
  
    public void setDamage(int damage){
        this.damage = damage;
    }
}

public class Test{
    public static void main(String[] args){
        Weapon weapon1 = new Weapon();
        weapon1.setName("无尽战刃");
        weapon1.setPrice(2070);
        weapon1.setDamage(60);
        System.out.println("武器名:"+weapon1.getName()+" 价格："+weapon1.getPrice()+" 伤害："+weapon1.getDamage());
    }
}

3.多态：

多态: 都是同一个类型，调用同一个方法，却能呈现不同的状态。

    父类  Item物品

package property;
 
public class Item {
    String name;
    int price;
 
    public void buy(){
        System.out.println("购买");
    }
    public void effect() {
        System.out.println("物品使用后，可以有效果 ");
    }
     
    public static void main(String[] args) {
        Item i1= new LifePotion();
        Item i2 = new MagicPotion();
        System.out.print("i1  是Item类型，执行effect打印:");
        i1.effect();
        System.out.print("i2也是Item类型，执行effect打印:");
        i2.effect();
    }
 
}

    子类1  LifePotion血瓶

package property;
 
public class LifePotion extends Item {
    public void effect(){
        System.out.println("血瓶使用后，可以回血");
    }
}

    子类2 MagicPotion蓝瓶

package property;
 
public class MagicPotion extends Item{
 
    public void effect(){
        System.out.println("蓝瓶使用后，可以回魔法");
    }
}

Item父类的主方法打印出来之后，同一个引用类型Item的变量t1，t2调用方法打印的内容不一样（一个回血，一个回蓝）。

同一个接口，使用不同的实例而执行不同操作。

多态存在的三个必要条件

    继承
    重写
    父类引用指向子类对象

最后，文章千千万，刚开始学习的概念总是那么的抽象难以记得，任何一门知识都是如此，只有自己不断地实践，学习和理解，才能消化这些知识，祝愿每一位努力的人都如尝所愿，有所造诣。