包（package），继承

1.包（package）

1）为何用包

包用于管理程序中的类，主要解决类同名问题（它的唯一性），也可以看作是现实生活中的目录。

2）作用

—可以解决包的同名问题。

—可以更好地管理类，有了包的概念，使类唯一性，可以更快捷的管理和维护。

—更好的保护类，属性和方法。

2.定义包

编译带包的源文件   javac -d ./ ./Test01

package cn.sxt;
public class Test01{
    public static void main(String [] args){
        
    }
}

注：定义包的时候要注意将其放在源代码的有效代码的第一句     [package 包的路径]放在第一句

 

 编译完成后。Test01 全路径为cn.sxt.Test01

 3.包命名规范

包命名原则:始终保持类的全路径唯一。

规范：

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

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

       如：域名javagroup.netpackage net.javagroup.xx

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

       package net.javagroup.project1.projectname.xx

 4.导包

导包一般有两种方法：

[1]    import cn.sxt02.Student;         // 导入cn.sxt02下的Student类。

[2]    import cn.sxt02.*;                    // 导入cn.sxt02下的所有类。

5.如何优雅的管理源代码和class文件

package cn.sxt01;

import cn.sxt02.Student;
public class Test01{
    public static void main(String[] args){
        Student s = new Student();
    }
}

package cn.sxt02;

public class Student{
    private String name;
    
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
}

编译过程：

  运行：

注意：编译时还没有包出来，不能用源文件的全路径形式

6.不同包的同名类

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

1）用import的两种导入方式进行处理

package cn.sxt01;

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

public class Test01{
    public static void main(String[] args){
        
        java.util.Date date1 = new java.util.Date();
        System.out.println(date1);
        
        
        Date date2 = new Date(0);
        System.out.println(date2);
        
    }
}

2）在创建对象时写全路径

package cn.sxt01;

import java.sql.Date;

public class Test02{
    public static void main(String[] args){
        
        java.util.Date date1 = new java.util.Date();
        System.out.println(date1);
        
        
        Date date2 = new Date(0);
        System.out.println(date2);
        
    }
}

7.jvm中常见的包

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

8.静态导入

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

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 cn.sxt01.Calc;
// 静态导入
import static cn.sxt01.Calc.*;
public class Test01{
    public static void main(String[] args){
        System.out.println(PI);
        System.out.println(add(1,2));
    }
}

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

可用，但 静态导入只可以导入静态成员。

9.继承

1）为何要用继承

为了提取两个类中公共的代码，可以使用继承抽取重复性的代码到一个公共类中，

这个公共的类称为父类(super class)。继承于父类的类称为子类(sub class).

2)继承的特性

—单根性，一个子类只有一个父类，一个父类有多个子类

—传递性，A继承于B，B继承于C，A具有C的特性和行为

3）继承语法

Student extends Person    Student继承于Person

 

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

public class Person{
    String name;
    int age;
    
    public void showInfo(){
        System.out.println("姓名:"+name);
        System.out.println("，年龄:"+age);
    }
}
public class Student extends Person{
    
}
public class Test01{
    public static void main(String[] args){
        Student s = new Student();
        s.name = "张三";
        s.age = 20;
        s.showInfo();
    }
}

  注： 子类只能继承父类的非私有性的属性和方法

10.Super（父类）

定义：super关键字表示父类对象，只是一个关键字，里面没有引用。

 

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

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);
        
    }

 

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

public class Fruit{
    float price;
}
public class Apple extends Fruit{
    
    public void showInfo(){
        // 不推荐使用
        //System.out.println("价格:"+price);
        //System.out.println("价格:"+this.price);
        // 当需要访问父类的属性时，优先使用super
        System.out.println("价格:"+super.price);
    }
    
}

注：变量隐藏

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

public class Fruit{
    float price;
    
    private String color;
    
    int weight = 100;
}
public class Apple extends Fruit{
    
    int weight = 200;
    
    public void showInfo(){
        // 不推荐使用
        //System.out.println("价格:"+price);
        //System.out.println("价格:"+this.price);
        // [1]当需要访问父类的属性时，优先使用super
        System.out.println("价格:"+super.price);
        
        // [2]不能访问父类的私有属性
        // System.out.println("颜色:"+super.color);
        
        // [3] 访问和父类同名的变量weight
        System.out.println("重量:"+weight);
        System.out.println("重量:"+this.weight);
        System.out.println("重量:"+super.weight);
    }
    
}

 

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());
    }

11.子类不能继承父类的成员有：

1）private（属性与方法）

2）构造方法

3）子类与父类不在同包，使用默认访问权限的成员

12.访问修饰符

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

private:私有的,只能在本类可以访问。

friendly:默认的,同包可访问，也称包访问权限。

protected:受保护的,①子类可访问②同包可访问

public:公共的,都可以访问

13.继承关系的初始化顺序

父类的属性初始化——父类构造方法——子类的属性初始化——子类构造方法

如下图

 继承关系内存图

 

 14.方法的重写（overwrite/override）

当父类的方法已经不能满足子类的自身需求时，子类就要根据自身情况进行方法重写

 注：方法的重写建立在继承上，所以没有继承就没有重写。

1）部分重写

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

 

2）完全重写

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]子类的访问权限一定>= 父类访问权限

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

public Pet create(){
        Pet pet = new Pet();
        return pet;
}
//返回值和父类相同
public Dog create(){
        Dog dog = new Dog();
        return dog;
}
//返回值是其子类

 15.何时使用继承

1）代码重用

当多个子类拥有相同的属性和方法时，应当将相同的属性和行为提取成为父类，子类拥有父类的属性和方法，从而实现子类的代码重用。

 2）符合从属关系  （is —a关系）如老师是人   学生是人