Java面向对象基本特征

川长思鸟来 2022-12-30 10:37 53阅读 0赞

# 封装 #

1.  封装：**隐藏事务属性的实现细节，对外公开一个公共的访问方式**
2.  封装的好处：
    
    1.  隐藏事务的实现细节
    2.  提高了代码的复用性
    3.  提高安全性
3.  类封装的原则：
    
    1.  隐藏事务的属性
    2.  隐藏事务的实现细节
    3.  对外提供一个公共的访问方式

# 继承 #

1.  让类和类之间产生关系，父子关系。使用关键字 extends
2.  定义一个A类，定义一个B类，让A类去继承B类，A类中就拥有B类中的所有内容(除private修饰的)
3.  父类和子类的关系
    
    1.  父类：就是被继承的类，别称：超类，基类
    2.  子类：用于继承类，别称：派生类

继承的好处和弊端

1.  好处：
    
    1.  提高了代码的复用性
    2.  提高了代码的可维护性
    3.  是类中多态的前提
2.  弊端：
    
    1.  提高了代码和代码之间的耦合性
    2.  耦合性：事务和事务之间相互影响的程度
3.  开发的原则：面向对象最终实现的目标:高内聚，低耦合
4.  继承好处远远大于弊端，继承还是要用的

继承的注意事项

1.  父类中私有的成员变量不能被继承(不能再子类中直接访问)
    
    1.  父类中的一些私有成员，不能再子类中直接使用
    2.  在子类对象中，仍然包含了父类中的私有的成员变量
    3.  只不过在子类中，不能直接使用这些私有的内容
2.  父类中的构造方法不能被继承
    
    1.  原因
        
         *  父类的构造方法需要和父类类名一致，子类的构造方法名需要和子类的构造方法名一致，因为父类和子类的类名不一致，因此无法继承
         *  父类的构造方法是用来给父类的成员变量赋值，子类的构造方法是用来给子类成员变量赋值的，然后子类的成员变量比父类可能要多，使用父类的构造方法就无法将子类中的所有的成员变量赋值，因此不能继承
         *  解决：
            
            1.  子类虽然无法直接继承父类的构造方法，但是可以在子类中调用父类的构造方法

java中继承的特点

1.  java中支持单继承，不支持多继承，但是支持多层继承，继承是有传递性的
2.  单继承：一个子类只能有一个父类(一个孩子，只能有一个亲爹)
3.  多继承：一个子类可以同时拥有多个亲爸爸
4.  多层继承：A继承B类，B继承C类，那么A类中就拥有B类中的内容也拥有C类中的内容，越顶层的类，拥有的功能就越少，主要是公共的属性的行为，例如集合的体系，先学最顶层的父类，把共性的内容学完之后，子类就只需要研究特有的功能即可
5.  Java中为什么不支持多继承
    
    1.  如果有多继承，那么子类就调用多个父类中相同的方法，父类们对这个方法有不同的实现，子类就不知道该调用哪个父类中对这个方法的实现了

继承中成员变量的关系

1.  在子类中定义和父类中不同名的成员变量，在子类中既可以使用子类去访问自己的成员变量，也可以访问父类中的成员变量
2.  在子类中定义和父类同名的成员变量，子类中就会根据就近原则，只能访问到自己定义的成员变量
    
    1.  在子类中，如果要访问某个变量名，优先在自己的方法中找，找不到就去方法外找，方法外找不到，就会去该类的父类中去找，还没有，就继续像父类的父类中去找，一致找到所有类的根类，Object,有就使用，没有就编译报错

继承中成员方法的关系

1.  在父子类中出现了同名的方法，两个方法的内部实现不一样
    
    1.  此时在子类中调用这个方法的时候，只会有子类对这个方法的实现
2.  如果父类和子类的方法同名，但是实现不一样，java中把这个叫做重写
    
    1.  重载：在同一个类中，方法名相同，参数列表不同，与返回值类型无关
    2.  重写：在父子类中，方法名一致，参数列表一致，返回值类型一致
    3.  java中可以通过@Override 检测一个方法是不是重写父类的方法
3.  方法本身是属于父类，只不过在子类中重新实现了这个方法的内容
4.  重写的注意事项：
    
    1.  私有的方法不能被重写，子类可以定义和父类私有方法同名的方法，叫做方法的重新定义，不叫重写
    2.  重写：使用父类方法的定义，修改为子类的实现
    3.  方法在重写的时候，权限不能越来越小，子类应该越来越强大，功能越来越多，不能将父类中的内容给重写没了

继承中构造方法的关系

1.  在初始化子类数据之前，必须先完成对父类数据的初始化(因为在初始化子类数据的时候，可能用到父类的数据，所以必须先完成对父类的初始化)
2.  如果在子类的构造方法中，没有显式的调用任何其他的构造方法，在构造方法的第一句，系统默认会给你加上一句super() 默认访问父类的空参构造
3.  如果在子类的构造方法中，手动的加上了父类构造方法的调用，系统就不会给你提供任何构造方法的调用
4.  如果在子类的构造方法，手动添加了访问本类其他的构造方法，那么系统也不会给你增加任何构造方法的访问
5.  构造方法不能递归调用
    
    1.  不能自己调用自己，也不能间接的访问自己
6.  this语句和super语句只能出现在构造方法的第一句，只能出现一个
7.  不能再其他的非构造方法中出现this语句。，其他的非静态方法都是属于对象的，在属于对象的方法中访问对象创建时出现的内容，就相当于间接的访问了对象

# 多态 #

1.  事务的多种形态
2.  对象的多态性：同一个对象，在不同的环境下，有不同的名称
3.  1.  例如：张欢    在班级里 ： 同学
    2.  回到了家在老公那： 媳妇   回到家在父母那：  女儿
4.  多态实现的前提
    
    1.  要有父子关系，没有继承，就没有多态
    2.  方法的重写
    3.  父类的引用指向子类对象

多态访问成员方法的特点

1.  编译看左，运行看右
2.  编译的时候看=左边的引用类型中，是否定义了该方法，如果有，就编译通过，如果没有编译失败
3.  运行的时候，要看= 右边，对象所属的类中，如果对这个方法进行了实现，最终运行的就是子类对这个方法的实现

向上向下转型

1.  向上转型
    
    1.  正常情况下： 使用父类的引用指向子类的对象
    2.  多态中，使用的是父类类型的引用指向了子类对象(向上转型)
    3.  本质：缩小了对象本身的访问范围，减少了访问权限，只能访问父类中的内容
2.  向下转型：
    
    1.  让一个子类对象的父类引用，恢复成子类的引用
    2.  变量的强制转换
        
         *  要转换的数据类型  变量名称 = (要转换的数据类型) 要转换的变量
    3.  向下转型：
        
         *  子类类型 引用名称 = (子类类型) 父类类型的引用
         *  Zi z = (Zi)f；
         *  本质：就是恢复子类本身的访问范围
3.  注意：不可以把父类对象进行向下转型，必须一定是父类的引用指向子类对象，才可以向下转型

多态的好处

1.  提高了代码的扩展性
2.  在方法中，如果形势参数是父类类型，将来在调用这个方法的时候，就可以把这个父类类型的子类创建出来的对象，当做实际参数传递
3.  如果一个方法的返回值是父类类型，那么就可以在方法内将父类的子类对象，当做方法的返回值返回，调用者接收的时候可以直接使用父类类型来接受，或者也可以直接向下转型(必须要知道返回的是什么类型的子类)

# this和super的使用总结 #

1.  含义
    
    1.  this表示当前类对象的引用
    2.  super表示父类的引用，哪个对象调用super所在的方法，super就代表哪个对象父类部分的数据
2.  super和this访问成员变量
    
    1.  super只能访问父类中的内容
    2.  this既可以访问父类，也可以访问子类
3.  this和super都可以访问成员方法
    
    1.  this既可以访问父类的，也可以访问子类的
    2.  super只能访问父类的 super.成员方法名(实际参数);
4.  this和super访问构造方法，this访问叫做this语句，super访问叫做super语句
    
    1.  this(); 访问 子类的构造方法
    2.  super(); 访问父类的构造方法
    3.  this语句和super语句只能出现在构造方法中，而且必须在第一行，不能出现在其他的方法中