1 包 继承
1.1 包
1.1.1 为什么会使用包?
为了更好的管理同名的类。
包就是目录
包解决的问题---类的同名问题。
[1] 防止命名冲突。
[2] 易于管理包和类。
[3] 更好的保护类、属性、方法。
1.1.2 创建包
通过关键字package 创建包,package 一定要出现在类文件的第一句。
包的命名规则
[1]包名由小写字母组成,不能以圆点开头或结尾
e.g: package sxt;
[2]包名之前最好加上唯一的前缀,通常使用组织倒置的网络域名。如:域名javagroup.net
e.g: package cn.sxt.xxx
[4]包名后续部分依不同机构内部的规范不同而不同
e.g: package cn.sxt.qq.xxx
形式:倒置域名.部门.项目组.xxx
整体原则:保持类路径唯一。
1.1.3 编译带包的类
javac –d <目标目录> <源文件目录> 指定放置生成的类文件的位置
|
|
总结
javac –d 也可以编译没有定义包的类。
如果一个类没有定义任何包,jvm默认分配一个包(defaultpackage)
特殊情况1:
当源文件和编译目标路径不在同一目录下时。
|
特殊情况2:
|
|
Test01找Dog时,从当前目录demo02开始找。
开发工具提供的包解决方案:
[1]人为定义src用于存源文件,人为定义一个bin用于存储.class
[2] 保持源文件中的包和目录一一对应。
|
[3] 编译时进入src,从src开始编译。src就是包的开始。
|
1.1.4 导入包
import 关键字用于导包。加载类的全路径。
为了使用不在同一包中的类,需要在Java程序中使用import关键字导入这个类
import java.util.*; // 导入java.util下的所有类。 |
package cn.sxt;
import cn.sxt2.Dog; public class Test01{
public static void main(String[] args){ // 此时Dog是和Test01同一目录的Dog //Dog dog = new Dog();
//Penguin p = new Penguin();
Dog dog = new Dog(); dog.showInfo(); } } |
|
在同一个类中可能会导入不同包中的同名类。
import java.util.*; import java.sql.*;
public class Test01{ public static void main(String[] args){ Date d = new Date(); }
} |
|
解决方法
[1] 指定类时明确类的名称
import java.util.*; import java.sql.Date;
public class Test01{ public static void main(String[] args){ // Date明确指java.sql.Date Date d = new Date(0); System.out.println(d); }
} |
[2]创建对象时明确类名
import java.util.*; import java.sql.*;
public class Test02{ public static void main(String[] args){
java.util.Date d = new java.util.Date(0); System.out.println(d); }
} |
1.1.5 系统包
包 | 备注 |
java.lang(language) | 语言级别的包,该包不需要导入,jvm自动加载。 |
java.util | 工具包。 |
java.io | 输入输出流 |
java.net | 网络编程 |
java.awt | 这个包中的类用于构建和管理应用程序的图形用户界面 |
1.1.6 静态导入
如果一个类中的方法或属性全部是使用static声明,
那么在导入该类的时候就可以使用静态导入的方式
package cn.sxt;
import static cn.sxt.Calc.*; public class Test03{ public static void main(String[] args){
int r = add(1,2); System.out.println("pi = "+ PI); System.out.println("r = " + r); } } |
注意:
修改代码,一定要清理掉之前的.class。
1.2 继承
1.2.1 为什么要使用继承?
|
为了减少重复性的代码,在类设计上可以把多个类公共的代码提取到一个公共的类中,这个公共类称为父类(super class),让这些多个类继承于这个公共父类,这些类称为父类子类(sub class)。
继承的特性
[1] 单继承。java是单继承,只能直接继承一个父类。
[2] 传递性。C继承了B,B继承A。C是A的间接子类,C具有A的特征和行为。
子类继承父类,子类拥有父类的非私有的属性和方法,使用关键字extends实现继承。
同时,子类还可以包含自身特有的属性和方法。
public class Test01{
public static void main(String[] args){ Dog dog = new Dog(); dog.color = "red"; // dog访问父类非私有的属性 // dog.name = "" // error private访问控制限制 dog.setName("二狗"); // dog可以访问父类公共的方法 dog.print(); // dog可以访问父类公共的方法 } } |
1.3 Super
super关键字用于在子类中访问父类成员。
super 只是一个关键字,表示父对象,不存在引用。
[1]访问父类的非私有方法。
public void showInfo(){
System.out.print("我的名称"+super.getName()); System.out.print(",健康值"+super.getHealth()); System.out.print(",亲密度"+super.getLove());
System.out.print(",我是一只"+this.getStrain()); } |
[2] 访问父类的非私有属性
public void showInfo(){
// 访问父类非私有属性 System.out.print(",颜色"+super.color);
System.out.print(",我是一只"+this.getStrain()); } |
思考题:Pet中定义了非私有color,Dog也定义了非私有Color。如何在子类访问子类Color和父类Color?
[3] 访问父类的构造方法
形式:super(参数1,参数2,…)
public Dog(String name,int health,int love,String strain){
/*super.setName(name); super.setHealth(health); super.setLove(love); */ super(name,health,love); this.setStrain(strain);
} |
|
1.4 子类从父类到底继承了什么?
子类不能继承父类的
|
1.5 访问修饰符权限
访问修饰符一般用于限制属性、方法、类、接口等的访问权限。java中有4种访问权限。
关键字 | 本类 | 同包子类 | 同包其他类 | 不同包子类 | 不同包其他类 |
public | ✔ | ✔ | ✔ | ✔ | ✔ |
默认friendly | ✔ | ✔ | ✔ | ✘ | ✘ |
protected | ✔ | ✔ | ✔ | ✔ | ✘ |
private | ✔ | ✘ | ✘ | ✘ | ✘ |
public:公共权限。任何情况都可以访问。权限最大。
protected:受保护的权限。①子类可访问 ②同包可访问
默认(friendly),也称为包访问权限。同包可访问。
private:私有的,本类可访问。
1.6 继承的初始化顺序
|
1.7 继承关系的内存图
|
思考:
[1] 静态属性和静态方法能不能被继承?
1.8 方法重写(override/overwrite)
1.8.1 重写概念
当子类继承父类的方法不能满足子类需要时,子类可以选择性的重写父类的方法。
// Pet public void showInfo(){ System.out.print("我的名称:"+this.getName()); System.out.print(",健康值:"+this.getHealth()); System.out.print(",亲密度:"+this.getLove()); } |
//Dog public void showInfo(){ System.out.print("我的名字:"+getName()); System.out.print(",健康值:"+super.getHealth()); System.out.print(",亲密度:"+super.getLove()); System.out.print(",我是一只:"+this.getStrain()); } |
注意:
[1] 重写的一定是方法
[2] 重写一定建立在继承的继承上,没有继承,就没有重写。
子类可以根据自身需要分为完成重写或部分重写。
完全重写:子类继承过来的东西没有任何作用,此时可以完全重写。
public void showInfo(){ System.out.print("我的名字:"+getName()); System.out.print(",健康值:"+super.getHealth()); System.out.print(",亲密度:"+super.getLove()); System.out.print(",我是一只:"+this.getStrain()); } |
部分重写:子类继承过来的东西部分有用,需要子类根据自身特性添加更多的资源。此时可以部分重写。
public void showInfo(){ super.showInfo(); System.out.print(",我是一只:"+this.getStrain()); } |
1.8.2 重写原则
- 方法名相同
- 参数列表相同
- 返回值类型(父类)相同或者是其子类;
- 访问权限不能严于父类
// Pet.java public Pet create(){ System.out.println("宠物生宠物"); Pet p = new Pet(); return p; } |
// Dog.java public Dog create(){ System.out.println("狗生狗"); Dog d = new Dog(); return d; } |
1.8.3 重写和重载区别
|
1.9 抽象类
1.9.1 抽象类概念
C继承B,B继承A,整个继承过程中,形成一个继承金字塔,位于继承金字塔顶的类越来越简答(抽象),而位于金字塔底的类,越来越具体(强大)。
位于金字塔顶端的类,根据本身特性过于抽象,我们成这样的类为抽象类(abstract class)
1.9.2 抽象类特性
[1] 抽象类不能实例化 ,abstract 修饰
public abstract class Animal{
} |
|
[2] 抽象方法
在抽象类的一些方法因为类本身过于抽象而无法实现,我们成这些方法为抽象方法(abstract method)
抽象方法一定位于抽象类中。
抽象类中的方法不一定都是抽象方法。
public abstract class Animal{
//…
public abstract void sleep();
} |
[3] 子类继承了抽象类,一定要实现抽象类中的抽象方法,除非该子类也是抽象类。
public abstract class Animal{
public abstract void sleep();
} |
public abstract class Person extends Animal{
} |
public class Person extends Animal{
public void sleep(){ System.out.println("人类的sleep方法"); }
} |
|
1.9.3 重写(override)和实现(implement)
重写:子类继承父类的方法满足不了自身需要时,子类可以重写父类的方法。一般而言,父类的方法已经实现,但不能满足子类需要。
实现:子类继承抽象的父类时,一定要完全重写抽象父类的抽象方法。这个过程称为实现。父类的方法只是一个形式的定义,没有方法体。
实现是一种特殊的重写,一种强制性的重写。
1.10 Final
final 关键字表示最终的意思。可以用于修饰类、方法、属性、局部变量等。
[1]final修饰类表示最终类。最终类不能被继承。
public final class Animal{
} |
public class Person extends Animal{
} |
|
[2]final修饰符方法。最终方法不能被重写。
public class Animal{
public final void sleep(){
} } |
public class Person extends Animal{
public void sleep(){ System.out.println("Person:sleep"); } } |
|
[3] 修饰属性。经常和static配合声明静态常量。
static final String GENDER_MAN = “男”; static final String GENDER_WOMAN = “女”; |
[4] 局部变量
final修饰基本数据类型。变量代表的空间值不能发生变量。
final 修饰引用数据类型。修饰变量表示引用的空间不能发生变化。引用空间中的属性不受final限制。
使用final修饰引用型变量,变量不可以再指向另外的对象
public class Test01{
public static void main(String[] args){
final Person a;
a = new Person(); a.name = "kallen1"; a.name = "kallen2"; System.out.println("a = "+a);
/* a = new Person(); System.out.println("a = "+a); */ } } |
思考:
静态方法可以重写吗?
1.11 总结
Q:为什么要使用继承?
提取重复性代码,减少代码量
Q:何时使用继承
[1] 复合is a关系。
[2] 多个类存在重复性代码
1.12 开发工具
主流:Eclipse / IDEA
下载地址:eclipse.org
1.12.1 快捷键
ctrl++ | 编辑区字体放大 |
ctrl+- | 编辑区字体缩小 |
ctrl+1 | 快速修复代码 |
ctrl+shift+f | 格式化代码 |
shift+alt+s | source菜单 |
ctrl+alt+向上/向下 | 向上/向下快速复制本行代码 |
ctrl+shift+o | 快速导包 |
alt+向上/向下 | 快速移动代码 |
配置eclipse智能提示
|