【Java SE】多态、内部类、包、权限修饰符
写在前面
- 关于文章
本篇文章主要学习了JavaSE的基础进阶内容的
多态、内部类、包、权限修饰符等等。在这里学习这块基础知识时，这些知识偏向于语法，难度不大，偏向于记忆，学起来相对比较轻松，但是树高千尺，营养还在根部。基础不牢，地动山摇。所以还是有必要把基础知识学扎实。这篇文章是在老师提供的学习资料的基础上整理完善出来的。
- 我的站点
- 联系我
🐧：
2410685763WeChat：
Super_Baby_00公众号：
编程那点事儿
多态
多态是继封装、继承之后，面向对象的第三大特性。
多态是出现在继承或者实现关系中的。
多态体现的格式：
父类类型 变量名 = new 子类/实现类构造器;
变量名.方法名();
多态的前提：有继承关系，子类对象是可以赋值给父类类型的变量。例如Animal是一个动物类型，而Cat是一个猫类型。Cat继承了Animal，Cat对象也是Animal类型，自然可以赋值给父类类型的变量。
案例演示
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。如果子类没有重写该方法，就会调用父类的该方法。
总结起来就是：编译看左边，运行看右边。
代码如下：
定义父类：
public class Animal {
public void eat()｛
System.out.println("动物吃东西！")
｝
}
定义子类：
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
}
定义测试类：
public class Test {
public static void main(String[] args) {
// 多态形式，创建对象
Animal a1 = new Cat();
// 调用的是 Cat 的 eat
a1.eat();
// 多态形式，创建对象
Animal a2 = new Dog();
// 调用的是 Dog 的 eat
a2.eat();
}
}
定义和前提
多态： 是指同一行为，具有多个不同表现形式。
从上面案例可以看出，Cat和Dog都是动物，都是吃这一行为，但是出现的效果（表现形式）是不一样的。
前提【重点】
- 继承或者实现【二选一】
- 方法的重写【意义体现：不重写，无意义】
- 父类引用指向子类对象【格式体现】
父类类型：指子类对象继承的父类类型，或者实现的父接口类型。
优点
实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。
弊端
我们已经知道多态编译阶段是看左边父类类型的，如果子类有些独有的功能，此时多态的写法就无法访问子类独有功能了。
class Animal{
public void eat()｛
System.out.println("动物吃东西！")
｝
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void catchMouse() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
}
class Test{
public static void main(String[] args){
Animal a = new Cat();
a.eat();
a.catchMouse();//编译报错，编译看左边，Animal没有这个方法
}
}
引用类型转换
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。
回顾基本数据类型转换
- 自动转换: 范围小的赋值给范围大的.自动完成:double d = 5;
- 强制转换: 范围大的赋值给范围小的,强制转换:int i = (int)3.14
多态的转型分为向上转型（自动转换）与向下转型（强制转换）两种。
向上转型（自动转换）
- 向上转型：多态本身是子类类型向父类类型向上转换（自动转换）的过程，这个过程是默认的。
当父类引用指向一个子类对象时，便是向上转型。
使用格式：
父类类型 变量名 = new 子类类型();
如：Animal a = new Cat();
原因是：父类类型相对与子类来说是大范围的类型，Animal是动物类，是父类类型。Cat是猫类，是子类类型。Animal类型的范围当然很大，包含一切动物。所以子类范围小可以直接自动转型给父类类型的变量。
向下转型（强制转换）
- 向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。
一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。
使用格式：
子类类型 变量名 = (子类类型) 父类变量名;
如:Aniaml a = new Cat();
Cat c =(Cat) a;
转型的异常
转型的过程中，一不小心就会遇到这样的问题，请看如下代码：
public class Test {
public static void main(String[] args) {
// 向上转型
Animal a = new Cat();
a.eat(); // 调用的是 Cat 的 eat
// 向下转型
Dog d = (Dog)a;
d.watchHouse(); // 调用的是 Dog 的 watchHouse 【运行报错】
}
}
这段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。
instanceof关键字
为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：
变量名 instanceof 数据类型
如果变量属于该数据类型或者其子类类型，返回true。
如果变量不属于该数据类型或者其子类类型，返回false。
所以，转换前，我们最好先做一个判断，代码如下：
public class Test {
public static void main(String[] args) {
// 向上转型
Animal a = new Cat();
a.eat(); // 调用的是 Cat 的 eat
// 向下转型
if (a instanceof Cat){
Cat c = (Cat)a;
c.catchMouse(); // 调用的是 Cat 的 catchMouse
} else if (a instanceof Dog){
Dog d = (Dog)a;
d.watchHouse(); // 调用的是 Dog 的 watchHouse
}
}
}
内部类
将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。可以把内部类理解成寄生，外部类理解成宿主。
分类
按定义的位置来分
静态内部类，类定义在了成员位置 (类中方法外称为成员位置，有static修饰的内部类)实例内部内，类定义在了成员位置 (类中方法外称为成员位置，无static修饰的内部类)局部内部类，类定义在方法内匿名内部类。一般定义在方法中，或者可执行代码中
静态内部类
静态内部类特点：
有static修饰的内部类，属于外部类本身的。- 总结：静态内部类与其他类的用法完全一样。只是访问的时候需要加上
外部类.内部类。 - 拓展:
静态内部类可以直接访问外部类的静态成员。
内部类的使用格式：
外部类.内部类。
静态内部类对象的创建格式：
外部类.内部类 变量名 = new 外部类.内部类构造器;
案例演示：
// 外部类：Outer01
class Outer01{
private static String sc_name = "黑马程序";
// 内部类: Inner01
public static class Inner01{
// 这里面的东西与类是完全一样的。
private String name;
public Inner01(String name) {
this.name = name;
}
public void showName(){
System.out.println(this.name);
// 拓展:静态内部类可以直接访问外部类的静态成员。
System.out.println(sc_name);
}
}
}
public class InnerClassDemo01 {
public static void main(String[] args) {
// 创建静态内部类对象。
// 外部类.内部类 变量 = new 外部类.内部类构造器;
Outer01.Inner01 in = new Outer01.Inner01("张三");
in.showName();
}
}
实例内部类
实例内部类特点：
无static修饰的内部类，属于外部类对象的。- 宿主：外部类对象。
内部类的使用格式：
外部类.内部类。 // 访问内部类的类型都是用 外部类.内部类
实例内部类创建对象格式：
外部类.内部类 变量 = new 外部类构造器.new 内部类构造器;
- 拓展1：
实例内部类不能定义静态成员。 - 拓展2：
实例内部类可以直接访问外部类的私有和静态成员。案例演示
public class InnerClassDemo02 {
public static void main(String[] args) {
// 宿主：外部类对象。
// Outer02 out = new Outer02();
// 创建内部类对象。
Outer02.Inner02 in = new Outer02().new Inner02("张三");
in.showName();
}
}
class Outer02{
// 实例内部类，属于外部类对象的。
// 拓展：实例内部类不能定义静态成员。
public class Inner02{
// 这里面的东西与类是完全一样的。
private String name;
public Inner02(String name) {
this.name = name;
}
public void showName(){
System.out.println(this.name);
}
}
}
实例内部类面试题
请在?地方向上相应代码,以达到输出的内容
注意：内部类访问外部类对象的格式是：外部类名.this
public class Demo05 {
public static void main(String[] args) {
Body.Heart heart = new Body().new Heart();
heart.jump();
}
}
class Body { // 身体
private int weight = 30;
// 在成员位置定义一个类
class Heart {
private int weight = 20;
public void jump() {
int weight = 10;
System.out.println("心脏在跳动 " + ?); // 10
System.out.println("心脏在跳动 " + ?); // 20
System.out.println("心脏在跳动 " + ?); // 30
}
}
}
局部内部类
- 局部内部类 ：定义在方法中的类。
定义格式:
class 外部类名 {
数据类型 变量名;
修饰符 返回值类型 方法名(参数列表) {
// …
class 内部类 {
// 成员变量
// 成员方法
}
}
}
局部内部类编译后仍然是一个独立的类，编译后有$还有一个数字。Chinese$1Chopsticks.class
匿名内部类【重点】
概述
匿名内部类 ：是内部类的简化写法。它的本质是一个带具体实现的 父类或者父接口的 匿名的 子类对象。
开发中，最常用到的内部类就是匿名内部类了。
引入
实际上，如果我们希望定义一个只要使用一次的类，就可考虑使用匿名内部类。匿名内部类的本质作用
是为了简化代码。
之前使用接口时，似乎得做如下几步操作：
- 定义子类
- 重写接口中的方法
- 创建子类对象
- 调用重写后的方法
interface Swim {
public abstract void swimming();
}
// 1. 定义接口的实现类
class Student implements Swim {
// 2. 重写抽象方法
@Override
public void swimming() {
System.out.println("狗刨式...");
}
}
public class Demo07 {
public static void main(String[] args) {
// 3. 创建实现类对象
Student s = new Student();
// 4. 调用方法
s.swimming();
}
}
我们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是做这样的快捷方式。
匿名内部类前提和格式
匿名内部类必须继承一个父类或者实现一个父接口。
匿名内部类格式
new 父类名或者接口名(){
// 方法重写
@Override
public void method() {
// 执行语句
}
};
使用方式
以接口为例，匿名内部类的使用，代码如下：
创建匿名内部类，并调用：GUI做界面
interface Swim {
public abstract void swimming();
}
public class Demo07 {
public static void main(String[] args) {
// 使用匿名内部类
new Swim() {
@Override
public void swimming() {
System.out.println("自由泳...");
}
}.swimming();
// 接口 变量 = new 实现类(); // 多态,走子类的重写方法
Swim s2 = new Swim() {
@Override
public void swimming() {
System.out.println("蛙泳...");
}
};
s2.swimming();
s2.swimming();
}
}
匿名内部类的特点
- 定义一个没有名字的内部类
- 这个类实现了父类，或者父类接口
- 匿名内部类会创建这个没有名字的类的对象
匿名内部类的使用场景
通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。代码如下：
interface Swim {
public abstract void swimming();
}
public class Demo07 {
public static void main(String[] args) {
// 普通方式传入对象
// 创建实现类对象
Student s = new Student();
goSwimming(s);
// 匿名内部类使用场景:作为方法参数传递
Swim s3 = new Swim() {
@Override
public void swimming() {
System.out.println("蝶泳...");
}
};
// 传入匿名内部类
goSwimming(s3);
// 完美方案: 一步到位
goSwimming(new Swim() {
public void swimming() {
System.out.println("大学生, 蛙泳...");
}
});
goSwimming(new Swim() {
public void swimming() {
System.out.println("小学生, 自由泳...");
}
});
}
// 定义一个方法,模拟请一些人去游泳
public static void goSwimming(Swim s) {
s.swimming();
}
}
包和权限修饰符
包
包我们每天建的项目就是在一个目录下，我们每次都会建立一个包，这个包在磁盘下其实就是一个目录。包是用来分门别类的管理技术，不同的技术类放在不同的包下，方便管理和维护。
包名的命名规范：
路径名.路径名.xxx.xxx
// 例如：com.itheima.oa
- 包名一般是公司域名的倒写。
- 包名必须用”.“连接。
- 包名的每个路径名必须是一个合法的标识符，而且不能是Java的关键字。
权限修饰符
在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，我们之前已经学习过了public 和 private，接下来我们研究一下protected和缺省（default默认）修饰符的作用。
- public：公共的，所有地方都可以访问。
- protected：当前类 ，当前包，当前类的子类可以访问。
- 缺省（没有修饰符）：当前类 ，当前包可以访问。
- private：私有的，当前类可以访问。
public > protected > 缺省 > private
不同权限的访问能力
| public | protected | 缺省（空的） | private | |
|---|---|---|---|---|
| 同一类中 | √ | √ | √ | √ |
| 同一包中的类 | √ | √ | √ | |
| 不同包的子类 | √ | √ | ||
| 不同包中的无关类 | √ |
可见，public具有最大权限。private则是最小权限。
编写代码时，如果没有特殊的考虑，建议这样使用权限：
- 成员变量使用
private，隐藏细节。 - 构造方法使用
public，方便创建对象。 - 成员方法使用
public，方便调用方法。
小贴士：不加权限修饰符，就是default权限
微信关注
本站所发布的一切软件资源、文章内容、页面内容可能整理来自于互联网，在此郑重声明本站仅限用于学习和研究目的；并告知用户不得将上述内容用于商业或者非法用途，否则一切后果请用户自负。
如果本站相关内容有侵犯到您的合法权益，请仔细阅读本站公布的投诉指引页相关内容联系我，依法依规进行处理！
作者：理想
链接：https://www.imyjs.cn/archives/567
共有 0 条评论