包_继承

1.包

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

包的作用：

【1】防止命名冲突

【2】允许类组成一个单元模块，便于管理

【3】更好的保护类、属性和方法

1.1定义包

package用于定义包，形如：package   路径（包名）

必须写到源文件的有效代码的第一句。

1 package cm.wuhao;     //定义包
2 
3 public class test01{
4     public static void main(string[] args){
5         system.out.println("test package");
6     }
7 }

编译带包的源文件

javac -d 目的地 源文件

编译完成后生成的字节码的全路径

 

运行编译好的字节码文件

java 包路径+类名

例如：

 1.2包的命名规范

原则：始终保持类的全路径是唯一

规范：

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

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

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

1.3导包

import 用于导包，告诉类需要的其他类在什么位置（路径）。

形如：

1 import com.wuhao.student； // 导入com.wuhao下的student类。 

2 import com.wuhao.*； // 导入com.wuhao下的所有类。

编译时要先编译导入的包，其他类生成该类的全路径方能编译本类成功。

1.4不同包中的同名

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

1 import java.util.date; //两个包中都有date类
2 import java.sql.date;
3 
4 public class test05{
5     public static void main(string[] args) { 
6     date date = new date(0);
7 }
8 
9 }

这时候系统报错，并没有通过编译

我们可以这样处理：

创建对象时写其中一个对象的全路径

 1 import java.sql.date;//sql中的date类
 2 
 3 public class test05{
 4     public static void main(string[] args) { 
 5     java.util.date date1 = new java.util.date();//写全路径
 6     system.out.println("date1的地址"+date1);
 7     date date2 = new date(0); //调用sql中的date类
 8     system.out.println("date2的地址"+date2);
 9 }
10 
11 }

2.jvm中提供的包

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

3.静态导入

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

1 package cn.sxt01;
2 public class calc{
3     public static float pi = 3.14f; //静态属性
4     
5     public static int add(int a,int b){
6         return a+b;
7     }
8 }

1 package cn.sxt02;
2 // 静态导入
3 import static cn.sxt01.calc.*;
4 public class test01{
5     public static void main(string[] args){
6         system.out.println(pi);
7         system.out.println(add(1,2));
8     }
9 }

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

4.继承

4.1为什么要继承？

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

java 的继承特性：

【1】单根性：只能有一个父类（只有一个爸爸）

【2】传递性：可以是爸爸从爷爷那继承过来的非私有的属性和方法，儿子在从爸爸那里继承下来（类似中国的香火延续）

类b继承于类a，使用关键字extends，则b拥有了a中非私有的属性和方法。

1 class car { 　　　　　　　　　　　　　　　　　　//父类
2     private int site;  //座位数
3     public void setsite(int site){
4         this.site = site;
5     }
6     void print(){
7         system.out.print("载客量是"+site+"人");
8     }
9 }

1 class bus extends car { 　　　　　　　　　　//子类
2     bus(int site){
3         setsite(site);
4     }
5 }

1 public class test04{
2     public static void main(string[] args) { 　　
3     bus bus = new bus(20);    
4     bus.print();
5 }
6 
7 }    

如果person中定义了private 属性count

5.super关键字

super只是一个关键字，区别于this关键字，super并没有引用有地址。

super的作用：

【1】访问父类的构造方法

 1 public dog(string name,int health,int love,string strain){
 2         /*
 3         this.setname(name);
 4         this.sethealth(health);
 5         this.setlove(love);
 6         */
 7         super(name,health,love);
 8         this.setstrain(strain);
 9         
10     }

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

【2】super调用父类的非私有属性

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

变量隐藏(c)

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

一句话:如果要访问父类属性，通过super；如果要访问子类属性，通过this.

[3] super访问非私有父类方法

1 public void print(){
2         system.out.print("我的姓名"+super.getname());
3         system.out.print("，健康值"+super.gethealth());
4                 system.out.print("，亲密度"+super.getlove());
5         super.showinfo();
6         system.out.println("，我是一只"+this.getstrain());
7     }
8                         

6.子类不能继承父类的资源

 

7.访问修饰符

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

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

 

private ：只能访问本类成员

friendly：默认的，同包可以访问，包访问符

protected：除了不同包的其它类不能访问，其它都可以访问

public：全都可以访问

8.继承的循序

继承关系内存图

9.方法的重写

当子类从父类继承过来的方法不能满足自身需要时，子类可以根据自身情况进行方法重写(overwrite/override)

方法重写建立在继承的基础上，没有继承，就没有重写！

子类根据自身情况，可以选择部分重写和完全重写。

 部分重写

1 public void showinfo(){
2         super.showinfo();
3         system.out.println("我是一只"+this.getstrain());
4     }

完全重写

1 public void showinfo(){
2         system.out.println("--"+super.getname()+"--");
3         system.out.println("健康值:"+super.gethealth());
4         system.out.println("亲密度:"+super.getlove());
5         system.out.println("品种:"+this.getstrain());
6     }

重写的规则

[1]方法名称相同

[2]参数列表相同

[3]子类的访问权限一定 >= 父类访问权限 private 特殊除外

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

1 public pet create(){
2         pet pet = new pet();
3         return pet;
4 }

1 public dog create(){
2         dog dog = new dog();
3         return dog;
4 }