一、类与对象
1 对象的特征--属性
1）每个对象具有的各种特征
2）每个对象的每个属性都拥有特定值
2 对象的特征--方法
1）对象执行的操作（例如：收银员
一、类与对象
1.对象的特征--属性
1）每个对象具有的各种特征
2）每个对象的每个属性都拥有特定值
2.对象的特征--方法
1）对象执行的操作（例如：收银员李明——收银、打印账单、刷卡，所做的动作就是方法）
2）对象：用来描述客观实物的一个实体，由一组属性和方法构成；说白了对象是事实存在的
3.类和对象
1）类：具有相同属性和方法的一组对象的集合，类是对象的抽象，对象是类的具体。
2）类是抽象的概念，仅仅是模板（比如“人”）；对象是一个你能够看得到、摸得着的具体实物。
4.类的规范
1）类名首字母要大写
2）定义类的步骤：（1）定义类名 （2）编写类的属性 （3）编写类的方法
5.使用对象的步骤
1）创建对象：类名 对象名=new 类名(); 举例：School center=new School();
2）引用对象成员：使用“.”进行一下操作
（1）引用类的属性：对象名.属性名举例：center.name="课工场";//给name属性赋值
（2）引用类的方法：对象名.方法名();举例：center.showCenter(); //调用showCenter()方法
6.类的方法
1）方法是个“黑匣子”，完成某个特定的应用程序功能，并返回结果
2）类的方法定义类的某种行为（或功能）
7.类方法的返回值
1）如果方法具有返回值，方法中必须使用关键字‘return’返回改制，返回值类型为该值的类型
2）返回值只能有一个
3）如果方法没有返回值，返回值类型为void
8.类方法的调用
1）方法之间允许互相调用，不需要知道方法的具体实现，实现重用，提高效率
（1）Student类的方法a()调用Student类的方法b()，直接调用
举例：public void a(){b();}//调用b()
（2）Student类的方法a()调用Teacher类的方法b()，先创建类对象，然后调用方法
举例：public void a(){Teacher t=new Teacher(); t.b();}//t.b()就是调用了Teacher类的b()
二、方法与方法重载
1.如何使用带参数的方法
1）定义带参数的方法
<访问修饰符> 返回类型 <方法名>(<形式参数列表>){//方法的主体}
2）调用带参数的方法
对象名.方法名(参数1，参数2，......，参数n) //()中为实参列表
3）常见错误
（1）调用方法时不能指定实参类型 不需要在声明变量类型
（2）形参和实参数据类型不一致！数量也要一致！
2.方法传参
1）基本数据类型和引用数据类型数据在传参时的区别
基本数据类型，操作传递的是变量的值，改变一个变量的值不会影响另一个变量的值。
引用数据类型（类、数组和接口），赋值是把原对象的引用（可理解为内存地址）传递给另一个引用
3.构造方法1
1）无参构造方法每个类都有个默认的无参构造方法
举例：Student s1=new Student();//new的是Student() ;无参构造方法
2）带参构造方法
举例：Student s1=new Student("张三",40);// new的是Student("张三",40) ;带参构造方法
4.构造方法2
<访问修饰符> <构造方法名> () {//1.无返回值类型 2.方法名与类名相同 3.可以指定参数
//初始化代码
}
作用：对象初始化 系统提供默认无参构造方法
5.构造方法重载
1）自定义构造方法//方法重载
方法名相同；参数项不同；与返回值、访问修饰符无关
2）以下举例不在提供默认无参构造方法
public Student(){}
public Student(String name,int age){
//带参构造方法this关键字是对一个对象的默认引用，这里用以区分同名成员变量
this.name=name;
this.age=age;
}
6.this的用法
this关键字的用法
1）调用属性：this.health=100; this.name="大黄";
2）调用方法：this.print();
3）调用构造方法：如果使用，必须是构造方法中的第一条语句
this();//调用无参构造方法
this("小黄",100,100,"雄");//调用带参构造方法
7.方法重载的规定
1）同一个类名中
2）方法名相同
3）参数个数或类型不同
4）与返回值、访问修饰符无关
8.成员变量和局部变量
1）变量声明的位置决定变量作用域
2）变量作用域确定可在程序中按变量名访问该变量的区域
3）区别
（1）作用域不同
局部变量：作用域仅限于定义它的方法中
成员变量：作用域在整个类的内部都是可见的
（2）初始值不同
Java会给成员变量一个初始值
Java不会给局部变量赋予初始值
注意：①在同一个方法中，不允许有同名局部变量；在不同的方法中，可以有同名局部变量
②在同一个类中，成员变量和局部变量同名时，局部变量具有更高的优先级
三、封装与继承
1.封装
1）封装的概念
将类的某些信息隐藏起来在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
2）封装的两个大致原则
（1）把尽可能多的东西藏起来，对外提供便捷的接口
（2）把所有的属性藏起来
3）实现封装
（1）修改属性的可见性 //设为private，防止错误修改
（2）创建公有的getter/setter方法 //用于属性的读写
（3）在getter/setter方法中加入属性控制语句 //对属性值的合法性进行判断
4）封装的好处
（1）便于使用者正确使用系统，防止错误修改属性
（2）有助于系统之间的松耦合，提高系统独立性
（3）提高软件的可重用性
（4）降低了构建大型系统的风险
3.包
1）包的作用
（1）允许类组成较小的单元（类似文件夹），易于找到和使用相应的文件
（2）防止命名冲突区分名字相同的类
（3）有助于实施访问权限控制
2）创建
//1.作为java源代码第一条语句 2.用package声明包，以分号结尾
package cn.jbit.inherit;//声明包
public class School{
......
}
3）包命名规范
（1）包名由小写字母组成，不能以远点开头或结尾
package mypackage;
（2）包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名
package cn.com.baidu;
（3）包名后续部分依不同机构内部的规范不同而不同
package cn.com.baidu.name; package cn.com.baidu.age;
注意：com:商业机构edu:教育机构gov:政府机关net:网络机构org:非盈利机构
使用组织倒置的网络域名：www.bdqn.cn 这个域网是唯一的；一般公司命名为：com.公司名 项目名.模块名
4）导入包
为了使用不在同一个包中的类，需要在Java程序中使用import关键字导入这个类
规范：import 包名.类名;
（1）系统包：java.util
（2）自定义包：cn.jtest.classandobject
import java.util.*;//导入java.util包中所有类
import cn.jtest.classandobject.School;//导入指定包中指定类
（1）*：指包中的所有类 School:指包中的School类
5）使用包的注意事项
（1）一个类同时引用了两个来自不同包的同类名，必须通过完整的类名来区分
（2）每个包都是独立的，顶层包不会包含子包的类
（3）package和import的顺序是固定的
package必须位于第一行（忽略注释行）
只允许有一个package语句
其次是import
接着是类的声明
4.类成员的访问修饰符
1）修饰符 public修饰符：公有访问级别默认修饰符：包级私有访问级别
2）常见修饰符
同一个类中同一个包中子类中任何地方
private可以不可以不可以不可以
默认修饰符可以可以不可以不可以
protected可以可以可以不可以
public可以可以可以可以
5.static修饰符
1）static可以用来修饰
成员变量：静态变量，可以直接通过类名访问
成员方法：静态方法，可以通过类名访问
代码块：静态代码块，当Java虚拟机加载类时，就会执行该代码块；1如果有多个静态块，按照顺序执行2每个静态代码块只会被执行一次
2）类成员变量包括
（1）类变量（静态变量）
被static修饰的变量
在内存中只有一个拷贝（一个内存地址）
类内部，可以在任何方法内直接访问静态变量
其他类中，可以直接通过类名访问
（2）实例变量
没有被static修饰的变量
每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响
3）static变量的作用
（1）能被类的所有实例共享，可以作为实例之间进行交流的共享数据
（2）如果类的所有实例都包含一个相同的常量属性，可把这个属性定义为静态常量，从而节省内存空间
4）static方法
（1）静态方法：可直接通过类名访问
静态方法中不能使用this和super
不能直接访问所属类的实例变量和实例方法
可直接访问类的静态变量和静态方法
（2）实例方法：通过实例访问
可直接访问所属类的静态变量、静态方法、实例变量和实例方法
（3）静态方法必须被实现（main()就是最常用的静态方法）
6.继承
概念：1方便修改代码；
2减少代码量；
3子类与父类是is-a关系（比如狗狗是一个宠物）
1）如何使用继承
（1）编写父类
<访问修饰符> class Pet{
//公共的属性和方法
}
（2）编写子类，继承父类
<> class Dog exrends Pet{
//子类特有的属性和方法
}
小结：继承是java中实现代码重写的重要手段之一。java中只支持“单根继承”，即一个类只能有一个直接父类
2）子类访问父类成员
（1）访问父类构造方法
super();
super(name);
（2）访问父类属性
super.name;
（3）访问父类方法
super.print();
小结：1使用super关键字，super代表父类对象；super关键字只能出现在子类的方法和构造方法中
2super在子类调用父类的构造方法，必须是第一句；
3super不可以访问父类中定义为private的属性和方法
3）继承条件下构造方法的调用规则
（1）子类构造方法没有通过super显示调用父类的有参构造方法，也没有通过this显示调用自身其他的构造方法，系统默认调用父类的无参构造方法
（2）子类构造方法通过super显示调用父类的有参构造方法，执行父类相应的构造方法，而不执行父类的无参构造方法
（3）子类构造方法通过this显示调用自身的其他构造方法，在相应的构造方法中应用以上两条规则
4）子类能继承父类的什么
（1）继承public和protected修饰的属性和方法，不管子类和父类是否在同一个包中
（2）继承默认权限修饰符修饰的属性和方法，但前提条件是子类和父类必须在同一个包中
5）子类不能继承父类的成员
（1）private成员
（2）子类与父类不在包中，不能继承默认访问权限的成员
（3）不能继承父类的构造方法，要是用，只能调用
6）继承适用于什么时候
（1）继承与真实世界类似
只要说“猫是一种哺乳动物”，猫的很多属性和行为就不言而明和所有的哺乳动物都相同
（2）继承是代码重用的一种方式
将子类公有的属性和行为方法放在父类中，让子类继承
四、方法重写与多态
1.方法重写
1）什么是方法重写（方法重写或方法覆盖）
（1）子类根据需求对 从父类继承的方法进行重新编写
（2）方法重写时，可以用 super.方法 的方式来保留父类的方法
（3）构造方法只能调用，不能重写
2）方法重写的规则
（1）方法名相同---重点
（2）参数列表相同---重点
（3）返回值类型相同或者是继承父类的某个子类---重点
（4）访问权限不能严于父类（大白话就是子类的修饰符不能比父类的权限更小）---重点
（5）父类的静态方法不能呗子类覆盖为非静态方法，父类的非静态方法不能被子类覆盖为静态方法
（6）子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法（注：静态方法中无法使用super）
（7）父类的私有方法不能被子类覆盖
（8）不能抛出比父类方法更多的异常
3）方法重写vs方法重载
比较项位置方法名参数表返回值访问修饰符
方法重写子类中相同相同相同或者是其子类不能比父类严格
方法重载同类中相同不相同无关无关
2.Object类是所有类的父类
1）Object类被子类经常重写的方法
方法说明
to String()返回当前对象本身的有关信息，按字符串对象返回
equals()比较两个对象是否是同一个对象，是则返回true
hashCode()返回该对象的哈希代码值
qetClass()获取当前对象所属的类的信息，返回Class对象
2）Object类中的equals()方法
比较两个对象是否是同一个对象，是则返回true
操作符：==
简单数据类型，直接比较值。如：1==2
引用类型，比较两者是否为同一对象
（1）Object类中的equals方法与==没区别
（2）当有特殊需求，如认为属性相同即为同一对象时，需要重写equals();
（3）Java.lang.String重写了equals()方法，把equals()方法的判断变为了判断其值
//PPT4 练习2：重写equals() 重写比较规则，判断2名学员（Student）是否为同一对象
public boolean equals(Object obj){//重写equals方法
if (this == obj){
return true;
}
if (obj instanceof Student){
Student stu = (Student)obj;
//如果两名学员的学号以及姓名相同，则为同一对象
if (this.No==((Student) obj).No && this.name==((Student) obj).name){
return true;
}
}
return false;
}
3.多态
1）什么是多态
同一种事物，由于条件不同，产生的结果也不同
多态：同一个引用类型，使用不同的实例而执行不同的操作
2）多态的使用
//Dog类
public class Dog extends Pet {
public void toHospital(){
this.setHealth(60);
System.out.println("打针、吃药");
}
}
//Penguin类
public class Penguin extends Pet {
public void toHospital() {
this.setHealth(70);
System.out.println("吃药、疗养");
}
}
//主人类
public class Master {
public void cure(Pet pet) {
if (pet.getHealth() < 50)
pet.toHospital();
}
}
//测试类
Pet pet = new Dog();//注意书写
Master master = new Master();
master.cure(pet);//父类引用，子类对象
……
主人类还可以给很多宠物看病：
又要给cat类看病，只需编写cat类继承Pet类，创建cat类对象，其它代码不变不用修改Master类
小结：方法重写是实现多态的基础
3）Pet类的toHospital()如何实现
（1）toHospital()不需要有具体的实现
（2）抽象方法
（3）Pet类声明为抽象类添加abstract关键词 public abstract class Pet{//抽象类};
（4）实例化Pet毫无意义
4）抽象方法
举例示意：public abstract void print();
（1）抽象方法没有方法体
（2）抽象方法必须在抽象类里
（3）抽象方法必须在子类中被实现，除非子类是抽象类
5）向上向下转型
向上转型：
<父类型> <引用变量名>=new <子类型>();
Pet pet=new Dog();//父类的引用指向子类对象，自动进行类型转换
pet.setHealth(20);
Master master=new Master();
master.cure(pet);
（1）此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法；
（2）此时通过父类引用变量无法调用子类特有的方法；
向下转型：
<子类类名> <引用变量名>=(强转<子类类名>)<父类型的引用变量>;
//将一个指向子类对象的父类引用赋给一个子类的引用，即：父类类型转换为子类类型。需要强转
Dog dog=(Dog)pet; //将pet转换为Dog类型 向下转型 (Dog)即为强转pet类型
dog.catchingFlyDisc();//执行Dog类独有的方法 接飞盘
（1）在向下转型的过程中，如果没有转换为真实的子类类型，会出现类型转换异常
6）instanceof应用
//代码展示
//主人类中的一个play方法
public void play(Pet pet){
if(pet instanceof Penguin){
Penguin penguin=(Penguin) pet;
penguin.swimming();
}else if(pet instanceof Dog){
Dog dog=(Dog) pet;
dog.catchFlyDis();
}else if(pet instanceof Cat){
Cat cat=(Cat) pet;
cat.zhuoMouse();
}
}
Java中提供了instanceof运算符来进行类型的判断，减少在向下转型的过程中，没有转换为真实子类类型的类型转换异常
注：使用instanceof时，对象的类型必须和instanceof后面的参数所指定的类在继承关系上有上下级关系
五、抽象类和接口
1.抽象类
1）抽象类VS普通类
（1）抽象类不能被实例化（没有任何意义）；但是可以创建一个引用变量，其类型是一个抽象类，指向非抽象的子类实例
（2）普通类可以被实例化
举例：public class Dog{}; Dog d1=new Dog(); 创建了一只Dog类的d1对象
2）抽象方法VS普通方法
（1）有无方法体；抽象方法没有方法体 普通方法有方法体
3）抽象类与抽象方法的使用
（1）抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类
（2）如果子类没有实现父类的所有抽象方法，子类必须被定义为抽象类
（3）没有抽象构造方法，也没有抽象静态方法
（4）抽象类中可以有非抽象的构造方法，创建子类的实例时可能调用
2.接口
1）JDK8之前特性和之后的新增特性
JDK8之前的接口特性
①接口中的变量都是静态常量（public static final），必须显示初始化
②接口中所有的方法默认都是public abstract
③接口没有构造方法，不可以被实例化，但可以被实现 常作为类型使用
④实现类必须实现接口的所有方法
⑤实现类可以实现多个接口（implements、多个接口使用逗号隔开） java中的多继承
JDK8新增的接口特性
（1）JDK1.8以后，接口里可以有默认方法（方法体）了
①default关键字，默认方法
②默认方法可以被继承，通过实例调用
③如果一个类实现了多个接口，多个接口都定义了多个同样的默认方法
方案1：子类重写覆盖父接口中的默认方法
方案2：子类可以使用super来调用指定接口的默认方法
④如果一个类继承了一个抽象类，实现了一个接口，抽象类和接口存在同样的方法
采取类优先的原则，优先继承抽象类的方法
⑤接口的默认方法可以有多个
（2）JDK1.8后，接口里可以声明（并且可以提供实现）静态方法
①接口中的静态方法必须是public的，public修饰符可以省略，static修饰符不能省略
②静态方法不能被继承及覆盖，所以只被集体所在的接口调用
③接口中静态方法可以有多个
（3）必须知道的接口特性
①接口不可以被实例化
②实现类必须实现接口的所有方法
③实现类可以实现多个接口（implements、多个接口使用逗号隔开）
④接口中的变量都是静态常量（public static final）
2）接口的使用
（1）接口中的成员变量 默认都是public static final的，必须显示初始化
（2）接口中的方法 默认都是public abstract的
（3）接口没有构造方法，不能被实例化
（4）一个接口不能实现另一个接口，单可以继承多个其他接口
（5）一个类必须实现接口抽象方法，除非这个类也是抽象类
3）抽象类VS接口
相同点：
①代表系统的抽象层
②都不能被实例化
③都能包含抽象方法 用于描述系统提供的服务，不比提供具体实现
不同点：
①在抽象类中可以为部分方法提供默认实现，而接口中只能包含抽象方法 抽象类便于复用，接口便于代码维护
②一个类只能继承一个直接的父类（单根继承原则），但可以实现多个接口
使用原则：
①接口做系统与外界交互的窗口 接口提供服务
②接口本身一旦制定，就不能随意修改
③抽象类可完成部分功能实现，还有部分功能可作为系统的扩展点
3.面向对象设计原则
①多用组合，少用继承
②针对接口编程
③针对扩展开放，针对改变关闭
4.接口总结
1）Java中的接口
①属性全都是全局静态变量
②方法都是全局抽象方法
③无构造方法
2）一个类可以实现多个接口，非抽象类实现接口时，必须实现接口中的全部方法
3）抽象类利于代码复用，接口利于代码维护
六、异常的捕获和处理
1）常见异常类型
异常类型说明
Exception异常层次结构的父类
ArithmeticException算术错误情形，如以零作除数---常见
ArrayIndexOutOfBoundsException数组下标越界---常见
NullPointerException尝试访问 null 对象成员---常见
ClassNotFoundException不能加载所需的类
IllegalArgumentException方法接收到非法参数
ClassCastException对象强制类型转换出错---常见
NumberFormatException数字格式转换异常，如把"abc"转换成数字
InputMismatchException输入格式错误（比如input.nextInt()用户输入一个字符）---常见
一、类与对象1.对象的特征--属性1）每个对象具有的各种特征2）每个对象的每个属性都拥有特定值2.对象的特征--方法1）对象执行的操作（例如：收银员李明——收银、打印账单、刷卡，所做的动作就是方法）2）对象：用来描述客观实物的一个实体，由一组属性和方法构成；说白了对象是事实存在的3.类和对象1）类：具有相同属性和方法的一组对象的集合，类是对象的抽象，对象是类的具体。2）类是抽象的概念，仅仅是模板（比如“人”）；对象是一个你能够看得到、摸得着的具体实物。4.类的规范1）类名首字母要大写2）定义类的步骤：（1）定义类名 （2）编写类的属性 （3）编写类的方法5.使用对象的步骤1）创建对象：类名 对象名=new 类名(); 举例：School center=new School();2）引用对象成员：使用“.”进行一下操作（1）引用类的属性：对象名.属性名举例：center.name="课工场";//给name属性赋值（2）引用类的方法：对象名.方法名();举例：center.showCenter(); //调用showCenter()方法6.类的方法1）方法是个“黑匣子”，完成某个特定的应用程序功能，并返回结果2）类的方法定义类的某种行为（或功能）7.类方法的返回值1）如果方法具有返回值，方法中必须使用关键字‘return’返回改制，返回值类型为该值的类型2）返回值只能有一个3）如果方法没有返回值，返回值类型为void8.类方法的调用1）方法之间允许互相调用，不需要知道方法的具体实现，实现重用，提高效率（1）Student类的方法a()调用Student类的方法b()，直接调用举例：public void a(){b();}//调用b()（2）Student类的方法a()调用Teacher类的方法b()，先创建类对象，然后调用方法举例：public void a(){Teacher t=new Teacher(); t.b();}//t.b()就是调用了Teacher类的b()二、方法与方法重载1.如何使用带参数的方法1）定义带参数的方法<访问修饰符> 返回类型 <方法名>(<形式参数列表>){//方法的主体}2）调用带参数的方法对象名.方法名(参数1，参数2，......，参数n) //()中为实参列表3）常见错误（1）调用方法时不能指定实参类型 不需要在声明变量类型（2）形参和实参数据类型不一致！数量也要一致！2.方法传参1）基本数据类型和引用数据类型数据在传参时的区别基本数据类型，操作传递的是变量的值，改变一个变量的值不会影响另一个变量的值。引用数据类型（类、数组和接口），赋值是把原对象的引用（可理解为内存地址）传递给另一个引用3.构造方法11）无参构造方法每个类都有个默认的无参构造方法举例：Student s1=new Student();//new的是Student() ;无参构造方法2）带参构造方法举例：Student s1=new Student("张三",40);// new的是Student("张三",40) ;带参构造方法4.构造方法2<访问修饰符> <构造方法名> () {//1.无返回值类型 2.方法名与类名相同 3.可以指定参数//初始化代码}作用：对象初始化 系统提供默认无参构造方法5.构造方法重载1）自定义构造方法//方法重载方法名相同；参数项不同；与返回值、访问修饰符无关2）以下举例不在提供默认无参构造方法public Student(){}public Student(String name,int age){//带参构造方法this关键字是对一个对象的默认引用，这里用以区分同名成员变量this.name=name;this.age=age;}6.this的用法this关键字的用法1）调用属性：this.health=100; this.name="大黄";2）调用方法：this.print();3）调用构造方法：如果使用，必须是构造方法中的第一条语句this();//调用无参构造方法 this("小黄",100,100,"雄");//调用带参构造方法7.方法重载的规定1）同一个类名中2）方法名相同3）参数个数或类型不同4）与返回值、访问修饰符无关8.成员变量和局部变量1）变量声明的位置决定变量作用域2）变量作用域确定可在程序中按变量名访问该变量的区域3）区别（1）作用域不同局部变量：作用域仅限于定义它的方法中成员变量：作用域在整个类的内部都是可见的（2）初始值不同Java会给成员变量一个初始值Java不会给局部变量赋予初始值注意：①在同一个方法中，不允许有同名局部变量；在不同的方法中，可以有同名局部变量②在同一个类中，成员变量和局部变量同名时，局部变量具有更高的优先级三、封装与继承1.封装1）封装的概念将类的某些信息隐藏起来在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问2）封装的两个大致原则（1）把尽可能多的东西藏起来，对外提供便捷的接口（2）把所有的属性藏起来3）实现封装（1）修改属性的可见性 //设为private，防止错误修改（2）创建公有的getter/setter方法 //用于属性的读写（3）在getter/setter方法中加入属性控制语句 //对属性值的合法性进行判断4）封装的好处（1）便于使用者正确使用系统，防止错误修改属性（2）有助于系统之间的松耦合，提高系统独立性（3）提高软件的可重用性（4）降低了构建大型系统的风险3.包1）包的作用（1）允许类组成较小的单元（类似文件夹），易于找到和使用相应的文件（2）防止命名冲突区分名字相同的类（3）有助于实施访问权限控制2）创建//1.作为java源代码第一条语句 2.用package声明包，以分号结尾package cn.jbit.inherit;//声明包public class School{......}3）包命名规范（1）包名由小写字母组成，不能以远点开头或结尾package mypackage;（2）包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名package cn.com.baidu;（3）包名后续部分依不同机构内部的规范不同而不同package cn.com.baidu.name; package cn.com.baidu.age;注意：com:商业机构edu:教育机构gov:政府机关net:网络机构org:非盈利机构使用组织倒置的网络域名：www.bdqn.cn 这个域网是唯一的；一般公司命名为：com.公司名 项目名.模块名4）导入包为了使用不在同一个包中的类，需要在Java程序中使用import关键字导入这个类规范：import 包名.类名;（1）系统包：java.util（2）自定义包：cn.jtest.classandobjectimport java.util.*;//导入java.util包中所有类import cn.jtest.classandobject.School;//导入指定包中指定类（1）*：指包中的所有类 School:指包中的School类5）使用包的注意事项（1）一个类同时引用了两个来自不同包的同类名，必须通过完整的类名来区分（2）每个包都是独立的，顶层包不会包含子包的类（3）package和import的顺序是固定的package必须位于第一行（忽略注释行）只允许有一个package语句其次是import接着是类的声明4.类成员的访问修饰符1）修饰符 public修饰符：公有访问级别默认修饰符：包级私有访问级别2）常见修饰符同一个类中同一个包中子类中任何地方private可以不可以不可以不可以默认修饰符可以可以不可以不可以protected可以可以可以不可以public可以可以可以可以5.static修饰符1）static可以用来修饰成员变量：静态变量，可以直接通过类名访问成员方法：静态方法，可以通过类名访问代码块：静态代码块，当Java虚拟机加载类时，就会执行该代码块；1如果有多个静态块，按照顺序执行2每个静态代码块只会被执行一次2）类成员变量包括（1）类变量（静态变量）被static修饰的变量在内存中只有一个拷贝（一个内存地址）类内部，可以在任何方法内直接访问静态变量其他类中，可以直接通过类名访问（2）实例变量没有被static修饰的变量每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响3）static变量的作用（1）能被类的所有实例共享，可以作为实例之间进行交流的共享数据（2）如果类的所有实例都包含一个相同的常量属性，可把这个属性定义为静态常量，从而节省内存空间4）static方法（1）静态方法：可直接通过类名访问静态方法中不能使用this和super不能直接访问所属类的实例变量和实例方法可直接访问类的静态变量和静态方法（2）实例方法：通过实例访问可直接访问所属类的静态变量、静态方法、实例变量和实例方法（3）静态方法必须被实现（main()就是最常用的静态方法）6.继承概念：1方便修改代码；2减少代码量；3子类与父类是is-a关系（比如狗狗是一个宠物）1）如何使用继承（1）编写父类<访问修饰符> class Pet{//公共的属性和方法}（2）编写子类，继承父类<> class Dog exrends Pet{//子类特有的属性和方法}小结：继承是java中实现代码重写的重要手段之一。java中只支持“单根继承”，即一个类只能有一个直接父类2）子类访问父类成员（1）访问父类构造方法super();super(name);（2）访问父类属性super.name;（3）访问父类方法super.print();小结：1使用super关键字，super代表父类对象；super关键字只能出现在子类的方法和构造方法中2super在子类调用父类的构造方法，必须是第一句；3super不可以访问父类中定义为private的属性和方法3）继承条件下构造方法的调用规则（1）子类构造方法没有通过super显示调用父类的有参构造方法，也没有通过this显示调用自身其他的构造方法，系统默认调用父类的无参构造方法（2）子类构造方法通过super显示调用父类的有参构造方法，执行父类相应的构造方法，而不执行父类的无参构造方法（3）子类构造方法通过this显示调用自身的其他构造方法，在相应的构造方法中应用以上两条规则4）子类能继承父类的什么（1）继承public和protected修饰的属性和方法，不管子类和父类是否在同一个包中（2）继承默认权限修饰符修饰的属性和方法，但前提条件是子类和父类必须在同一个包中5）子类不能继承父类的成员（1）private成员（2）子类与父类不在包中，不能继承默认访问权限的成员（3）不能继承父类的构造方法，要是用，只能调用6）继承适用于什么时候（1）继承与真实世界类似只要说“猫是一种哺乳动物”，猫的很多属性和行为就不言而明和所有的哺乳动物都相同（2）继承是代码重用的一种方式将子类公有的属性和行为方法放在父类中，让子类继承四、方法重写与多态1.方法重写1）什么是方法重写（方法重写或方法覆盖）（1）子类根据需求对 从父类继承的方法进行重新编写（2）方法重写时，可以用 super.方法 的方式来保留父类的方法（3）构造方法只能调用，不能重写2）方法重写的规则（1）方法名相同---重点（2）参数列表相同---重点（3）返回值类型相同或者是继承父类的某个子类---重点（4）访问权限不能严于父类（大白话就是子类的修饰符不能比父类的权限更小）---重点（5）父类的静态方法不能呗子类覆盖为非静态方法，父类的非静态方法不能被子类覆盖为静态方法（6）子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法（注：静态方法中无法使用super）（7）父类的私有方法不能被子类覆盖（8）不能抛出比父类方法更多的异常3）方法重写vs方法重载比较项位置方法名参数表返回值访问修饰符方法重写子类中相同相同相同或者是其子类不能比父类严格方法重载同类中相同不相同无关无关2.Object类是所有类的父类1）Object类被子类经常重写的方法方法说明to String()返回当前对象本身的有关信息，按字符串对象返回equals()比较两个对象是否是同一个对象，是则返回truehashCode()返回该对象的哈希代码值qetClass()获取当前对象所属的类的信息，返回Class对象2）Object类中的equals()方法比较两个对象是否是同一个对象，是则返回true操作符：==简单数据类型，直接比较值。如：1==2引用类型，比较两者是否为同一对象（1）Object类中的equals方法与==没区别（2）当有特殊需求，如认为属性相同即为同一对象时，需要重写equals();（3）Java.lang.String重写了equals()方法，把equals()方法的判断变为了判断其值//PPT4 练习2：重写equals() 重写比较规则，判断2名学员（Student）是否为同一对象public boolean equals(Object obj){//重写equals方法if (this == obj){return true;}if (obj instanceof Student){Student stu = (Student)obj;//如果两名学员的学号以及姓名相同，则为同一对象if (this.No==((Student) obj).No && this.name==((Student) obj).name){return true;}}return false;}3.多态1）什么是多态同一种事物，由于条件不同，产生的结果也不同多态：同一个引用类型，使用不同的实例而执行不同的操作2）多态的使用//Dog类public class Dog extends Pet {public void toHospital(){this.setHealth(60);System.out.println("打针、吃药");}}//Penguin类public class Penguin extends Pet {public void toHospital() {this.setHealth(70);System.out.println("吃药、疗养");}}//主人类public class Master {public void cure(Pet pet) {if (pet.getHealth() < 50)pet.toHospital(); }}//测试类Pet pet = new Dog();//注意书写Master master = new Master();master.cure(pet);//父类引用，子类对象……主人类还可以给很多宠物看病：又要给cat类看病，只需编写cat类继承Pet类，创建cat类对象，其它代码不变不用修改Master类小结：方法重写是实现多态的基础3）Pet类的toHospital()如何实现（1）toHospital()不需要有具体的实现（2）抽象方法（3）Pet类声明为抽象类添加abstract关键词 public abstract class Pet{//抽象类};（4）实例化Pet毫无意义4）抽象方法举例示意：public abstract void print();（1）抽象方法没有方法体（2）抽象方法必须在抽象类里（3）抽象方法必须在子类中被实现，除非子类是抽象类5）向上向下转型向上转型：<父类型> <引用变量名>=new <子类型>();Pet pet=new Dog();//父类的引用指向子类对象，自动进行类型转换pet.setHealth(20);Master master=new Master();master.cure(pet);（1）此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法；（2）此时通过父类引用变量无法调用子类特有的方法；向下转型：<子类类名> <引用变量名>=(强转<子类类名>)<父类型的引用变量>;//将一个指向子类对象的父类引用赋给一个子类的引用，即：父类类型转换为子类类型。需要强转Dog dog=(Dog)pet; //将pet转换为Dog类型 向下转型 (Dog)即为强转pet类型dog.catchingFlyDisc();//执行Dog类独有的方法 接飞盘（1）在向下转型的过程中，如果没有转换为真实的子类类型，会出现类型转换异常6）instanceof应用//代码展示//主人类中的一个play方法public void play(Pet pet){if(pet instanceof Penguin){Penguin penguin=(Penguin) pet;penguin.swimming();}else if(pet instanceof Dog){Dog dog=(Dog) pet;dog.catchFlyDis();}else if(pet instanceof Cat){Cat cat=(Cat) pet;cat.zhuoMouse();}}Java中提供了instanceof运算符来进行类型的判断，减少在向下转型的过程中，没有转换为真实子类类型的类型转换异常注：使用instanceof时，对象的类型必须和instanceof后面的参数所指定的类在继承关系上有上下级关系五、抽象类和接口1.抽象类1）抽象类VS普通类（1）抽象类不能被实例化（没有任何意义）；但是可以创建一个引用变量，其类型是一个抽象类，指向非抽象的子类实例（2）普通类可以被实例化举例：public class Dog{}; Dog d1=new Dog(); 创建了一只Dog类的d1对象2）抽象方法VS普通方法（1）有无方法体；抽象方法没有方法体 普通方法有方法体3）抽象类与抽象方法的使用（1）抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类（2）如果子类没有实现父类的所有抽象方法，子类必须被定义为抽象类（3）没有抽象构造方法，也没有抽象静态方法（4）抽象类中可以有非抽象的构造方法，创建子类的实例时可能调用2.接口1）JDK8之前特性和之后的新增特性JDK8之前的接口特性①接口中的变量都是静态常量（public static final），必须显示初始化②接口中所有的方法默认都是public abstract③接口没有构造方法，不可以被实例化，但可以被实现 常作为类型使用④实现类必须实现接口的所有方法⑤实现类可以实现多个接口（implements、多个接口使用逗号隔开） java中的多继承JDK8新增的接口特性（1）JDK1.8以后，接口里可以有默认方法（方法体）了 ①default关键字，默认方法 ②默认方法可以被继承，通过实例调用③如果一个类实现了多个接口，多个接口都定义了多个同样的默认方法方案1：子类重写覆盖父接口中的默认方法方案2：子类可以使用super来调用指定接口的默认方法④如果一个类继承了一个抽象类，实现了一个接口，抽象类和接口存在同样的方法采取类优先的原则，优先继承抽象类的方法⑤接口的默认方法可以有多个（2）JDK1.8后，接口里可以声明（并且可以提供实现）静态方法①接口中的静态方法必须是public的，public修饰符可以省略，static修饰符不能省略②静态方法不能被继承及覆盖，所以只被集体所在的接口调用③接口中静态方法可以有多个（3）必须知道的接口特性①接口不可以被实例化②实现类必须实现接口的所有方法③实现类可以实现多个接口（implements、多个接口使用逗号隔开）④接口中的变量都是静态常量（public static final）2）接口的使用（1）接口中的成员变量 默认都是public static final的，必须显示初始化（2）接口中的方法 默认都是public abstract的（3）接口没有构造方法，不能被实例化（4）一个接口不能实现另一个接口，单可以继承多个其他接口（5）一个类必须实现接口抽象方法，除非这个类也是抽象类3）抽象类VS接口相同点：①代表系统的抽象层②都不能被实例化③都能包含抽象方法 用于描述系统提供的服务，不比提供具体实现不同点：①在抽象类中可以为部分方法提供默认实现，而接口中只能包含抽象方法 抽象类便于复用，接口便于代码维护②一个类只能继承一个直接的父类（单根继承原则），但可以实现多个接口使用原则：①接口做系统与外界交互的窗口 接口提供服务②接口本身一旦制定，就不能随意修改③抽象类可完成部分功能实现，还有部分功能可作为系统的扩展点3.面向对象设计原则①多用组合，少用继承②针对接口编程③针对扩展开放，针对改变关闭4.接口总结1）Java中的接口①属性全都是全局静态变量②方法都是全局抽象方法③无构造方法2）一个类可以实现多个接口，非抽象类实现接口时，必须实现接口中的全部方法3）抽象类利于代码复用，接口利于代码维护六、异常的捕获和处理1）常见异常类型异常类型说明Exception异常层次结构的父类ArithmeticException算术错误情形，如以零作除数---常见ArrayIndexOutOfBoundsException数组下标越界---常见NullPointerException尝试访问 null 对象成员---常见ClassNotFoundException不能加载所需的类IllegalArgumentException方法接收到非法参数ClassCastException对象强制类型转换出错---常见NumberFormatException数字格式转换异常，如把"abc"转换成数字InputMismatchException输入格式错误（比如input.nextInt()用户输入一个字符）---常见
