【我与Java的成长记】之封装，继承详解（一）（能看懂文字就能明白系列）

guduadmin14小时前

【我与Java的成长记】之封装，继承详解（一）（能看懂文字就能明白系列）,在这里插入图片描述,第1张

系列文章目录

能看懂文字就能明白系列

C语言笔记传送门

Java笔记传送门

🌟 个人主页：古德猫宁-

🌈 信念如阳光，照亮前行的每一步

文章目录

系列文章目录
- 🌈 *信念如阳光，照亮前行的每一步*
- 前言
- 一、封装（Encapsulation）
- - 封装的概念
  - 封装举例
  - 访问限定符
  - 二、继承（Inheritance）
  - - 继承的概念
    - 继承的语法
    - 父类成员的访问
    - - 1、子类中访问父类的成员变量
      - 2、子类中访问父类的成员方法
        
        前言
        
        面向对象的开发范式其实是对现实世界的理解和抽象的方法，那么具体如何将现实世界抽象成代码呢？这就需要运用面向对象的三大基本特征，分别是封装，继承，多态。
        
        本节目标：
        
        封装
        继承
        
        本节重点：都是重点
        
        一、封装（Encapsulation）
        
        封装的概念
        
        所谓封装，就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的类或者对象隐藏信息
        比如：对于电脑这样一个复杂的设备，提供给用户的就只是：开关机，通过键盘输入，显示器USB插孔等，让用户和计算机进行交互，完成日常事物。但实际上：电脑真正工作的确却是CPU，显卡，内存等一些硬件元件。
        对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内存是如何设计的等，用户只需知道，怎么开机，怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机，鼠标以及键盘插孔等，让用户可以与计算机进行交换即可。
        
        封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互
        
        封装举例
        
        举个简单的例子：
        
        class Rectangle { private int length;//被private修饰的成员变量只能在类中访问，不能被其他类访问 private int width; public Rectangle(int length,int width){//构造方法 this.length = length; this.width = width; } public int area(){//获得矩形面积 return this.length*this.width; } } public class test1{ public static void main(String[] args) { Rectangle rectangle = new Rectangle(3,9); System.out.println(rectangle.area()); } }
        
        在上面的代码中有两个类，Rectangle类中的width和length被private修饰，所以只能在Rectangle类中访问，不能被其他类访问，这时我们可以借助 area方法计算并返回值，然后在test1类中调用area方法获得值并输出，如果要在test1访问Rectangle类中的length编译器则会报错。
        
        访问限定符
        
        Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者成员变量能否直接在类外使用。Java提供了四种访问限定符。
        注意：
        
        default权限指：什么都不写时的默认权限。
        访问权限除了可以限定类中的成员的可见性，也可以控制类的可见性。
        一般情况下成员变量设置为private，成员方法设置为public。
        二、继承（Inheritance）
        
        继承的概念
        
        继承机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有的类特性的基础上进行扩展，增加新功能，这样产生新的类，称为派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。
        
        比如：猫和狗，它们是动物
        那我们用java可以这样设计：
        
        //dog public class Dog { String name; int age; public void bark(){ System.out.println(name+"正在汪汪叫"); } public void eat(){ System.out.println(name+"正在吃饭"); } }
        
        //Cat public class Cat { String name; int age; public void maiomiao(){ System.out.println(name+"正在喵喵叫"); } public void eat(){ System.out.println(name+"正在吃饭"); } }
        
        观察上面的两段代码，我们发现猫和狗类中存在大量重复，如图所示：
        这时候我们就可以将这些共性抽取出来，实现代码复用，即继承。
        
        继承的语法
        
        在Java中如果要表示类之间的继承关系，需要借助extends关键字，具体如下：
        
        修饰符 class 子类 extends 父类{
        //…
        }
        
        注意：
        
        子类会将父类中的成员变量或者成员方法继承到子类中。
        子类继承父类之后，必须要新添加自己特有的成员，体现出与父类的不同，否则就没必要继承了。
        
        那我们就可以尝试对上面的猫类和狗类的代码进行优化了
        比如：我们可以创建一个动物类，专门来放猫和狗的共性
        
        public class Animal { int age; String name; public void eat(){ System.out.println(name+"正在吃饭"); } }
        
        class Dog extends Animal{ public void bark(){ System.out.println(name+"正在汪汪叫"); } } class Cat extends Animal{ public void maiomiao(){ System.out.println(name+"正在喵喵叫"); } } public class test1{ public static void main1(String[] args) { Dog dog = new Dog();//实例化对象 System.out.println(dog.age);// dog类中并没有定义任何成员变量， System.out.println(dog.name);// name和age属性肯定是从父类Animal中继承下来的 dog.eat();// dog访问的eat()方法也是从Animal中继承下来的 } }
        
        上述图示中，Dog和Cat都继承了Animal类，其中：Animal类称为父类/基类或者超类，Dog和Cat可以称为Animal的子类/派生类，继承之后，子类可以复用父类中成员，子类在实现时只需关心自己新增的成员即可。
        
        从继承概念中可以看出继承最大的作用就是：实现代码复用，还有就是来实现多态（后面讲到）
        
        父类成员的访问
        
        在继承体系中，子类将父类中的方法和字段继承下来了，那在子类中能否直接访问父类继承下来的成员呢？
        
        1、子类中访问父类的成员变量
        
        一、子类和父类不存在同名成员变量
        成员变量访问遵循“就近原则”，自己有的话优先访问自己的，如果没有则向父类中找。
        例如：
        
        class Base{ int a; int b; } public class Derived extends Base{ int c; public void method(){ a = 10;//自己没a,所以访问从父类中继承下来的a b = 20;//同上 c = 30;//自己有c,所以访问子类自己的c } }
        
        二、子类和父类成员存在同名成员变量
        
        class Base{ int a; char b; } public class Derived extends Base{ int a;// 与父类中成员a同名，且类型相同 char b = 10; // 与父类中成员b同名，但类型不同 int c; void method(){ a = 100;//按照”就近原则“，所以访问子类自己的 b = 200;//按照”就近原则“，所以访问子类自己的 c = 300; } }
        
        总结：
        
        如果访问的成员变量子类中有，优先访问自己的成员变量。
        如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
        如果访问的成员变量与父类中成员变量同名，则优先访问自己的
        成员变量访问遵循就近原则，自己有优先访问自己的，如果没有则向父类中找。
        
        2、子类中访问父类的成员方法
        
        一、成员方法名字不同（与上面的规则相同）
        
        class Base{ public void methodFu(){ System.out.println("调用父类的成员方法"); } } public class Derived extends Base{ public void methodzi(){ System.out.println("调用子类的成员方法"); } public void method(){ methodFu();//访问父类继承的methodFu() methodzi();//访问子类自己的methodzi() //methodwu();编译失败，在整个继承体系中没有发现方法methodwu() } }
        
        二、成员方法名字相同（规则略有不同）
        
        class Base{ public void methodA(){ System.out.println("调用父类的成员方法A"); } public void methodB(){ System.out.println("调用父类的成员方法B"); } } public class Derived extends Base{ public void methodA(){ System.out.println("调用子类的成员方法A"); } public void methodB(){ System.out.println("调用子类的成员方法B"); } public void methodC(){ methodA();//直接访问，则永远访问到的都是子类中的方法，父类的无法访问到。 methodB(); } public static void main(String[] args) { Derived derived = new Derived(); derived.methodC(); } }
        
        运行结果：
        不同之处：
        总结：
        
        通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。
        通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同（重载），根据调用方法适传递的参数选择合适的方法访问，如果没有则报错。