继承封装多态

封装

• 封装值得就是我们面向对象的一些属性，方法去封起来，尽可能的去隐藏其中实现的细节，我们去给定一下特定的接口去进行赋值和调用，而不是完全的暴露出来。

  • 例如：

：

 class Encapsulation{
 private String name; 
private int age;
    public fengzhuang(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
public void show() {
        System.out.println("名字为"+name+"年龄为："+age);
 }

• 从代码中我们可以看到，属性已经私有化了，我们不让对象去直接赋值，而是通过暴露出来的构造方法或者get set方法去赋值和使用。这就是我们上文所说的把我们需要暴露的地方暴露出来，而不是把所有的逗暴露出来，我们需要尽可能的隐藏起来。

  • 好处：

  引用百度百科：

  • ① 对象的数据封装特性彻底消除了传统结构方法中数据与操作分离所带来的种种问题，提高了程序的可复用性和可维护性，降低了程序员保持数据与操作内容的负担。

  • ②对象的数据封装特性还可以把对象的私有数据和公共数据分离开，保护了私有数据，减少了可能的模块间干扰，达到降低程序复杂性、提高可控性的目的。

继承

• 继承就是老子和儿子的关系，儿子有父类的所有成员，同时可以在这个基础上扩展出自己特有的成员。很好的吻合了 开闭原则。

  • 继承关键字： extends

开闭原则：对修改关闭，对扩展打开.

我们去继承上边的代码：

public class test extends Encapsulation{

    public test(String name, int age) {
        super(name, age);
        // TODO Auto-generated constructor stub
    }
@Override
public void show() {
    // TODO Auto-generated method stub
    super.show();
}
public static void main(String[] args) {
        test t=new test("小明", 10);
        t.show();
    }
}

• 我们可以看到，在子类里可以直接调用父类的方法进行重写,也可以调用父类的属性。

  运行结果：名字为小明年龄为：10

• 在main方法中，我们直接实例化出来子类，并且在构造方法中去赋值，因为子类继承父类，所以子类的值直接赋值给父类，并且调用父类的show方法去显示

多态

• 多态作用： 降低耦合度

• 多态的必要条件：

  1. 要有继承；

  2. 要有重写；

  3. 父类引用指向子类对象。

  我们继续用上边的代码后边加一个类：

  public static  class test1 extends Encapsulation{
      private int studengNum;
        public test1(String name, int age,int studengNum) {
            super(name, age);
            this.studengNum=studengNum;

            // TODO Auto-generated constructor stub
        }
        @Override
        public void show() {
            // TODO Auto-generated method stub

            System.out.println("名字为"+getName()+"年龄为："+getAge()+"学号:"+studengNum);
        }
    }
        public static void main(String[] args) {
            fengzhuang t=new test("小明", 10);
            fengzhuang t1=new test1("小掌柜",10,1456);
            t.show();
            t1.show();
        }

运行结果：

名字为小明年龄为：10
名字为小掌柜年龄为：10学号:1456

• 我们可以看到这句话：

：

Encapsulation t=new test("小明", 10);
Encapsulation t1=new test1("小掌柜",10,1456);

都是名字”Encapsulation ” 的父类去指向子类，而不同的子类去调用其不同的方法。

重写 重载

重写：重写父类的方法，参数和返回值必须一样，而方法里的具体执行可以不同。在方法前用 “@override”去判定是否为重写

上述父类代码：

public void show() {
    System.out.println("名字为"+name+"年龄为："+age);
}

子类重写：

@Override
public void show() {

        System.out.println("名字为"+getName()+"年龄为："+getAge()+"学号:"+studengNum);

    }

重载：除却方法名必须相同之外，传入参数必须不同。

上述构造方法：

public test1(String name, int age,int studengNum) {
        super(name, age);
        this.studengNum=studengNum;

    }

重载方法：

 public test1() {
        // TODO Auto-generated constructor stub
    }

结束

        ----------2017年6月14日00:15:22 syf