Java基础知识总结(41)

(4)面向对象的特征

复制代码
  面向对象的三大特征∶封装、继承和多态
  1、封装:
          封装是指将对象的状态信息隐藏在对象的内部,不允许外部程序直接访问,只能通过对象内部提供的方法来实现对内部信息的操作和访问。
          为实现良好的封装,需要从两个方面考虑:
          将对象的成员变量和实现细节隐藏在对象内部,不允许外部直接访问
          把方法暴露出来,让方法来控制对这些成员变量进行安全的访问和操作
​
          访问修饰符:
                        public  protected  缺省   private
          同类            √        √         √     √
          同包子类        √         √        √      ×
          同包非子类      √         √        √      ×
          非同包子类      √         √        ×      ×
          非同包非子类    √         ×        ×      ×
          如:
            /**
            * 父类
            * @author Ray
            *
            */
            public class ParentClass {
复制代码
                /**
                * 构造器
                */
                public ParentClass() {
    
                }
​
                //访问修饰符为public的变量 姓名
                public String publicName;
                //访问修饰符为protected的变量 存款
                protected String protectedMoney;
                //访问修饰符为default的变量 年龄
                int defaultAge;
                //访问修饰符为private的变量 性别
                private String privateGender; 
​
            }
            
            /**
            * 同包子类
            * @author Ray
            *
            */
            public class SonClass extends ParentClass{
                public void test() {
                    System.out.println(this.publicName);
                    System.out.println(this.protectedMoney);
                    System.out.println(this.defaultAge);
                    //System.out.println(this.privateGender) 不能访问;
                }
            }
​
            /**
            * 同包非子类
            * @author Ray
            *
            */
            public class Test {
​
                public static void main(String[] args) {
                    ParentClass parentClass = new ParentClass();
                    System.out.println(parentClass.publicName);
                    System.out.println(parentClass.protectedMoney);
                    System.out.println(parentClass.defaultAge);
                    //System.out.println(parentClass.privateGender); 不能访问
                }
            }       
​
            /**
            * 非同包子类
            * @author Ray
            *
            */
            public class SonClass extends ParentClass{
                public void test() {
                    System.out.println(this.publicName);
                    System.out.println(this.protectedMoney);
                    //System.out.println(this.defalutAge);  不能访问
                    //System.out.println(this.privateGender); 不能访问 
                }
​
            }
​
            /**
            *非同包非子类
            * @author Ray
            *
            */
            public class Test {
                public static void mian(String[] args) {
                    ParentClass parentClass = new ParentClass();
                    System.out.println(parentClass.publicName);
                    //System.out.println(parentClass.protectedMoney); 不能访问
                    //System.out.println(parentClass.defaultAge); 不能访问
                    //System.out.println(parentClass.privateGender); 不能访问
                }
            }
​
          总结:
            public:公共的,任意位置都可以访问
            protected:同包和子类(同包子类,同包非子类,非同包子类)
            缺省:同包(同包子类,同包非子类)
            private:私有,类内
          包:
            1. 从操作系统层面来看,包就是一个文件夹或者路径
            2. 从项目开发角度来看,包可以有效的管理类
            3. Java中引入包概念,目的是为了解决类名冲突的问题,不同包下可以有同名的类。如果某个类在某个包中,那么在类中代码的第一行一定要声明类所在的包:package packageName
            4. 包的命名一般使用域名的倒置例如:cn.bytecollege.util
            5. Java中定义一个类,会默认导入java.lang包
          常用的包:
            java.io:输入输出流
            java.lang:通用包
            java.lang.reflect:反射相关
            java.math:数学相关
            java.text:格式化相关
            java.util:集合框架相关
            java.sql:数据库相关
 2、继承:
        在已有类的基础上创建一个新类,从而达到代码复用的目的,已有的类又叫做基类,父类,或者超类,父类中定义的是通用的状态和行为,新建的类又叫做子类或者派生类。继承使用extends关键字实现,Java中继承是单继承的,一个类有且只能又一个父类。Java中所有的类都是Object的子类,每个类都会直接或者间接继承Object。
        方法重写(override):
            当子类从父类继承的方法不能满足子类需要时,子类可以对父类的方法进行重写,也叫方法覆盖
        方法重写的特征:
​
            1. 方法重写只存在于继承关系中
            2. 方法名相同参数列表相同
            3. 返回类型和父类方法返回值类型一致或者是父类方法的返回值类型的子类
            4. 访问修饰符权限大于等于父类方法访问修饰符权限
            5. 子类方法抛出异常小于等于父类方法抛出异常   
​
        面试题:
            构造方法能不能被重写?
                答:不能,构造方法不能被继承,可以重写的一定是被继承的
            构造方法能不能被继承?
                答:不能,构造方法不是类成员,不能被继承。
相关推荐
起名字真南14 分钟前
【OJ题解】C++实现字符串大数相乘:无BigInteger库的字符串乘积解决方案
开发语言·c++·leetcode
爬山算法19 分钟前
Maven(28)如何使用Maven进行依赖解析?
java·maven
tyler_download25 分钟前
golang 实现比特币内核:实现基于椭圆曲线的数字签名和验证
开发语言·数据库·golang
小小小~26 分钟前
qt5将程序打包并使用
开发语言·qt
hlsd#26 分钟前
go mod 依赖管理
开发语言·后端·golang
小春学渗透28 分钟前
Day107:代码审计-PHP模型开发篇&MVC层&RCE执行&文件对比法&1day分析&0day验证
开发语言·安全·web安全·php·mvc
杜杜的man30 分钟前
【go从零单排】迭代器(Iterators)
开发语言·算法·golang
亦世凡华、31 分钟前
【启程Golang之旅】从零开始构建可扩展的微服务架构
开发语言·经验分享·后端·golang
2401_8574396943 分钟前
SpringBoot框架在资产管理中的应用
java·spring boot·后端
怀旧6661 小时前
spring boot 项目配置https服务
java·spring boot·后端·学习·个人开发·1024程序员节