javaSE探赜索隐之三--＜类与对象的爱恨情仇下＞-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_45785542/article/details/109498215

本文介绍了面向对象编程中的三个核心概念：封装、继承和多态。封装通过隐藏类的内部细节并提供公共接口来保护数据。继承允许子类继承父类的特性，提高代码复用性。多态则使一个接口能够表示多种类型的行为。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

封装

封装就是将类的某些信息隐藏在类的内部，不允许外部直接访问。而是通过该类提供的方法对隐藏的信息进行访问。

public class Person {

    //隐藏类的信息,这样外部就不能访问
      private  String  name;
      private  int age;
    //可以向外部提供专门的方法,来对类中私有的属性访问
      public void setName(String name){
          if(name!=null){
              //this表示当前正在访问的对象
              this.name = name;
          }
     }
     public String getName(){
          return this.name;
     }
     public void setAge(int age){
          this.age=age;
     }
     public int getAge(){
          this.test();
          return this.age;
     }

而其他类只能通过给定的方法访问。

public class Test {

    public static void main(String[] args) {
         //Person p=new Person("jim",10);

       Person p=new Person();
              p.setName("张三");
              p.setAge(10);
        System.out.println(p.getAge());
        System.out.println(p.getName());

    }
}

补充：
- this关键字表示当前类的对象的属性、方法。（this必须放在非静态方法中，因为静态的方法和属性属于类，不属于对象。）
- 一般封装给定方法的快捷方式：鼠标右击–>Generate–>Getter and Setter

继承

继承的相关概念
1. 继承就是在已有类的基础上派生出新类的过程，新类可以拥有父类的非私有属性、方法，从而提高代码的重用性、扩展性（方法的重写）。
2. 能继承的两个类之间大都属于（A是B[a is b]）这样的关系。比如，猫是一个动物，也就是说猫类继承了动物类。
3. 被继承的类是父类（基类），继承过的类是子类（派生类），子类通过（extend关键字+父类名）将父类继承过来。
4. java中只支持单继承，即一个类只能有一个直接父类。但是类的继承具有传递性，也就是说类可以间接被继承。（举个例子，Java中Object类是所有类的父类，所有的类都直接）

继承的相关过程

在继承后创建子类对象的时候，会优先调用父类的无参构造方法，创建父类对象。通过“super()”关键字调用父类构造方法，（默认为无参构造方法），如果写出来要写在第一行。

当父类的方法不能满足子类的需求时，可重写父类中的方法。
重写规则：

方法名相同、参数列表相同、返回值类型相同、访问权限相同

//父类
public class Animal{
         private String name;
         private int age;
         public void eat(){
             System.out.println("动物正吃");
         }
         public void setName(String name){
             this.name = name;
         }
         public String getName(){
             return  this.name;
         }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
}
//子类
public class Dog extends  Animal{
    private String type;
     @Override
    public void eat() {
        System.out.println("狗吃。");
    }
    public void study(){
        System.out.println("狗正学习");
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
}
//测试类
public class TestExtends {

    public static void main(String[] args) {
          Dog dog = new Dog();
             dog.setName("拉拉");
             dog.setType("狼犬");
        System.out.println(dog.getName());
        System.out.println(dog.getType());
             dog.eat();
             dog.study();
    }
}

补充：@override是重写的意思，快捷键：Ctrl+o

多态

类与类的关系

关联
关联就是对象与对象（类与类）之间的连接，java中关联关系表现为一个类作为另一个类的属性存在。比如人拥有车。人和车是不同的类，他们的对象之间存在对应关系。基本满足（ A has B）
- 关联关系分为：一对一关联、一对多关联（集合、数组）；单向关联、双向关联。
依赖

依赖即一个类使用另一个类作为参数。

依赖关系是临时的，方法完成后，变量立即被销毁。

多态

多态就是同一种事物在不同的时刻，所表现出的不同状态。
多态的条件：
1. 继承（包括接口的实现）。
2. 必须有重写的方法（往往会在父类中定义一些抽象的方法，即没有方法体的方法）
3. 父类的引用指向子类的对象。
多态下成员方法的调用
1. 编译看左边，运行看右边。
```
  Animal dog = new Dog();
```
2. 编译运行都看左边（针对静态方法）

补充：

向上转型

向上转型与默认转换相似，提高了程序的扩展性。
```
 Animal animal = new Dog();
```
问题：父类类型变量无法调用子类特有的方法。因此出现了向下转型。

向下转型

Dog dog = (Dog)animal;
//往往在向下转型钱需要先判断 “dog” 是不是 “animal”类型的对象。
//否则会出现 Dog dog = (Dog) object （实际上Dog和Object并无关系）