OOP三大特性

最新推荐文章于 2024-10-05 12:07:50 发布

紧急津波

最新推荐文章于 2024-10-05 12:07:50 发布

阅读量56

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/qq_41841385/article/details/129677873

版权

文章详细介绍了Java编程中的面向对象三大特性：封装（包括信息隐藏、get/set方法），继承（单继承、super关键字、构造器）以及多态（重写、动态编译和类型转换）。这些特性增强了代码的安全性、可维护性和灵活性。

摘要由CSDN通过智能技术生成

三大特性

封装

该露的露，该藏的藏
- 程序设计要追去 “高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装（数据的隐藏）
- 通常，应禁止直接访问一个对象中数据的实际表示，而应该通过操作接口来访问，这称为信息隐藏

属性私有、get\set

提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口所有用户调用的接口只有get和set方法
系统的可维护性增加了

private String name; //名字
private int id; //学号

//提供一些可以操作属性的方法
//提供一些public的get、set方法
//get 获得该数据
public String getName(){
    	return this.name;
	}
//set 给该数据设置值
public void setName(String name){
    	this.name=name;
	}
//Alt+insert 快捷键
public int getId() {
        return id;
    }
public void setId(int id) {
        this.id = id;
    }

其中可以使用set方法对数据提供一些防止违规操作

public void setAge(int age) {
    if (age>120||age<0){
        this.age=3;
    }else{
        this.age = age;
    }
}
//判断传入的age是否符合要求

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
***extends***的意思是”扩展“。子类是父类的扩展
JAVA中类只有单继承，没有多继承 参考树结构一个儿子只有一个父亲，但一个父亲可以有多个儿子
- 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等
- 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
- 子类和父类之间，从意义上来将应该具有”is a“的关系
- 子类会继承父类的所有方法
Ctrl+H 打开继承树

权限修饰词

//public 优先级最高
//protected 受保护的
//default 默认
//private 私有 无法继承

Object类：所有的类都默认直接或者间接继承Object类
Super注意点
1. super调用父类的构造方法，必须在构造方法的第一行
2. super必须只能出现在子类的方法或者构造方法里
3. super和this不能同时调用构造方法
super对比this
1. 代表的对象不同：
  
  this：本身调用者这个对象
  
  super：代表父类对象的应用
2. 前提不同
  
  this：没有继承也可以使用
  
  super：只能在继承条件下才可以使用
3. 构造方法不同
  
  this：调用本类的构造
  
  super：调用父类的构造
方法重写
- ==***重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数方法时，实际执行的是子类重写父类的方法
- 前提必须有继承关系，子类重写父类的方法；只针对方法不是属性
- 方法重写只与非静态方法有关
- 方法名必须相同，参数列表必须相同
- 修饰符：范围可以扩大不能缩小 public>protected>default>private
- 抛出的异常：范围可以被缩小不能扩大；classNotException>Exception(大)
- 为什么需要重写
  1. 父类的功能，子类不一定需要或满足
- ALt+insert：override 快捷键
- 不能被重写的方法
  - static 属于类，不属于实例
  - final 常量，在常量池中
  - private 私有方法

多态

见D:\JavaSE\基础语法\src\com\oop\demo06\AnimalTest.java

public class AnimalTest {
    public static void main(String[] args) {
        AnimalTest test = new AnimalTest();
        test.func(new Dog());
    }
    public void func(Animal animal){//Animal animal = new Dog();
        //声明的时候是animal 运行时实际运行的是Dog中重写的Animal方法
        animal.eat();
        animal.shout();
    }
    //如果没有多态性 Animal只能new Animal则要使用Dog或Cat则需要
    public void func(Dog dog){}
    public void func(Cat cat){}
}


class Animal{
    public void eat(){
        System.out.println("动物吃");
    }
    public void shout(){
        System.out.println("动物叫");
    }
}
class  Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
    @Override
    public void shout() {
        System.out.println("汪汪汪");
    }
}
class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    @Override
    public void shout() {
        System.out.println("喵喵喵");
    }
}

动态编译：可扩展性
同一方法可以==根据发送对象的不同而采用多种不同的行为方式==
一个对象的实际类型是确定的，但可以指向对象的引用类型有很多
- 对象能执行哪些方法主要看对象左边的类型，和右边关系不大
```
Student s1 = new Student();
s1.run();
```
多态的使用：虚拟方法的使用
- 有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们***实际执行的是子类重写父类的方法***
- 子类型能调用的方法都是自己的或者继承父类的
- 父类型可以指向子类，但是不能调用子类独有的方法，但可以调用重写的父类方法
- 编译看左边执行看右边
虚拟方法调用(Virtul Method Invocation)
- ***子类重写了父类的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。***这样的方法调用在编译期是无法确定的
- ```
Person e = new Student();
e.getInfo(); //调用Student类的getInfo()方法
```
多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
注意：
- 多态是方法的多态，属性没有多态
- 父类和子类，有联系类型转换异常！ ClassCastException！
- 存在条件：继承关系，方法需要重写，父类引用指向子类对象 Father f1= new Son();
类型转换
- 向上转型：把子类转换为父类（丢失子类自身的方法；走重写父类的方法）
- 向下转型：把父类转换为子类（强制转换）从而父类调用子类特有的属性和方法

在这里插入图片描述

//类型之间的转换：基本类型转换 高转低
//父 <------- 子  低转高
		Person obj = new Student();
//父类调用子类独有的方法要强制转换
//Student <------ Person 高转低
		Student student = (Student) obj;
		student.go();
		((Student)obj).go();

//子 转 父 低转高 会丢失自己本身的方法
		Student student1 = new Student();
		student1.go();
		//Person <----- Student
		Person person=student1;
		//person.go();方法丢失

//运行报错 person1没有调用过Student类的信息
        Person person1 = new Person();
        Student student2=(Student)person1;
        student2.go();

instanceof 引用类型，判断一个对象是什么类型

判断x所指向的子类型是否与y有关

System.out.println(x instanceof y);判断x所指向的子类型是否与y有关

//Object>String
//Object>Person>Student
//Object>Person>Teacher
Object object = new Student();
		System.out.println(object instanceof Student);//true
		System.out.println(object instanceof Person);//ture
		System.out.println(object instanceof Object);//true
		System.out.println(object instanceof Teacher);//false
		System.out.println(object instanceof String);//false
Person person = new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//ture
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//false
//        System.out.println(person instanceof String);//编译报错
Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//ture
        System.out.println(student instanceof Object);//true
//        System.out.println(student instanceof Teacher);//编译报错
//        System.out.println(student instanceof String);//编译报错