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("看家");  
    }  
}

输出结果

吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠

本文地址：https://blog.csdn.net/weixin_42878211/article/details/109566039