1）区分相同名字的类
2）当类很多时，可以很好的管理类
3）控制访问范围
1.2 包的命名命名规则：只能包含数字、字母、下划线、小圆点，但不能用数字开头，不能是关键字或保留字。
命名规范：
1）一般是小写字母+小圆点
2）一般是：com.公司名.项目名.业务模块名 如：com.hspedu.oa.controller
1.3 常用的包1）java.lang.* //lang包是基本包，默认引用，不需要再引入
2）java.util.* //util包是系统提供的工具包
3）java.net.* //网络包，网络开发
4）java.awt.* //是做Java的界面开发，GUI
1.4 注意事项和使用细节1、package的作用是声明当前类所在的包，需要放在类的最上面，一个类中最多只有一句package。
2、import指令位置放在package的下面，在类定义的前面，可以有多句且没有顺序的要求。
2 访问修饰符 2.1 基本介绍Java提供四种访问修饰符，用于控制方法和属性(成员变量)和访问权限(范围)
1）公开级别：public，对外公开
2）受保护级别：protected，对子类和同一个包中的类公开。
3）默认级别：没有修饰符，向同一个包的类公开
4）私有级别：private，只有类本身可以访问，不对外公开
2.2 使用的注意事项1）修饰符可以用来修饰类中的属性，成员方法以及类
2）只有默认和public才能修饰类，并遵循上述访问无权限规则
3）成员方法的访问规则和属性完全一样。
3 封装 3.1 基本介绍封装就是把抽象出的数据(属性)和对数据的操作(方法)封装在一起，数据被保护在内部，程序的其他部分只能通过被授权的方法才能对数据进行操作。
3.2 实现步骤1）将属性私有化 private
2）提供一个公共的(public) set方法，用于对属性判断并赋值
public void setXxx(类型 参数名){
属性 = 参数名;
}
例：
public void setName(String name){
this.name = name;
}
3）提供一个公共的(public) get方法，用于获取属性值
public 返回值类型 getXxx(){
return xx;
}
例：
public String getName(){
return name;
}
4 继承
4.1 基本介绍
4.2 基本语法
class 子类 extends 父类{
}
1）子类会自动拥有父类定义的属性和方法
2）父类又叫超类、基类
3）子类又叫派生类
4.3 继承的好处1）代码的复用性提高
2）代码的扩展性和维护性提高
4.4 继承的深入讨论/细节1）子类继承了父类所有的属性和方法，非私有的属性和方法可以在子类直接访问，但私有属性和方法不能在子类直接访问，要通过父类提供的公共方法去访问
2）子类必须调用父类的构造器
3）当创建子类对象时，不管使用子类的那个构造器，默认都会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的那个构造器完成对父类的初始化，否则，编译不会通过。
4）如果希望调用父类的某个构造器，则显示的调用
5）super在使用时，必须放在构造器第一行(super只能在构造器中使用)
6）super() 和 this()都只能放在构造器第一行，因此这两个方法不能共存在一个构造器
7）Java所有类都是Object类的子类，Object是所有类的基类
8）父类的构造器的调用不限于直接父类，将一直向上追溯之Object类
9）子类最多只能继承一个父类，即java是单继承机制
10）不能滥用继承，自类和父类必须满足 is-a 关系
5 super关键字 5.1 基本介绍super代表父类的引用，用于访问父类的属性、方法、构造器
5.2 基本语法1）访问父类属性，但不能访问peivate属性
super.属性名;
2）访问父类的方法，不能访问父类的private方法
super.方法名(参数列表);
3）访问父类构造器
super(参数列表);只能放在构造器第一句，只能出现一句，不能与this()同时出行5.3 super给变成带来的便利
1）调用父类构造器的好处（分工明确，父类属性由父类初始化，子类属性由子类初始化）
2）当子类中有和父类中的成员（属性或方法）重名时，为了访问父类成员，必须使用super
3）super的访问不限于直接父类，如果爷爷类和本类中有同名成员也可以使用super去访问爷爷类成员；如果多个基类中都有同名成员，使用super访问就遵循就近原则，也遵循访问控制权限规则。
5.4 super 和 this的比较 6 重写/覆盖 6.1 基本介绍简单来说：方法覆盖就是子类有一个方法，和父类的某个方法名称、返回类型、参数一样，我们就说子类的这个方法覆盖了父类的方法。
6.2 注意事项和使用细节1）子类的方法的形参列表，方法名称，要和父类的形参列表，方法名称完全一样。
2）子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类。
3）子类方法不能缩小父类方法的访问权限
6.3 重写和重载的比较 7 多态方法或对象具有多种形态。是面向对象的第三大特征，多态建立在封装和继承的基础上。
7.1 多态的具体体现1）方法的多态(重写和重载)
①重载体现多态
main{
A a = new A();
a.sum(1, 2);
a.sum(1, 2, 3);
}
class A{
public void sum(int num1, int num2){}
public void sum(int num1, int num2, int num3){}//和上面的sum构成重载
}
②重写体现多态
mian{
A a = new A();
B b = new B();
a.say();
b.say();
}
class A{//父类
public void say();
}
class B extends A{//子类
public void say();//重写父类say()
}
2）对象的多态
①一个对象的编译类型和运行类型可以不一致
main{
Animal animal = new Dog();
}
class Animal{}
class Dog extends Animal{}
class Cat extends Animal{}
②编译类型在定义对象时，就确定了，不能改变。
③运行类型是可以变化的
animal = new Cat()
④编译类型看定义时 = 号的左边，运行类型看 = 的右边
Animal animal = new Dog(); 编译类型 运行类型7.2 注意事项和使用细节 7.2.1 多态的前提是：两个对象(类)存在继承关系 7.2.2 多态向上转型
本质：父类的引用指向子类对象
语法：父类类型 引用名 = new 子类类型();
特点：编译类型看左边，运行类型看右边。
可以调用父类中的所有成员(需遵循访问权限)
不能调用子类特有的方法
最终运行效果看子类的具体实现方式
main{
A a = new B();
a.say();//输出 B say()
a.eat();//输出 A eat()
a.play();//不可以调用该方法
}
class A{
public void say(){
System.out.println("A say()")
}
public void eat(){
System.out.println("A eat()")
}
}
class B extends A{
public void say(){
System.out.println("B say()")
}
public void play(){
System.out.println("B play()")
}
}
7.2.3 多态向下转型
①语法：子类类型 引用名 = (子类类型) 父类引用;
②只能强转父类的引用，不能强转父类的对象
A a = new B(); A a1 = new A(); B b = (B) a;//可以 B b = (B) a1;//不可以
③要求父类的引用类型必须指向的是目标类型的对象
A a = new B(); B b = (B) a;//可以 C c = (C) a;//不可以
④当向下转型后，可以调用子类型中的所有成员
A a = new B(); B b = (B) a; b.say();//输出 B say() b.eat();//输出 A eat() b.play();//输出 B play()
注意：属性没有重写之说，属性的值看编译类型
main{
A a = new B();
System.out.println(a.num);//10
B b = new B();
System.out.println(b.num);//20
}
class A{
int num = 10;
}
class B extends A{
int num = 20;
}
7.3 instanceOf
比较操作符，用于判断对象的运行类型是否为xxx类型或xx类型的子类
main{
AA a = new AA();
System.out.println(a instanceOf AA);//true
System.out.println(a instanceOf BB);//false
AA aa = new BB();
System.out.println(aa instanceOf AA);//true
System.out.println(aa instanceOf BB);//true
BB bb = new BB();
System.out.println(bb instanceOf AA);//true
System.out.println(bb instanceOf BB);//true
}
class AA{}
class BB extends AA{}
7.4 多态的应用
7.4.1 多态数组
main{
AA[] aas = new AA[3];
aas[0] = new AA();
aas[1] = new BB();
aas[2] = new CC();
}
class AA{}
class BB extends AA{}
class CC extends AA{}
7.4.2 多态参数
方法定义的形参类型为父类类型，实参类型允许为子类类型
public class Demo01{
public static void main(String[] args){
BB bb = new BB();
Demo01 demo = new Demo01();
demo.test(bb);
}
public void test(AA aa){}
}
class AA{}
class BB extends AA{}
8 Object类详解
8.1 equals 方法
8.1.1 equals 与 == 的对比
==是比较运算符：
① == ：既可以判断基本类型，又可以判断引用类型
② ==：如果判断基本类型，判断的是值是否相等
③ ==：如果判断引用类型，判断的是地址是否相等，即判断是不是同一个对象
④ equals：是Object类中的方法，只能判断引用类型
⑤ equals：默认判断地址是否相等，子类往往重写该方法，用于判断内容是否相等。
8.1.2 如何重写equals方法例：判断两个Person对象的内容是否相等，相等返回true，否则返回false
main{
Person p1 = new Person("tom", 20, "男");
Person p2 = new Person("tom", 20, "男");
p1.equals(p2);
}
class Person{
public void equals(Object obj){
if(this == obj){
return ture;
}
if(obj instanceOf Person){
return name.equals(obj.name) && age == obj.name && gender == obj.gender
}
return false;
}
}
8.2 hashCode
1）提高具有哈希结构的容器的效率
2）两个引用，如果指向同一个对象，则哈希值肯定是一样的
3）两个引用，如果指向两个对象，则哈希值是不一样的
4）哈希值主要根据地址号来的，但不能将哈希值等价于地址
9 断点调试（debug）1）断点调试是指在程序的某一行设置一个断点，调试时，程序运行到这一行时会停住
2）断点调试可以帮助查看Java底层源代码的执行过程，提高程序员水平
快捷键：
F7：跳入方法内
F8：逐行执行代码
Shift + F8：跳出方法
F9：执行到下一个断点
