java面向对象——包+继承+多态（一）-1-阿里云开发者社区

包（package）

概念：

是组织类的一种方式，能够保证类的唯一性

创建包

在src包下点击new 然后package创建包，就能够创建出一个包，在创建的包下新建java class就会创建一个类。

注意事项：

1 在文件的最上方加上一个 package 语句指定该代码在哪个包中，比如创建一个class的包,在这个包下新建的java文件，要在最上方加上package class（IDEA一般会自动生成）

2 如果一个类没有 package 语句, 则该类被放到一个默认包中

3 包名需要尽量指定成唯一的名字

导入包中的类：

直接导入

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

这种导入就需要我们知道，我们调用的类在那个包目录下，而且这样子也很麻烦，在这里作为一个了解就可以。

import语句导入

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

当我们对Date这个类实例化的时候，我们可以发现，IDEA会自动提示出这个类所在的包，此时我们只需要双击一下java.util（在这里，要特别提一下，不同的包里面的类名是可以一样的，我们语句中时间戳的功能，是在java.util这个包下的Date类实现的，这个问题不需要深究，只需要理解利用import是怎么导入包中的类），这个时候就会自动帮我们导入包中的类。

上面所讲的就是通过import语句导入包中具体类名称，其实也可以使用java.util.*;导入，代码也不会报错

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

这个可以理解是一个通配项，这样子确实会比较方便，也很简单，但是我们并不建议这样子去导入包中的类，最好要具体到类名

import java.util.*;
import java.sql.*;

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

如果此时导入java.util与java.sql包那么此时Date就会报错，原因就是util与sql包下都有一个Date类，那么此时编译器就懵逼了，就不知道导入的是谁的了，那么此时就需要我们导入具体的一个类名就不会报错了

注意事项：

1 不同与c语言，java在使用通配项的时候，不是把包下的所有类都导入进去，是需要哪一个类，才会使用哪一个类，而c语言是把所有的类全部导入

2 包名必须是小写字母

3 在导入包中的类的时候，要导入具体的类名称，养成良好的编程习惯。

静态导入（了解即可）

使用 import static 可以导入包中的静态的方法和字段.

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

取最大值的时候，如果没有调用使用静态导入就必须得是math.max(2,3)，可以看到system以及math就可以省略掉了，这就是静态导入。

包的访问权限

在java的类与对象中，我们已经初步认识到类中的public与priate访问限定符，包访问权限就是不加任何关键字去修饰，直接定义其类型。访问的范围：只能在同一个包中。

常见的系统包

java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
java.lang.reflect:java 反射编程包;
java.net:进行网络编程开发包。
java.sql:进行数据库开发的支持包。
java.util:是java提供的工具程序包。(集合类等) 非常重要
java.io:I/O编程开发包。

继承

class dog{
    public String name;
    public int age;
    public void eat(){
        System.out.println("eat()");
    }
}
class bird{
    public String name;
    public int age;
    public void eat(){
        System.out.println("eat()");
    }
    public void fly(){
        System.out.println("fly()");
    }
}
public class test {
    public static void main(String[] args) {
    dog dog=new dog();
    dog.name="haha";
    bird bird=new bird();
    bird.name="heihei";
    bird.fly();
    }
}

在上面这个代码我们可以看到，对于bird以及dog类中都含有共同的字段与方法，那么这个时候我们就可以通过继承来对代码实现重复利用（对代码的共同属性进行抽取）

class animal{
    public String name;
    public int age;
    public void eat(){
        System.out.println("eat()");
    }
}
class dog extends animal{
}
class bird extends animal{
    public void fly(){
        System.out.println("fly()");
    }
}
public class test {
    public static void main(String[] args) {
    dog dog=new dog();
    dog.name="haha";
    bird bird=new bird();
    bird.name="heihei";
    bird.fly();
    }
}

在这里我们可以发现，继承是由关键字extends来引出的，其中dog，bird我们称之为子类，派生类，animal我们称之为父类，基类，超类

继承的语法规则

class 子类 extends 父类 {

}

注意要点：

1 通过关键字extends指定父类

2 java中只能继承一个父类

3 子类会继承父类中所有的字段与方法

4 对于private修饰的字段，子类是不能访问的

5 子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用.

6 如果一个类不想被继承，那么可以使用关键字final去修饰这个类

super关键字（重点）

1 super（）帮助父类进行构造

在利用构造方法对子类进行构造时，必须要先帮助父类进行构造

class animal{
    public String name;
    public int age;
    public void eat(){
        System.out.println(name+"eat()"+age);
    }
    public animal(String name,int age){
      this.name=name;
      this.age=age;
      eat();
    }
    public void func(){
        System.out.println("");
    }
}
class dog extends animal{
    public dog(String name,int age){
        super(name,age);//调用父类含有两个参数的构造方法
    }
}
class bird extends animal{
    public bird(String name,int age){
        super(name,age);//调用父类含有两个参数的构造方法
    }
    public void fly(){
        System.out.println("fly()");
    }
}
public class test {
    public static void main(String[] args) {
    dog dog=new dog("haha",10);
    bird bird=new bird("heihei",20);
    }
}

注意事项：

1 super在帮助子类构造父类的时候，super（）必须处于子类构造方法的第一行

2 super表示父类的实例引用，是依赖于对象的，所以是不能出现在静态方法里面的

2 super.func()调用父类的普通方法

class animal{
    public String name;
    public int age;
    public void eat(){
        System.out.println(name+"eat()"+age);
    }
    public animal(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void func(){
        System.out.println("");
    }
}
class dog extends animal{
    public dog(String name,int age){
        super(name,age);
        super.eat();
    }
}

在这个代码中，我们可以看到在子类中可以利用super关键字调用父类普通方法，这里要注意super在调用父类的方法时不能写出方法外面的

3 super.data引用父类实例

这个就是在子类中，通过super关键字去访问父类的字段

super关键字与this关键字的区别：

1 super是在父子类的前提下，作用在子类，在子类里去访问父类的方法与字段，并且要先帮助父类构造方法，必须放在第一行

2 this关键字查找范围在本类中或者是本类中没有就去父类中查找，通过this可以调用本类中的字段（本类中要是没有就会去父类中查找），调用本类中的方法（本类要是没有，就会去父类中查找），也可以在本类调用构造方法，调用构造方法需要放在方法的第一行

java面向对象——包+继承+多态（一）-2

/article/1503990

java面向对象——包+继承+多态（一）-1

包（package）

概念：

创建包

注意事项：

导入包中的类：

直接导入

import语句导入

静态导入（了解即可）

包的访问权限

常见的系统包

继承

继承的语法规则

注意要点：

super关键字（重点）

1 super（）帮助父类进行构造

注意事项：

2 super.func()调用父类的普通方法

3 super.data引用父类实例

super关键字与this关键字的区别：

热门文章

最新文章

相关课程

相关电子书

相关实验场景