正文
包、继承、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] 继承实现代码重用
当多个子类拥有共同的属性和行为时，人为把共同的属性和方法提取到父类中，子类继承父类实现代码重用。
