包的含义：
可以理解为包就是目录。
包的作用：
1.解决类同名的问题。
2.更好的管理、维护、保护类。
包的定义：
package 必须放在有效代码的第一句。
1 package cn.sxt;
2
3 public class Test01{
4 public static void main(String[] args){
5 System.out.println("test package");
6 }
7 }
编译带包的源文件
1 javac -d 源文件 目的文件
例子：
编译完成后的全路径为cn.sxt.Test01.
2.导入包(B)
形式：
import cn.sxt.Test01 ;//导入cn.sxt包下的Test01类
import cn .sxt.*;//导入cn.sxt包下的所有类。
1 package cn.sxt01;
2 public class Test01{
3 public static void main(String[] args){
4 Student s = new Student();
5 }
6 }
1 package cn.sxt02;
2
3 public class Student{
4 private String name;
5
6 public void setName(String name){
7 this.name = name;
8 }
9 public String getName(){
10 return this.name;
11 }
12 }
1 package cn.sxt01;
2
3 + import cn.sxt02.Student;
4 public class Test01{
5 public static void main(String[] args){
6 Student s = new Student();
7 }
8 }
package cn.sxt01;
import cn.sxt02.Student;
public class Test01{
public static void main(String[] args){
Student s = new Student();
}
}
1 package cn.sxt02;
2
3 public class Student{
4 private String name;
5
6 public void setName(String name){
7 this.name = name;
8 }
9 public String getName(){
10 return this.name;
11 }
12 }
编译过程
运行效果
3.不同包中的同名同类的包用法(B)
(1)创建对象时写全路径如：
1import 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)
方法和属性静态时考虑用静态导入
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 cn.sxt01.Calc;
4 // 静态导入
5 import static cn.sxt01.Calc.*;
6 public class Test01{
7 public static void main(String[] args){
8 System.out.println(PI);
9 System.out.println(add(1,2));
10 }
11 }
5.继承（A）
理解：当两个类中有多个相同的属性时我们可以创建一个父类如:Farther,创建一个子类Son;用public class Son extends Farther语句继承，其中用关键字super可以直接访问父类属性方法，子类不能继承父类的私有化属性、方法。
1 public class Person{
2 String name;
3 int age;
4
5 public void showInfo(){
6 System.out.println("姓名:"+name);
7 System.out.println("，年龄:"+age);
8 }
9 }
1 public class Student extends Person{
2
3 }
1 public class Test01{
2 public static void main(String[] args){
3 Student s = new Student();
4 s.name = "张三";
5 s.age = 20;
6 s.showInfo();
7 }
8 }
6.super关键字（A）
super关键字表示父类对象，只是一个关键字，里面没有引用。
[1]super访问父类构造方法
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访问。
1 public class Fruit{
2 float price;
3 }
4 public class Apple extends Fruit{
5
6 public void showInfo(){
7 // 不推荐使用
8 //System.out.println("价格:"+price);
9 //System.out.println("价格:"+this.price);
10 // 当需要访问父类的属性时，优先使用super
11 System.out.println("价格:"+super.price);
12 }
13
14 }
变量隐藏(C)
当子类定义了一个和父类同名的属性时，在子类中优先访问子类的属性，如果要访问父类属性一定要加super。
如果要访问父类属性，通过super；如果要访问子类属性，通过this.
1 public class Fruit{
2 float price;
3
4 private String color;
5
6 int weight = 100;
7 }
1 public class Apple extends Fruit{
2
3 int weight = 200;
4
5 public void showInfo(){
6 // 不推荐使用
7 //System.out.println("价格:"+price);
8 //System.out.println("价格:"+this.price);
9 // [1]当需要访问父类的属性时，优先使用super
10 System.out.println("价格:"+super.price);
11
12 // [2]不能访问父类的私有属性
13 // System.out.println("颜色:"+super.color);
14
15 // [3] 访问和父类同名的变量weight
16 System.out.println("重量:"+weight);
17 System.out.println("重量:"+this.weight);
18 System.out.println("重量:"+super.weight);
19 }
20
21 }
子类继承父类资源
访问修饰符
private:私有的,只能在本类可以访问。
friendly:默认的,同包可访问，也称包访问权限。
protected:受保护的, ①子类可访问 ②同包可访问
public:公共的,都可以访问
继承关系内存图
方法的重写
当子类从父类继承过来的方法不能满足自身需要时，子类可以根据自身情况进行方法重写(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]子类的访问权限一定 >= 父类访问权限
[4]返回值和父类相同或者是其子类
原文地址：https://www.cnblogs.com/xfbb/p/10753366.html