包与继承

包的含义：

可以理解为包就是目录。

包的作用：

1.解决类同名的问题。

2.更好的管理、维护、保护类。

包的定义：

package 必须放在有效代码的第一句。

package cn.sxt;

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

编译带包的源文件

javac -d 源文件 目的文件

例子：

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

2.导入包(B)

形式：

import cn.sxt.Test01 ;//导入cn.sxt包下的Test01类

import cn .sxt.*;//导入cn.sxt包下的所有类。

package cn.sxt01;
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;
    }
}

package cn.sxt01;

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

 

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

编译过程

运行效果

 3.不同包中的同名同类的包用法(B)

(1)创建对象时写全路径如：

import java.util Date;

2 import java.sql.*;
3 public class Test{
4    public static void main(String[] args){
5    java.sql.Date sc = new java.sql.Date();
6     }
7 }

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

4.静态导入(B)

方法和属性静态时考虑用静态导入

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

5.继承（A）

理解：当两个类中有多个相同的属性时我们可以创建一个父类如:Farther,创建一个子类Son;用public class Son extends Farther语句继承，其中用关键字super可以直接访问父类属性方法，子类不能继承父类的私有化属性、方法。

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

6.super关键字（A）

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

[1]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);
        
    }

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

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

变量隐藏(C)

当子类定义了一个和父类同名的属性时，在子类中优先访问子类的属性，如果要访问父类属性一定要加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);
    }
    
}

子类继承父类资源

 访问修饰符

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

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

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

public:公共的,都可以访问

继承关系内存图

 方法的重写

当子类从父类继承过来的方法不能满足自身需要时，子类可以根据自身情况进行方法重写(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]子类的访问权限一定 >= 父类访问权限

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