包_继承

包_继承

1.包

包(package) 用于管理程序中的类，主要用于解决类的同名问题。包可以看成目录。

包的作用：

【1】防止命名冲突

【2】允许类组成一个单元模块，便于管理

【3】更好的保护类、属性和方法

1.1定义包

package用于定义包，形如：package   路径（包名）

必须写到源文件的有效代码的第一句。

package cm.wuhao;     //定义包

public class Test01{
    public static void main(String[] args){
        System.out.println("test package");
    }
}

编译带包的源文件

javac -d 目的地 源文件

编译完成后生成的字节码的全路径

运行编译好的字节码文件

java 包路径+类名

例如：

 1.2包的命名规范

原则：始终保持类的全路径是唯一

规范：

[1]包名由小写字母组成，不能以圆点开头或结尾。圆点有特殊意义——包分隔符

[2]包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名。如javagroup.com.xx   avagroup.net.xx

[3]包名后续部分依不同机构内部的规范不同而不同

1.3导包

import 用于导包，告诉类需要的其他类在什么位置（路径）。

形如：

import com.wuhao.Student； // 导入com.wuhao下的Student类。 

import com.wuhao.*； // 导入com.wuhao下的所有类。

编译时要先编译导入的包，其他类生成该类的全路径方能编译本类成功。

1.4不同包中的同名

如果一个类中用到了两个不同包但同名的类时，如何处理？

import java.util.Date; //两个包中都有date类
import java.sql.Date;

public class Test05{
    public static void main(String[] args) { 
    Date date = new Date(0);
}

}

这时候系统报错，并没有通过编译

我们可以这样处理：

创建对象时写其中一个对象的全路径

import java.sql.Date;//sql中的Date类

public class Test05{
    public static void main(String[] args) { 
    java.util.Date date1 = new java.util.Date();//写全路径
    System.out.println("date1的地址"+date1);
    Date date2 = new Date(0); //调用sql中的Date类
    System.out.println("date2的地址"+date2);
}

}

2.jvm中提供的包

包名	描述
java.lang/语言包	系统默认导入，String类保存在这个包中，所以我们在使用String时不需要导包
java.util	工具包，一些常用的类库，Scanner,Date,Arrays
java.io	输入输出处理，文件的读写等
java.net	网络编程
java.math	数学计算.Math.random
java.awt(C)	这个包中的类用于构建和管理应用程序的图形用户界面

3.静态导入

如果一个类中定义的属性和方法都是静态时，可以考虑使用静态导入。jdk1.5+ 出现。

package cn.sxt01;
public class Calc{
    public static float PI = 3.14f; //静态属性
    
    public static int add(int a,int b){
        return a+b;
    }
}

package cn.sxt02;
// 静态导入
import static cn.sxt01.Calc.*;
public class Test01{
    public static void main(String[] args){
        System.out.println(PI);
        System.out.println(add(1,2));
    }
}

思考:如果一个类中还有实例成员，能不能用静态导入？

4.继承

4.1为什么要继承？

为了提取较少代码的重复性，把抽取重复性的代码到一个公共类中，这个公共的类称为父类(super class)。继承于父类的类称为子类(sub class).

java 的继承特性：

【1】单根性：只能有一个父类（只有一个爸爸）

【2】传递性：可以是爸爸从爷爷那继承过来的非私有的属性和方法，儿子在从爸爸那里继承下来（类似中国的香火延续）

类B继承于类A，使用关键字extends，则B拥有了A中非私有的属性和方法。

class Car { 　　　　　　　　　　　　　　　　　　//父类
    private int site;  //座位数
    public void setSite(int site){
        this.site = site;
    }
    void print(){
        System.out.print("载客量是"+site+"人");
    }
}

class Bus extends Car { 　　　　　　　　　　//子类
    Bus(int site){
        setSite(site);
    }
}

public class Test04{
    public static void main(String[] args) { 　　
    Bus bus = new Bus(20);    
    bus.print();
}

}    

如果Person中定义了private 属性count

5.super关键字

super只是一个关键字，区别于this关键字，super并没有引用有地址。

super的作用：

【1】访问父类的构造方法

public Dog(String name,int health,int love,String strain){
        /*
        this.setName(name);
        this.setHealth(health);
        this.setLove(love);
        */
        super(name,health,love);
        this.setStrain(strain);
        
    }

super调用父类构造方法时，必须写到构造方法有效代码第一句

【2】super调用父类的非私有属性

super可以访问父类的非私有属性。私有的属性不能用super访问。

变量隐藏(C)

当子类定义了一个和父类同名的属性时，在子类中优先访问子类的属性，如果要访问父类属性一定要加super。

一句话:如果要访问父类属性，通过super；如果要访问子类属性，通过this.

[3] super访问非私有父类方法

public void print(){
        System.out.print("我的姓名"+super.getName());
        System.out.print("，健康值"+super.getHealth());
                System.out.print("，亲密度"+super.getLove());
        super.showInfo();
        System.out.println("，我是一只"+this.getStrain());
    }
                        

6.子类不能继承父类的资源

7.访问修饰符

java中存在4类访问修饰符，分别是private、默认、protected、public。

修饰符	本类✘	同包子类	同包其他类	不同包子类	不同包其他类
private	✔	✘	✘	✘	✘
默认	✔	✔	✔	✘	✘
protected	✔	✔	✔	✔	✘
public	✔	✔	✔	✔	✔

private ：只能访问本类成员

friendly：默认的，同包可以访问，包访问符

protected：除了不同包的其它类不能访问，其它都可以访问

public：全都可以访问

8.继承的循序

继承关系内存图

9.方法的重写

当子类从父类继承过来的方法不能满足自身需要时，子类可以根据自身情况进行方法重写(overwrite/override)

方法重写建立在继承的基础上，没有继承，就没有重写！

子类根据自身情况，可以选择部分重写和完全重写。

 部分重写

public void showInfo(){
        super.showInfo();
        System.out.println("我是一只"+this.getStrain());
    }

完全重写

public void showInfo(){
        System.out.println("--"+super.getName()+"--");
        System.out.println("健康值:"+super.getHealth());
        System.out.println("亲密度:"+super.getLove());
        System.out.println("品种:"+this.getStrain());
    }

重写的规则

[1]方法名称相同

[2]参数列表相同

[3]子类的访问权限一定 >= 父类访问权限 private 特殊除外

[4]返回值和父类相同或者是其子类

public Pet create(){
        Pet pet = new Pet();
        return pet;
}

public Dog create(){
        Dog dog = new Dog();
        return dog;
}