初识Java语言（五）- 包和继承，现在java后端的主流技术

Scanner sc = new scanner();

}

}

对于导包，我们还有一种比较简单的方式，如下

import java.util.*;

*，就是通配符。也就是在当前类中，可以直接使用util包的所有类，从而不需要再次导包了。值得注意的是，这里的导入，并不是导入util包下的所有类，这里跟C语言的include，不一样。C语言中的include，是导入头文件下的所有内容；而这里的import导入，只会在需要使用这个包下的类的时候，才会导入进来。

当然，对于import导入包时，还需要特别注意一个问题，如下：

import java.util.*;

import java.sql.*;

public class Main {

public static void main(String[] args) {

Date date = new Date(); //error， java.util.Date 还是 java.sql.Date?

}

}

此时进行编译，就会产生一个如上面代码的注释部分的错误。此时的编译器无法确定你想使用的是哪一个包下的Date类。现在就可以添加一个特定的import来解决这个问题。

import java.util.*;

import java.sql.*;

import java.util.Date; //特别指出是使用这个包下的Date类

public class Main {

public static void main(String[] args) {

Date date = new Date();

}

}

如果此时，两个包中的Date都需要使用，那就只能使用完全限定名了。如下：

import java.util.*;

import java.sql.*;

public class Main {

public static void main(String[] args) {

java.util.Date date = new java.util.Date();

java.sql.Date date2 = new java.util.Date();

}

}

静态导入

我们还可以使用静态导入包的方式，进行代码的缩写。使用import static 可以导入包中的静态方法和静态字段。这样就可以不必再加类名前缀。

import static java.lang.System.*;

public class Main {

public static void main(String[] args) {

out.println(“hello world”);

}

}

只是有这样一种机制，可以进行代码的缩写，但在现实中，这样的代码，可能更不容易读懂。所以大家使用时，酌情考虑。

在包中添加类

---

如果要想将类放入包中，就必须将包的名字放在源文件的开头，即就是放在定义这个包中各个类的代码之前。如下：

如果没有在这个源文件的开头，写package语句，则这个

《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》

【docs.qq.com/doc/DSmxTbFJ1cmN1R2dB】 完整内容开源分享

源文件中类就属于无名包（unnamed package）。无名包没有包名。

基本规则：

• 在源文件的最上方加一个package语句，可以指定该代码在哪个包

• 包名尽量指定成唯一的名字，通常会使用公司的域名逆序形成

• 包名要和代码路径相匹配。例如：package com.xxxx.demo，那么所对应的文件路径就是com/xxxx/demo

• 如果一个源文件没有package语句，则该类会被放到无名包（默认包）中

IDEA建包过程：

包访问权限

---

在之前的文章中，我们介绍过public和private。而private修饰的方法或成员变量，只能在当前这个类中访问。

如果有个类，既没有写public，也没有写private访问修饰限定符，则此时这个（类、方法或成员变量）可以在包内部（当前文件夹下）的其他类中使用，但是不能在包外部（其他文件夹下）的类中使用。如下代码：

import com.xxxx.demo1;

//demo1 包

public class Main {

public static void main(String[] args) {

Test test = new Test(); //会报错，访问权限不够。

}

}

//=假设下面是第二个文件夹下的文件=

import com.xxxx.demo2;

class Test { //访问修饰限定符：没写，我们就称为 默认

public int number;

}

public class Demo2 {

public int val;

}

访问修饰限定符权限：

| 范围 | private | 默认（default） | protected | public |

| :-: | :-: | :-: | :-: | :-: |

| 同包同类 | Y | Y | Y | Y |

| 同包不同类 | | Y | Y | Y |

| 不同包，子类 | | | Y | Y |

| 不同包，不同类 | | | | Y |

其中，protected会在继承中讲到，我们继续往下看！！！

二、继承

=============================================================

继承的基本思想就是：在已有类的基础之上，创建新的类。继承已存在的类得到就是复用了（继承）这些类的方法，而且可以增加一些新的方法和成员变量。

类、超类与子类

---

我们先来举个例子，比如一只猫和一只狗。它们了分别有自己的名字、性别、还是吃东西等等的一些性质。如下图：

他们分别都有自己的这些特征，我们也可以很容易的发现，他们都有自己一些共有的特征：比如姓名，性别。所以如果我们分别在新建猫和狗的类，还得写专属于它们自己的成员变量，这样的话，就显得代码重复累赘，如下图这样：

我们可以很清晰的看到，红色框代码部分，就是一模一样的，所以出现了重复的代码。而且这两个类都是动物，所以说引出了一个继承中的一个概念：“is -a”关系。

也就是说，什么是一个什么这样的概念。就可能会用到继承。

那该怎么实现继承关系呢？我们来看下图：

我们可以使用extends关键字来实现继承关系，这样的话，猫和狗两个类，就能够同时实现name和sex字段。这就是继承。

此时猫和狗类，我们称为子类或者派生类。而Animal类我们称为父类、基类或超类。

总结：

• 使用extends指定父类

• Java中一个子类只能继承一个父类。（而C++中可以实现多继承）

• 子类会继承父类所有的public的字段和方法

• 对于父类的private的字段和方法，子类是无法进行访问的

• 子类的实例中，也包含这父类的实例。可以使用super关键字得到父类实例的引用。

重写方法（override）

像上图，子类和父类中，方法名和参数列表是一模一样的。我们就称为方法重写（override）。可能有人就会问，我该怎么调用相应的方法呢？

我们想调用Animal的eat方法，我们只需要new出一个Animal的对象，就能进行调用，当然，Cat类的实例对象也是如此。如果我们想在Cat类的实例对象调用父类的方法，则我们可以使用super关键字进行调用。如下图：

切记：

• super关键字，在使用的时候，只能调用他的直接父类的方法或字段。比如：Animal类还继承了一个类，此时Cat类中，使用super，则只会调用Animal中的方法或字段。

• 在子类中重写的方法，这个方法的访问修饰限定符的等级，应高于或等于父类的方法的访问修饰限定符。比如：父类中的eat方法是public修饰，而子类中的eat方法也应该是public，或者是更高的。（当然只是举个例子，public就是最高的访问修饰限定符了）

• 被重写的方法，不能是被static修饰的

this与super的区别：

子类构造器

在上面说了，super关键字来调用父类的构造方法，那具体是如何进行调用的，我们来看一下具体的代码实现：

public class Cat extends Animal{

public Cat(String name, String sex) {

super(name, sex); //调用父类的构造方法，super语句必须在子类构造器的第一行

System.out.println(“Cat的构造方法”);

}

public void eat() {

System.out.println(“吃鱼”);

}

}

public class Animal {

public String name;

public String sex;

public Animal(String name, String sex) { //父类的构造方法

this.name = name;

this.sex = sex;

}

public void eat() {

System.out.println(“吃肉”);

}

}

总结：

• 使用super构造方法的语句必须放在子类构造方法中的第一行。

• 如果子类中，没有显示地调用父类的构造方法，将自动地调用超类的无参构造方法。

• 在进行子类的实例化时，会调用子类的构造方法，而在调用子类构造方法时，将会先调用父类的构造方法。也就是说：new Cat ，实际上将先会新建出父类，在父类新建完成后，才会回到子类的构造方法，进行新建子类。

下面是一道有趣的题：请问下列代码的输出结果是什么。

class X {

Y y=new Y();

public X() {

System.out.print(“X”);

}

}

class Y {

public Y() {

System.out.print(“Y”);

}

}

public class Z extends X {

Y y=new Y();

public Z() {

System.out.print(“Z”);

}

public static void main(String[] args) {

new Z();

}

}

上面的代码的输出结果是：YXYZ。

分析：

• 如果调用的是子类，那么在进入子类构造方法后，将先执行super语句（若没写，编译器自带），先构造父类。

• 在父类构造完成后，再次回到子类的构造方法。此时将先初始化当前类的成员变量。

• 在成员变量初始化之后，才会执行构造方法里面的语句。

上诉代码执行流程图：

protected关键字

在上文中，我写了一个访问修饰限定符的表，表中第3个protected关键字。

前面我们学了public和private访问修饰限定符，public的权限有大了，对于public来说，整个工程都可以进行使用；而对于private来说，只能在当前的类中进行使用。二者之前，一个权限过大，一个权限过小。所以在Java的继承中，还引入了这个关键字：protected；

对于protected来说，protected修饰的内容，在这个包下，可以直接使用。而在不同的包下，只有继承了这个类，才能在不同的包下使用该类被protected修饰内容。

阻止继承：final关键字

在前面的文章中，我们介绍过final关键字，final修饰的变量，在初始化之后，将不能被修改。

final int a = 10;

最后

以上就是无私衬衫为你收集整理的初识Java语言（五）- 包和继承，现在java后端的主流技术的全部内容，希望文章能够帮你解决初识Java语言（五）- 包和继承，现在java后端的主流技术所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。