Java面向对象之封装和继承

Java面向对象之封装和继承

⚡️前言⚡️
本篇文章记录博主对面向对象部分的学习,带大家认识Java基础知识——包与继承,后续内容将持续更新。(se基础语法的前半部分由于需要重新编写,暂未更新,敬请谅解)

🍉博客主页: 🍁如风暖阳🍁

🍉欢迎点赞 👍 收藏留言评论 📝私信必回哟😁

🍉本文由 【如风暖阳】 原创,首发于 CSDN🙉

🍉博主将持续更新学习记录收获,友友们有任何问题可以在评论区留言

🍉博客中涉及源码及博主日常练习代码均已上传码云(gitee)


🍅1. 封装

1.1 封装的概念

面向对象程序三大特性:封装、继承、多态。而类和对象阶段,主要研究的就是封装特性。何为封装呢?简单来说就是套壳屏蔽细节

比如:对于电脑这样一个复杂的设备,提供给用户的就只是:开关机、通过键盘输入,显示器,USB插孔等,让用户来和计算机进行交互,完成日常事务。但实际上:电脑真正工作的却是CPU、显卡、内存等一些硬件元件。

对于计算机使用者而言,不用关心内部核心部件,比如主板上线路是如何布局的,CPU内部是如何设计的等,用户只需要知道,怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时,在外部套上壳
子,将内部实现细节隐藏起来,仅仅对外提供开关机、鼠标以及键盘插孔等,让用户可以与计算机进行交互即可。

封装:将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行交互

1.2 访问限定符

Java 中对于字段和方法共有四种访问权限

  • private: 类内部能访问, 类外部不能访问
  • 默认(也叫包访问权限): 类内部能访问, 同一个包中的类可以访问, 其他类不能访问.
  • protected: 类内部能访问, 子类和同一个包中的类可以访问, 其他类不能访问.(在继承部分详细介绍)
  • public : 类内部和类的调用者都能访问
    在这里插入图片描述

什么时候下用哪一种呢?
我们希望类要尽量做到 “封装”, 即隐藏内部实现细节, 只暴露出必要的信息给类的调用者.
因此我们在使用的时候应该尽可能的使用 比较严格 的访问权限. 例如如果一个方法能用 private, 就尽量不要用public.
另外, 还有一种 简单粗暴 的做法: 将所有的字段设为 private, 将所有的方法设为 public. 不过这种方式属于是对访问权限的滥用, 还是更希望同学们能写代码的时候认真思考, 该类提供的字段方法到底给 “谁” 使用(是类内部自己用, 还是类的调用者使用, 还是子类使用)
Java中主要通过类和访问权限来实现封装:类可以将数据以及封装数据的方法结合在一起,更符合人类对事物的认知,而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符:

【说明】

  • 访问权限除了可以限定类中成员的可见性,也可以控制类的可见性
  • 一般情况下成员变量设置为private,成员方法设置为public。

1.3 封装扩展之包

包 (package) 是组织类的一种方式.
使用包的主要目的是保证类的唯一性.
例如, 你在代码中写了一个 Test 类. 然后你的同事也可能写一个 Test 类. 如果出现两个同名的类, 就会冲突, 导致代码不能编译通过,若在包中建立类,就避免了类名冲突的情况

1.3.1 导入包中的类

Java 中已经提供了很多现成的类供我们使用. 例如

public class Test {
    public static void main(String[] args) { 
    java.util.Date date = new java.util.Date(); // 得到一个毫秒级别的时间戳 
    System.out.println(date.getTime());
   }
}

可以使用 java.util.Date 这种方式引入 java.util 这个包中的 Date 类. 但是这种写法比较麻烦一些, 可以使用 import 语句导入包.

import java.util.Date;
public class Test {
    public static void main(String[] args) {
        Date date = new Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
   }
}

如果需要使用 java.util 中的其他类, 可以使用 import java.util.*,*又叫做通配符,用了它就可以使用包中的所有类,但又不像c/c++一样全部导入,而是使用哪个类就导哪个类

import java.util.*;
public class Test {
    public static void main(String[] args) {
        Date date = new Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
   }
}

但是我们更建议显式的指定要导入的类名. 否则还是容易出现冲突的情况.

import java.util.*;
import java.sql.*;
public class Test {
    public static void main(String[] args) {
        // util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
        Date date = new Date();
        System.out.println(date.getTime());
   }
}
// 编译出错
Error:(5, 9) java:Date的引用不明确
  java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配

在这种情况下需要使用完整的类名,才能避免冲突

import java.util.*;
import java.sql.*;
public class Test {
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();
        System.out.println(date.getTime());
   }
}
1.3.2将类放到包中

基本规则

  • 在文件的最上方加上一个 package 语句指定该代码在哪个包中.
  • 包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.bit.demo1 ).
  • 包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储代码.
  • 如果一个类没有 package 语句, 则该类被放到一个默认包中.
  • 包名必须小写

操作步骤

  1. 在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包
    在这里插入图片描述
  2. 在弹出的对话框中输入包名, 例如 com.bilibili.demo1
    在这里插入图片描述
  3. 在包中创建类, 右键包名 -> 新建 -> 类, 然后输入类名即可
    在这里插入图片描述
  4. 此时可以看到我们的磁盘上的目录结构已经被 IDEA 自动创建出来了
    在这里插入图片描述
  5. 同时我们也看到了, 在新创建的 Test.java 文件的最上方, 就出现了一个 package 语句
    在这里插入图片描述
1.3.3 import和package的区别

package:“包”,指:类所在的包
import:“引入”,指:引入类中需要的类。
也就是说在类所在的包需要使用package语句,如果一个类没有package语句它也会被默认放入一个包中,而import是因为当前类需要其他包中的类,所以才需要导入。

1.3.4包的访问权限控制

我们已经了解了类中的 public 和 private. private 中的成员只能被类的内部使用.
如果某个成员不包含 public 和 private 关键字, 此时这个成员可以在包内部的其他类使用, 但是不能在包外部的类使用.
下面的代码给了一个示例. Demo1 和 Demo2 是同一个包中, Test 是其他包中.

Demo1.java

package com.bilibili.demo1;
public class Demo1 {
    int value = 0; //在不加任何关键字修饰时,默认为包访问权限
}

Demo2.java

package com.bilibili.demo1; 
public class Demo2 { 
 public static void Main(String[] args) { 
 Demo1 demo = new Demo1(); 
 System.out.println(demo.value); 
 } 
} 
// 执行结果, 能够访问到 value 变量
10

Test.java

import com.bilibili.demo1.Demo1; 
public class Test { 
 public static void main(String[] args) { 
 Demo1 demo = new Demo1(); 
 System.out.println(demo.value); 
 } 
} 
// 编译出错
Error:(6, 32) java: value在com.bilibili.demo1.Demo1中不是公共的; 无法从外部程序包中对其进行访问
1.3.5 常见的系统包
  1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
  2. java.lang.reflect:java 反射编程包;
  3. java.net:进行网络编程开发包。
  4. java.sql:进行数据库开发的支持包。
  5. java.util:是java提供的工具程序包。(集合类等) 非常重要
  6. java.io:I/O编程开发包。

🍅2. 继承

2.1 背景

代码中创建的类, 主要是为了抽象现实中的一些事物(包含属性和方法).
有的时候客观事物之间就存在一些关联关系, 那么在表示成类和对象的时候也会存在一定的关联.
例如, 设计一个类表示动物

注意, 我们可以给每个类创建一个单独的 java 文件. 类名必须和 .java 文件名匹配(大小写敏感)

// Animal.java 
public class Animal { 
 public String name; 
 
 public Animal(String name) { 
 this.name = name; 
 } 
 
 public void eat(String food) { 
 System.out.println(this.name + "正在吃" + food); 
 } 
} 
// Cat.java 
class Cat { 
 public String name; 
 
 public Cat(String name) { 
 this.name = name; 
 } 
 
 public void eat(String food) { 
 System.out.println(this.name + "正在吃" + food); 
 } 
} 
// Bird.java 
class Bird { 
 public String name; 
 
 public Bird(String name) { 
 this.name = name; 
 } 
 
 public void eat(String food) { 
 System.out.println(this.name + "正在吃" + food); 
 } 
 
 public void fly() { 
 System.out.println(this.name + "正在飞 ︿( ̄︶ ̄)︿"); 
 } 
}

这个代码我们发现其中存在了大量的冗余代码.
仔细分析, 我们发现 Animal 和 Cat 以及 Bird 这几个类中存在一定的关联关系:

  • 这三个类都具备一个相同的 eat 方法, 而且行为是完全一样的.
  • 这三个类都具备一个相同的 name 属性, 而且意义是完全一样的.
  • 从逻辑上讲, Cat 和 Bird 都是一种 Animal (is - a 语义).

在这里插入图片描述

此时我们就可以让 Cat 和 Bird 分别继承 Animal 类, 来达到代码重用的效果,此时, Animal 这样被继承的类, 我们称为 父类 , 基类 或 超类, 对于像 Cat 和 Bird 这样的类, 我们称为 子类, 派生类,和现实中的儿子继承父亲的财产类似, 子类也会继承父类的字段和方法, 以达到代码重用的效果。

面向对象思想中提出了继承的概念,专门用来进行共性抽取,实现代码复用。

2.2 语法规则

基本语法

class 子类 extends 父类 { 
}
  • 使用 extends 指定父类.
  • Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承).
  • 子类构造的同时要先帮父类进行构造
  • 子类会继承父类的所有 public 的字段和方法.(构造方法也会继承,不过比较麻烦)
  • 对于父类的 private 的字段和方法, 子类中是无法访问的.(也可以继承但无法访问)
  • 子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用

对于上面的代码, 可以使用继承进行改进. 此时我们让 Cat 和 Bird 继承自 Animal 类, 那么 Cat 在定义的时候就不必再写 name 字段和 eat 方法.

class Animal { 
 public String name; 
 public Animal(String name) { 
 this.name = name; 
 } 
 public void eat(String food) { 
 System.out.println(this.name + "正在吃" + food); 
 } 
} 
class Cat extends Animal { 
 public Cat(String name) { 
 // 使用 super 调用父类的构造方法,若父类中无构造方法,则可以不构造
 super(name); //可以理解为儿子和父亲都有名字这个属性
 } 
} 
class Bird extends Animal { 
 public Bird(String name) {
  super(name); 
 } 
 public void fly() { 
 System.out.println(this.name + "正在飞 ︿( ̄︶ ̄)︿"); 
 } 
} 
public class Test { 
 public static void main(String[] args) { 
 Cat cat = new Cat("小黑"); //可以理解为儿子和父亲都有名字这个属性,只是把“小黑”这个名字赋给了儿子。
 cat.eat("猫粮"); 
 Bird bird = new Bird("圆圆"); 
 bird.fly(); 
 } 
}

extends 英文原意指 “扩展”. 而我们所写的类的继承, 也可以理解成基于父类进行代码上的 “扩展”.
例如我们写的 Bird 类, 就是在 Animal 的基础上扩展出了 fly 方法

如果我们把 name 改成 private, 那么此时子类就不能访问了

class Bird extends Animal { 
 public Bird(String name) { 
 super(name); 
 } 
 public void fly() { 
 System.out.println(this.name + "正在飞 ︿( ̄︶ ̄)︿"); 
 } 
} 
// 编译出错
Error:(19, 32) java: name 在 Animal 中是 private 访问控制

2.3 父类成员访问

在继承体系中,子类将父类中的方法和字段继承下来了,那在子类中能否直接访问父类中继承下来的成员呢?

2.3.1子类中访问父类的成员变量
  1. 子类和父类不存在同名成员变量
public class Base { 
	int a; 
	int b; 
}
public class Derived extends Base{ 
	int c;
	public void method(){ 
	   a = 10; // 访问从父类中继承下来的a 
	   b = 20; // 访问从父类中继承下来的b 
	   c = 30; // 访问子类自己的c 
	} 
}
  1. 子类和父类成员变量同名
public class Base { 
	int a; 
	int b; 
	int c; 
}

/
public class Derived extends Base{ 
	int a; // 与父类中成员a同名,且类型相同
	char b; // 与父类中成员b同名,但类型不同

	public void method(){ 
	   a = 100; // 访问父类继承的a,还是子类自己新增的a? 
	   b = 101; // 访问父类继承的b,还是子类自己新增的b?
	   c = 102; // 子类没有c,访问的肯定是从父类继承下来的c 
	   // d = 103; // 编译失败,因为父类和子类都没有定义成员变量b 
	}
}

在子类方法中 或者 通过子类对象访问成员时:

  • 如果访问的成员变量子类中有,优先访问自己的成员变量。
  • 如果访问的成员变量子类中无,则访问父类继承下来的,如果父类也没有定义,则编译报错。
  • 如果访问的成员变量与父类中成员变量同名,则优先访问自己的。

成员变量访问遵循就近原则,自己有优先自己的,如果没有则向父类中找。

2.3.2 子类中访问父类的成员方法
  1. 成员方法名字不同
public class Base {
	public void methodA(){ 
	  System.out.println("Base中的methodA()"); 
	} 
}
public class Derived extends Base{
	public void methodB(){ 
	  System.out.println("Derived中的methodB()方法"); 
}
	public void methodC(){
	  methodB(); // 访问子类自己的methodB()
	  methodA(); // 访问父类继承的methodA() 
	  // methodD(); // 编译失败,在整个继承体系中没有发现方法methodD() 
	} 
}

总结:成员方法没有同名时,在子类方法中或者通过子类对象访问方法时,则优先访问自己的,自己没有时再到父类中找,如果父类中也没有则报错。

  1. 成员方法名字相同
public class Base {
	public void methodA(){ 
	  System.out.println("Base中的methodA()"); 
	}

	public void methodB(){ 
	  System.out.println("Base中的methodB()"); 
	} 
}
public class Derived extends Base{
	public void methodA(int a) { 
	  System.out.println("Derived中的method(int)方法"); 
	}

	public void methodB(){ 
	  System.out.println("Derived中的methodB()方法"); 
	}

	public void methodC(){
	  methodA(); // 没有传参,访问父类中的methodA()
	  methodA(20); // 传递int参数,访问子类中的methodA(int)
	  methodB(); // 直接访问,则永远访问到的都是子类中的methodB(),基类的无法访问到 
	} 
}

【说明】
通过子类对象访问父类与子类中不同名方法时,优先在子类中找,找到则访问,否则在父类中找,找到则访问,否则编译报错。

通过派生类对象访问父类与子类同名方法时,如果父类和子类同名方法的参数列表不同(重载),根据调用方法适传递的参数选择合适的方法访问,如果没有则报错;

2.4 super关键字

如果需要在子类内部调用父类方法或成员需要怎么做?
可以使用super 关键字.
super 表示对父类实例的引用.

  • super()来调用父类的构造方法

  • super.fun()来调用父类的普通方法

  • super.data来调用父类的成员属性
    小总结.super和this的区别

        (1.)代表的事物不同
    
            super代表的是父类空间的引用
    
            this代表的是所属函数的调用者对象
    
        (2.)使用前提不同
    
            super必须要有继承关系才能使用
    
            this不需要继承关系也能使用
    
        (3.)调用的事物不同
    
             super:调用父类的构造方法(必须在第一行),普通方法或成员变量
    
             this:调用所属类的构造方法(必须在第一行),普通方法或成员变量
    

2.5 再谈初始化

代码块在继承关系上的执行顺序

class Person {
	public String name;
	public int age;
	public Person(String name, int age) { 
	  this.name = name; 
	  this.age = age; 
	  System.out.println("Person:构造方法执行"); 
	}
	{ 
	  System.out.println("Person:实例代码块执行"); 
	}
	static { 
	  System.out.println("Person:静态代码块执行"); 
	} 
}
class Student extends Person{
	public Student(String name,int age) { 
	  super(name,age); 
	  System.out.println("Student:构造方法执行"); 
	}

	{ 
	  System.out.println("Student:实例代码块执行"); 
	}

	static { 
	  System.out.println("Student:静态代码块执行"); 
	} 
}
public class TestDemo {
	public static void main(String[] args) { 
	  Student student1 = new Student("张三",19); 
	  System.out.println("==========================="); 
	  Student student2 = new Student("gaobo",20);
	}

	public static void main1(String[] args) { 
	  Person person1 = new Person("bit",10); 
	  System.out.println("============================"); 
	  Person person2 = new Person("gaobo",20); 
	} 
}

执行结果:

Person:静态代码块执行 
Student:静态代码块执行 
Person:实例代码块执行 
Person:构造方法执行 
Student:实例代码块执行 
Student:构造方法执行 
=========================== 
Person:实例代码块执行 
Person:构造方法执行 
Student:实例代码块执行 
Student:构造方法执行

通过分析执行结果,得出以下结论:
1、父类静态代码块优先于子类静态代码块执行,且是最早执行
2、父类实例代码块和父类构造方法紧接着执行
3、子类的实例代码块和子类构造方法紧接着再执行
4、第二次实例化子类对象时,父类和子类的静态代码块都将不会再执行

2.6 protected 关键字

刚才我们发现, 如果把字段设为 private, 子类不能访问. 但是设成 public, 又违背了我们 “封装” 的初衷.两全其美的办法就是 protected 关键字.

  • 对于类的调用者来说, protected 修饰的字段和方法是不能访问的
  • 对于类的 子类 (可以同一个包也可以不是同一个)和 同一个包的其他类 来说, protected修饰的字段和方法是可以访问的
// Animal.java 
public class Animal { 
 protected String name; 
 public Animal(String name) { 
 this.name = name; 
 } 
 public void eat(String food) { 
 System.out.println(this.name + "正在吃" + food); 
 } 
} 
// Bird.java 
public class Bird extends Animal { 
 public Bird(String name) { 
 super(name); 
 } 
 public void fly() { 
 // 对于父类的 protected 字段, 子类可以正确访问
 System.out.println(this.name + "正在飞 ︿( ̄︶ ̄)︿"); 
 } 
} 
// Test.java 和 Animal.java 不在同一个 包 之中了. 
public class Test { 
 public static void main(String[] args) { 
 Animal animal = new Animal("小动物"); 
 System.out.println(animal.name); // 此时编译出错, 无法访问 name 
 } 
}

2.7 更复杂的继承关系

刚才我们的例子中, 只涉及到 Animal, Cat 和 Bird 三种类. 但是如果情况更复杂一些呢?针对 Cat 这种情况, 我们可能还需要表示更多种类的猫
在这里插入图片描述
这种情况将会出现更复杂的继承关系,一般我们不希望出现超过三层的继承关系. 如果继承层次太多, 就需要考虑对代码进行重构了.如果想从语法上进行限制继承, 就可以使用 final 关键字.

2.8 final 关键字

曾经我们学习过 final 关键字, 修饰一个变量或者字段的时候, 表示常量 (不能修改).

final int a = 10; 
a = 20; // 编译出错
final 关键字也能修饰类, 此时表示被修饰的类就不能被继承.
final public class Animal { 
 ... 
} 
public class Bird extends Animal { 
 ... 
} 
// 编译出错
Error:(3, 27) java: 无法从最终com.bit.Animal进行继承

final 关键字的功能是 限制 类被继承"限制" 这件事情意味着 “不灵活”. 在编程中, 灵活往往不见得是一件好事. 灵活可能意味着更容易出错.
使用 final 修饰的类被继承的时候, 就会编译报错, 此时就可以提示我们这样的继承是有悖这个类设计的初衷的
我们平时是用的 String 字符串类, 就是用 final 修饰的, 不能被继承

⭐️最后的话⭐️

总结不易,希望uu们不要吝啬你们的👍哟(^U^)ノ~YO!!如有问题,欢迎评论区批评指正😁

在这里插入图片描述

  • 16
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 14
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 14
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

如风暖阳

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值