包、继承、Super、方法重写

1 包_继承

1.1 包

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

包的作用

[1] 防止命名冲突。

[2] 允许类组成一个单元(模块),便于管理和维护

[3] 更好的保护类、属性和方法 

 

1.1.1 定义包

package 用于定义包，必须写到源文件的有效代码的第一句。

package cn.sxt;

public class Test01{

public static void main(String[] args){

System.out.println("test package");

}

}

编译带包的源文件

javac –d  目的地  源文件

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

1.1.2 包命名规范

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

规范：

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

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

package net.javagroup.xx

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

package net.javagroup.project1.projectname.xx

1.1.3 导包

import 用于导包，告诉类需要的其他类在什么位置！

形式:

import cn.sxt02.Student // 导入cn.sxt02下的Student类。

import cn.sxt02.* // 导入cn.sxt02下的所有类。

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

}

}

如何优雅的管理源代码和class文件(B)

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;

}

}

编译过程:

运行

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

1.1.4 不同包中的同名类

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

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

}

}

在创建对象时写全路径

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

}

}

1.2 jvm提供的包

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

1.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 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));

}

}

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

1.4 继承

1.4.1 为什么要使用继承？

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

java继承的特性

[1] 单根性。在java中，一个类只能有一个直接父类。

[2] 传递性。C继承于B，B继承于A，C具有A的特性和行为。

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

}

}

如果Person中定义了private 属性count

需要注意的是 Java 不支持多继承，但支持多重继承。      子类拥有父类非 private 的属性、方法。       子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 A 类继承 B 类，B 类继承 C 类，所以按照关系就是 C 类是 B 类的父类，B 类是 A 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。         提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

1.5 Super

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。

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

}

}

一句话:如果要访问父类属性，通过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());

}

1.6 子类继承父类的资源

1.7 访问修饰符

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

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

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

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

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

public:公共的,都可以访问

1.8 继承关系的初始化顺序

继承关系内存图

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

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

public Pet create(){

Pet pet = new Pet();

return pet;

}

public Dog create(){

Dog dog = new Dog();

return dog;

}

1.10 何时使用继承

[1] 符合 is – a 关系

学生 is a 人;

老师 is a 人;

[2] 继承实现代码重用

当多个子类拥有共同的属性和行为时，人为把共同的属性和方法提取到父类中，子类继承父类实现代码重用。