java封装与多态

在每个类的内部,都有一个隐含的成员变量,该类的类型就是该类的类型,该成员变量的名称是this,this是一个引用,指向自身的对象。

this的使用

  1. this调用本类中的属性,也就是类中的成员变量
  2. this调用本类中的其他方法
  3. this调用本类中的其他构造方法,调用时要放在构造方法的首行

封装

封装的含义?

  • 隐藏对象内部的复杂性,只对外公开简单的接口,便于外界使用,从而提高系统的扩展性、可维护性
  • 是面向对象方法的重要原则,就是把对象的属性和操作或服务结合为一个独立的整体,并尽可能隐藏对象的内部实现细节。
  • 封装可以被认为是一个保护屏障,防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据,必须通过严格的接口控制。
  • 封装最主要的功能在于我们能修改自己的实现代码,而不用修改那些调用我们代码的程序片段。适当的封装可以让程式码更容易理解与维护,也加强了程式码的安全性。

封装的优点:

  1. 良好得封装可以降低耦合
  2. 类内部得结构可以自由修改
  3. 可以对成员变量进行更精确得控制
  4. 隐藏信息,实现细节

实现封装步骤

1.修改属性得可见性来限制对属性得访问

public class Person{
	private String name;
	private int age;
}

2.对每个值属性提供对外得公共方法访问,也就是创建一对赋取值方法,用于对私有属性得访问

public class Person{
    private String name;
    private int age;public int getAge(){
      return age;
    }public String getName(){
      return name;
    }public void setAge(int age){
      this.age = age;
    }public void setName(String name){
      this.name = name;
    }
}

完整示例:
EncapTest.java

/* 文件名: EncapTest.java */
public class EncapTest{
 
   private String name;
   private String idNum;
   private int age;
 
   public int getAge(){
      return age;
   }
 
   public String getName(){
      return name;
   }
 
   public String getIdNum(){
      return idNum;
   }
 
   public void setAge( int newAge){
      age = newAge;
   }
 
   public void setName(String newName){
      name = newName;
   }
 
   public void setIdNum( String newId){
      idNum = newId;
   }
}

以上实例中public方法是外部类访问该类成员变量的入口。

通常情况下,这些方法被称为getter和setter方法。

因此,任何要访问类中私有成员变量的类都要通过这些getter和setter方法。

下面的例子将说明EncapTest类的变量怎样被访问:
RunEncap.java

public class RunEncap{
   public static void main(String args[]){
      EncapTest encap = new EncapTest();
      encap.setName("James");
      encap.setAge(20);
      encap.setIdNum("12343ms");
 
      System.out.print("Name : " + encap.getName()+ " Age : "+ encap.getAge());
    }
}

多态

多态是同一个行为具有多个不同表现形式或形态的能力。

多态就是同一个接口,使用不同的实例而执行不同操作,如图所示:

在这里插入图片描述

多态就是对象多种表现形式得体现:同一个事件发生在不同的对象上会产生不太同的结果

多态存在的三个必要条件:继承,重写,父类引用指向子类对象
比如 Parent p = new Child();
当使用多态方式调用方法时,首先检查父类中是否有该方法,若没有则编译错误,若有,再调用子类的同名方法。
多态的好处:可以使程序有良好的扩展,并可以对所有类的对象进行通用处理

多态优点:

  • 消除类型之间的耦合关系。
  • 可替换性
  • 可扩充性
  • 接口性
  • 灵活性
  • 简化性

示例:

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

输出结果

吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠
相关推荐
©️2020 CSDN 皮肤主题: Age of Ai 设计师:meimeiellie 返回首页