包：
1、包的作用：
（1）避免类的同名（区分类）；类的全名称：包.类名
回忆：java.util.Scanner
java.util.Arrays
java.lang.String
j
（2）可以限定某些类或成员的可见范围；（权限）
如果某个类或成员省略了权限修饰符，它的可见范围是本包
（3）用于组织管理项目中众多的类
2、包的声明的格式：package 包名;
声明的要求：
（1）这句package语句必须在“源文件”代码的首行
（2）包名：A:所有单词都小写，每一个单词之间使用.分割； B:一般习惯上用公司的域名倒置加模块名 com.atguigu.xxx;
3、
编译：javac 源文件名.java； ----->>> 编译：javac -d . 源文件名.java
运行：java 类名 ----->>> 运行：java 包.类名
-d：directory文件夹，目录； .：表示当前目录
4、如何使用其他的包？ 前提：被使用的类必须是可见的
（1）使用类的全名称
（2）使用import语句先导包，然后使用类的简名称； import 包.类名;
特殊情况：要使用的两个类同名，包名不一样；那就一个导包用简名称，一个使用全名称
* 导包：
* (1)import 包.类名;
* (2)import 包.*;
* (3)import static 包.类名.静态成员;
* (4)import static 包.类名.*;
*
* (3)(4)就是静态导入，JDK1.5之后引入
*
* JDK1.5增加的：
* （1）foreach
* （2）枚举
* （3）注解
* （4）可变参数
* （5）静态导入
* JDK1.8增加的：
* （1）接口的默认方法和静态方法
final关键字
* 关键字:final，最终的
* 它也是一个修饰符
*
* 1、它可以修饰什么？
* final可以修饰：类（包括外部类和内部类）、变量（包括局部变量、实例变量和类变量）、方法（静态方法和非静态方法）； final不能用于修饰构造方法
*
* 2、它修饰后有什么不同？
* （1）修饰类，即class前面出现了final
* 表示这个类是最终类，即这个类不能被继承了，没有子类，它是太监类，没有子孙后代
* 例如：String类
*
* （2）修饰方法，即返回值类型前面出现final
* 表示这个方法是最终实现版本，即这个方法不能被重写
*
* （3）修饰变量，即在变量数据类型前面出现final； 被final修饰的变量只能在变量定义时初始化。
* 表示这个变量的值不能被修改，它是常量，一般要求常量名大写，每个单词之间使用_，常量必须赋值
*
* 例如：Math.PI
native关键字
* 关键字：native
* 它也是修饰符
*
* 1、native可以修饰什么？
* 可以修饰方法
*
* 2、native修饰的方法是什么意思？
* 表示这个方法是一个“原生”的方法，即它的方法体的实现不是用Java语言实现的，是有C/C++等语言实现的，
* 实现后编译为.dll文件，然后由Java代码调用。
*
* 对应调用者，使用者来说，可以把它当成Java实现的方法一样使用。
* 而且子类可以选择用Java代码重写native方法
*/
public class TestNative {
public static void main(String[] args) {
Object obj = new Object();
int hashCode = obj.hashCode();
System.out.println(hashCode);
}
}
class Student{
private int id;
private String name;
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + id;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (id != other.id)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
接口
* 、声明一个接口
* 【修饰符】 interface 接口名{
} //类似于类的声明(class)
可以用来修饰interface的有public, static也对； private和protected都不对；接口的内部成员都是public
* 、接口的成员
* JDK1.8之前：
* （）全局静态的常量 public static final 如 int MAX_SPEED = 20000;
* （）公共的抽象的方法 public abstract 如:void run();
* JDK1.8之后：增加了两个成员
* （）默认方法
* （）静态方法
*
* 、如何使用接口？
* （）全局静态的常量：通过接口名直接调用
* （）抽象方法，由实现类（就是子类）来实现它；；；“子类“要实现接口重写接口的方法，不一定要继承父类。
*
* 【修饰符】 class 实现类名 implements 接口们{
* //如果这个类不是抽象类，那么必须实现接口的所有的抽象方法
* }
*
* 接口可以比喻成“干爹”，可以有好几个
* 继承可以比喻成“亲爹”，只能有一个，所以单继承
*
* 、接口的特点
* （）接口也是不能直接创建对象
* （）一个类可以同时实现多个接口
* （）一个类可以同时继承它的父类，又实现接口，要求必须继承在前，实现在后
* 【修饰符】 class 实现类名 extends 父类 implements 接口们{
* //如果这个类不是抽象类，那么必须实现接口的所有的抽象方法
* }
* （）接口和父类有点像，所以接口的变量与实现类对象可以构成多态引用
* （）一个实现类实现接口时，必须实现接口的所有的抽象方法，否则这个实现类也得是抽象类
* （）接口可以继承接口，并且可以继承多个接口。
* 【修饰符】interface 接口名 extends 接口们{
* }
*
* 关系：
* 类与类之间：继承，单继承 extends
* 类与接口之间：类实现接口，可以多实现 implements
* 接口与接口之间：继承，多继承 extends
*
for(int i = 1; i < arr.length; i++){
for(int j = 0; j < arr.length - i; j++){
/*
* 假设传入的是Student[]数组，里面都是学生对象
* 如何表示前面的学生对象arr[j]比arr[j+1]大
*/
//需要调用arr[j]的compare方法,怎么才能调用compary方法呢,
//参数为Object类型向下转型为Student类型,它重写了compary方法
//通过arr[j].compare(arr[j+1])>0，就可以确定arr[j]比较arr[j+1]大
Sortable left = (Sortable) arr[j];//这一步很关键啊
if(left.compare(arr[j + 1]) > 0){ //if(arr[j] > arr[j+1]){
//交换两个元素，temp和元素的类型一样就可以
Object temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
* JDK1.8之后，接口增加了两个成员：
* 1、静态方法
* 和类中的静态方法的格式一样。
* 调用时：通过“接口名."调用即可
*
* 原来的核心类库中，有Collection接口和Collections工具类（全部是静态方法），
* Path接口和Paths工具类（全部是静态方法）
* 后面的工具类是为前面的接口服务的。
* 原来为了为某个接口提供工具类，还要增加一个类，现在就不同了，直接在接口中声明静态方法即可。
* 而且这些静态的实现和接口的实现类是什么类型无关。
*
* 2、默认方法
* 语法格式：
* 【修饰符】 interface 接口{
* 【修饰符】 default 返回值类型 方法名([形参列表]){
* 方法体
* }
* }
*
* 如何调用？
* 必须通过接口的"实现类对象."才能调用
*
* 某一个接口的某个抽象方法，可能它的多数实现类对该方法的实现是一样的，那么就没必要每一个实现类都写一遍。
* 把这样的方法实现，提取到接口中声明为默认方法，如果其他不一样的实现类，可以选择“重写”。
*/
public class TestInterface {
public static void main(String[] args) {
MyInter.test(); //接口中的静态方法直接 接口名.静态方法;
MyImp myimp = new MyImp();
myimp.fun();//通过接口的实现类对象来调用 接口的default默认方法;
myimp.method();//通过接口的实现类对象来调用 接口的default默认方法;
}
}
interface MyInter{
public static void test(){
System.out.println("接口中的静态方法直接接口名.来调用哦");
}
public default void fun(){
System.out.println("接口中的默认方法fun通过接口的实现类创建对象来调用");
}
public default void method(){
System.out.println("接口中默认方法method通过接口的实现类创建对象来调用");
}
}
class MyImp implements MyInter{
/*@Override //接口中的方法不是抽象方法,可以不用重写;
public void fun() {
// TODO Auto-generated method stub
MyInter.super.fun();
}
*/
}
/*
* 默认方法的冲突问题：
* 1、当某个类实现了多个接口，多个接口的默认方法的方法签名是一样的
* 必须重写，但是在重写的时候可以选择（1）保留其中一个（2）选择完全重写
*
* 2、当某个类继承了父类，又实现了接口，但是父类中有一个方法和接口中的默认方法的方法签名是一样的
* 默认选择保留“父类”，即子类创建对象默认调用的是父类中的方法，如果子类重写了父类的方法就按照子类重写的方法；
当然也可以重写接口中的方法，就会调用接口中的方法，如 InterD.super.test( ) ;
当然也可以选择重写（1）选择父接口的（2）完全重写
*/
public class TestDefaultMethod {
public static void main(String[] args) {
Sub s = new Sub();
s.test();
Son son = new Son();
son.test(); //如果子类没有重写,就默认调用父类的
}
}
interface InterA{
public default void test(){
System.out.println("我是接口A的默认方法test");
}
}
interface InterB{
public default void test(){
System.out.println("我是接口B的默认方法test");
}
}
class Father{
}
class Sub extends Father implements InterA, InterB{
@Override
public void test() {
// TODO Auto-generated method stub
InterA.super.test();//保留A接口的默认实现
InterB.super.test();//保留A接口的默认实现,也可以实现两个都保留;也可以进行重写;
System.out.println("我重写，两个都不要了");
}
}
interface InterD{
public default void test(){
System.out.println("我是接口D中的默认方法test");
}
}
class Fu{
public void test(){
System.out.println("我是父类Fu中的方法test");
}
}
class Son extends Fu implements InterD{
public void test(){
InterD.super.test(); //重写接口D中的方法; 子类重写父类的方法了,就不会调用父类的方法了调它自己的
System.out.println("我是子类Son中的方法test,重写了父类的了");
}
}
用实现类代替接口
public class TestInterface {
public static void main(String[] args) {
//AA aa = new BB(); //需要一个接口，给个实现类即可
AA aa = new CC(); //多态的传递
// AA aa = new BB(); BB bb = new CC(); 构建CC，等同于构建他的父类,父类可以代替接口实现；能代替不代表实现了接口,class CC extends BB implements AA这样子就实现了接口
//System.out.println(aa);
System.out.println(CC.class.getInterfaces().length); //CC并没有实现接口AA
}
}
interface AA{
}
class BB implements AA{
}
class CC extends BB{
}
简单工厂模式
* 简单工厂模式（了解）：
* （1）当创建某个对象比较麻烦
* （2）想要与被创建的对象的类型解耦合
*
* 工厂模式的目的：对象的创建者与对象的使用者角色分离
*
* 代码的结构：
* （1）接口
* （2）有接口的很多实现类
* （3）有一个工厂类，专门new接口的各种实现类的对象
* （4）使用接口的实现类对象的地方，通过工厂类之间获取对象，而不直接new实现类对象
*
* 耦合：依赖，关联
*/
public class TestFactory {
public static void main(String[] args) {
String str = new String(); //TestFactory与String类发生耦合，依赖
//对象的使用者TestFactory
//想要获取宝马车的对象; new出BMW对象,接口类型Car b
Car c = new BMW();//与BMW发生耦合，对象的使用者和创建者都是TestFactory
c.run();
//对象的使用者TestFactory不负责BMW和Aodi对象的创建，与BMW和Aodi类解耦合
Car b = Factory.getCar("宝马");
b.run();
Car a = Factory.getCar("奥迪");
a.run();
}
}
class Father{
}
class Son extends Father{
}
interface Car{
void run();
}
class BMW implements Car{
@Override
public void run() {
System.out.println("宝马来了。。。");
}
}
class AoDi implements Car{
@Override
public void run() {
System.out.println("奥迪来了。。。");
}
}
class Factory{
//工厂只负责创建对象;创建一个getCar方法来生产Car的对象
public static Car getCar(String type){
if("宝马".equals(type)){
return new BMW();
}else if("奥迪".equals(type)){
return new AoDi();
}
return null;
}
}
代理模式
* 代理：代购、中介
* 把麻烦，多变交给代理，核心的不易变化的还是自己来做。
*
* 静态代理和动态代理。
*
* 代理模式：（了解）
* 1、接口：主题接口
* 2、被代理者
* 3、代理者
* （1）被代理者和代理者都要实现主题接口。
* （2）要指定代理者为谁代理，即代理者中必须持有被代理者对象的引用
*
* 静态代理：
public class TestProxy {
public static void main(String[] args) {
DaiGou d = new DaiGou(new Customer()); //用有参构造器,创建DaiGou的对象d,并给他赋值初始化
d.buy(); //构造器中的形参Subject target, 把实参new出Customer对象传给它;最后由d对象来调用方法
}
}
interface Subject{
void buy(); //抽象方法省略了public abstract
}
//被代理者 --Customer类实现了Subject接口;
class Customer implements Subject{
@Override
public void buy() {
// 最核心的自己写
System.out.println("一手交钱一首交货");
}
}
class DaiGou implements Subject{
private Subject target; //类DaiGou的属性,接口类型的引用数据类型targer; 被代理者对象的引用
public DaiGou(Subject target) {
super();
this.target = target; //在构造器中给属性targer初始化
}
@Override
public void buy() {
System.out.println("筛选商品");
target.buy(); //一手交钱一首交货
System.out.println("反馈下");
}
}
枚举
* 枚举：也是一个种类型，也是一个类
* 1、什么是枚举？
* 中文：枚举 的近义词 列举，穷举，罗列
* Java中，枚举，罗列出该类型的所有对象
*
* 2、什么情况会用枚举？
* 当某个类型它的对象是有限的几个，这个时候就可以使用枚举。
* 3、如何声明枚举类
* JDK1.5之前
* JDK1.5之后
public class TestEnum {
public static void main(String[] args) {
// Season s = new Season();//构造器不可见
//如何获取春天对象
Season spring = Season.SPRING; 类型 类名 = 类型.静态对象
System.out.println(spring);
Season summer = Season.SUMMER;
System.out.println(summer);
}
}
//JDK1.5之前
/*
* （1）限定使用者创建对象； 2）把有限的几个对象，提前创建好，并存起来，大家共享
* 存对象：肯定用变量才能存； 共享：类变量，静态变量； 随处可用：public
*/
class Season{
//（2）把有限的几个对象，提前创建好，并存起来，大家共享
public static final Season SPRING = new Season();
public static final Season SUMMER = new Season();
public static final Season FALL = new Season();
public static final Season WINTER = new Season();
//（1）限定使用者创建对象，把构造器私有化
private Season(){
}
//可以定义其他的成员
public String toString(){
if(this == SPRING){
return "春眠不觉晓，处处闻啼鸟。";
}else if(this == SUMMER){
return "小荷才露尖尖角，早有蜻蜓立上头";
}else if(this == FALL){
return "停车坐爱枫林晚，霜叶红于二月花。";
}else{
return "千山鸟飞绝，万径人踪灭。";
}
}
}
* JDK1.5之后：
* 1、枚举类的声明格式
* 【修饰符】 enum 枚举类名{
* 枚举类的常量对象列表 【;
* 其他成员列表
* 】
* }
*
* 说明：
* （1）如果枚举常量对象列表后面要写其他成员，那么需要在常量对象列表后面加;分隔，如果没有其他成员，那么;可写可不写
* （2）构造器一定是私有化的
* （3）枚举类型的默认父类不是Object，而是java.lang.Enum类，当然Enum也是Object的子类
* 枚举类型不能再继承别的类型
*
* java.lang.Enum类：
* (1)构造器
* protected Enum(String name,int ordinal)
* name是为Enum类中的name属性赋值，自动赋值为常量对象的名称
* ordinal是Enum类中的ordinal属性赋值，自动赋值为常量对象的“序号”，这个序号是从0开始
*
* 他们的get方法没有按照普通类的get方法的命名，而是直接用属性名作为get方法的名称：name(),ordinal()
*
* 因为父类Enum只有唯一的一个有参构造，意味着我们自己写的枚举类的构造器和普通类（默认调用父类的无参构造）不一样，
* 默认调用的是父类的有参构造。
*
* (2)Enum实现了java.lang.Comparable接口
* 所有的枚举类型都支持比较大小，因为Enum实现了java.lang.Comparable接口，按照常量对象的顺序比较大小。
* 父类中把这个int compareTo()加了final，子类不能重写
*
* (3)两个API中没有的方法
* static 枚举类型[] values()：用来返回枚举类型的所有常量对象
* static 枚举类型 valueOf(字符串类型的常量对象名) -->> 枚举类名.valueof（“ ”）
Week sunday = Week.SUNDAY;
System.out.println(sunday); //对象sunday打印的是 toString的内容;
System.out.println(sunday.name());
System.out.println(sunday.ordinal()); System.out.println("----------------"); Week[] values = Week.values();
for (Week week : values) {
System.out.println(week);
} Week w = Week.valueOf("MONDAY");
System.out.println(w);
System.out.println(Week.valueOf("SUNDAY")); --->> 星期天 //（SUNDAY("星期天"); ）
public enum Status {
BUSY("忙得热火朝天，无法再安排其他任务"), //创建的对象时候用的是有参构造;
FREE(), //用的是无参,默认null
VOCATION(),
LEFT("离职了");
private String desc;
private Status() {
}
private Status(String desc) {
this.desc = desc;
}
Status busy = Status.BUSY;
Employee[] emp = new Employee[5];
emp[0] = new Employee("kris", 10000, Status.BUSY);//busy
for (Employee employee : emp) {
System.out.println(employee.toString());//employee <==> employee.toString();
}
注释
注解(annotation)：它又称为注释，它本质上也是注释，只不过它是代码级别的注释，即它用代码注释代码。
* 因为说注释容易让人误解为单行和多行的普通注释，很多人就故意叫做“注解”
* 注解是JDK1.5之后引入。
*
* 普通的注释：用文字去注释代码
* （1）单行注释
* （2）多行注释
*
* 文档注释：用代码和文字一起去注释代码。
*
* 注解长什么样？ @注解
* 一个完整的注解，它应该有三部分组成：
* （1）定义，声明
* 可能是程序员自己声明的，也可能是别人声明好的；* 开发中，绝大多数都是用别人声明好的。
* （2）注解的使用
* 你看到在类上面、方法上面、属性上面....用到了@注解，就是在使用注解
* （3）读取注解
* 得有代码去读取这个注解，理解代码的用意，信息...
* 读取注解需要用代码去读取，这个代码我们称为“注解处理流程”，大多数情况下，这个代码也是别人写好的，
* 一般都是谁定义，谁复制编写读取注解的代码。
*
* 注解在后面的框架中使用最多，它的作用是用来替代xml的配置文件，对代码进行解释。
* 因为xml的配置方式，一个是复杂，另一个与所解释的代码是独立的，所以有的地方不用xml，用注解
常见的注解
* 常见的注解：
*
* 一、系统定义的最基本的三个注解（必须都认识，会写，会用）
* 1、@Override：
* 这个注解的声明是在JDK的核心类库中声明的，
* 这个注解的读取是编译器来读取的，编译器：javac.exe，eclipse中有自己编译器
* 这个注解的使用由程序员来使用，用在所有的重写的方法的上面，表示让编译器，按照重写的要求对该方法进行格式检查和编译。
*
* 重写的要求：
* （1）方法名和形参列表必须相同
* （2）返回值类型
* 如果是基本数据类型和void，必须相同
* 如果是引用数据类型，必须<= 子类重写的方法的返回值类型<=父类被重写的方法的返回值类型
* （3）权限修饰符：必须>= 子类重写的方法的权限修饰符的可见范围>=父类被重写的方法的权限修饰符的可见范围
* （4）抛出的异常列表类型范围：?
* （5）其他修饰符：被重写的方法不能是static,private,final
*
* 2、@SuppressWarings(xx)
* 这个注解的声明是在JDK的核心类库中声明的，
* 这个注解的读取是编译器来读取的，编译器：javac.exe，eclipse中有自己编译器
* 这个注解的使用由程序员来使用，用在任意需要抑制警告的地方
*
* @SuppressWarnings("all")
* @SuppressWarnings({ "rawtypes", "unused" })
*
* 3、@Deprecated
* 这个注解的声明是在JDK的核心类库中声明的，
* 这个注解的读取是编译器来读取的，编译器：javac.exe，eclipse中有自己编译器
* 这个注解的使用由程序员来使用，用在任意需要标记为“已过时”的元素上面，可能是方法，可能是类，
* “已过时”的东西，不建议程序继续使用的，如果使用可能有问题
*
* 删除的行为一定要谨慎。
*
* 编译器如果遇到了程序员使用了已标记为“已过时”的元素时，它会弹出警告
文档注解，文档注释
二、文档注解，文档注释
* 文档注解的声明，也有JDK核心类库声明过了； * 读取：javadoc.exe来读取
* @author：表示作者
* @version：表示版本
* @since：起始版本
* @see：另请参考
* @param：形参
* @return：返回值
* @throws：抛出的异常列表
*
* @param、@return、@throws只能在方法上使用
* @param 形参名 形参的数据类型 形参的解释
* @return 返回值类型 说明
* @throws 异常类型 说明
import javax.management.RuntimeErrorException; /**
* @author Administrator
* @version 1.8
* @since 1.0
* @see java.lang.Object
* @see java.lang.Math
*/ public class TestAnnotation { public static void main(String[] args) {
/**java程序主入口
* @param args String[] 命令行参数
*/
@SuppressWarnings(value = { "unused" })
int a = 10;
} public static int getMax(int a, int b){
/**
* 从两个整数中找出最大值
* @param a int
* @param b int
* @return int 返回最大值
*/ return a > b ? a :b;
} public static int divide(int a, int b) throws RuntimeErrorException{ /**
* 这是一个求两个整数的商
* @param int a
* @param int b
* @return int
* @throws RuntimeException,当b为0时抛出异常
*/ if(b == 0){
throw new RuntimeException("除数不能为0");
}
return a/b;
} @Deprecated
public void print(){
System.out.println("过时的方法啊");
} @Override
public String toString() {
return "TestAnnotation [toString()=" + super.toString() + "]";
} }
单元测试
* JUnit框架不是JRE核心类库，需要单独引入它的jar，类库； eclipse等IDE（集成开发工具）都直接集成了JUnit框架
*
* 三、单元测试
* 声明和定义：JUnit框架中定义的* 读取：由java + JUnit框架读取
*
* 如何运行？
* 如果没有选择，那么当前源文件中的所有的单元测试都会运行
* 如果选中某个方法，只运行某一个；
*
* @Test： 要先引入import org.junit.Test;
*加在需要单独测试的方法。*
* @Before 导入 import org.junit.Before; 与之类似的 --->>> @After 是在@Test方法后边最后才执行。
* 加在需要在单元测试方法前面运行的方法上; 如public void test(){ }; *执行的特点：每一个@Test方法前面都会执行这个方法，再执行@Before；
*
* @BeforeClass @BeforeClass
* 加在需要在类初始化时执行的方法上。 如public static void test(){ }; 最先执行，首行位置；*
* @AfterClass 类似上边@BeforeClass的用法
* 加在需要在类所有的测试方法之后执行的方法上
*
这四个都有要求：方法所在的类必须是public
* 方法本身必须是public，而且是无参无返回值的，静态的
@Test
public void test(){
System.out.println("Hello");
}
@Before
public void test1(){
System.out.println("hi");
}
@After
public void test2(){
System.out.println("Test之后");
}
@BeforeClass
public static void test3(){
System.out.println("嘿嘿");
}
@AfterClass
public static void test4(){
System.out.println("嘿哈");
}
自定义注释
* 枚举看成是类
* 注解看成是接口
*
* 注解：
* （1）声明
* （2）使用
* （3）读取
*
* 一、自定义注解
* 1、语法格式：
* 【修饰符】 @interface 注解名{
* }
*
* 2、加元注解说明一下
* 元注解：注解注解的注解，给注解加的注解。它们在java.lang.annotation包下
* （1）@Target
* @Target(ElementType.xx)
* @Target({ElementType.xx,ElementType.xx,...})
* ElementType是一个枚举类型，有很多常量对象：例如：TYPE,METHOD（方法）,FIELD（属性）,CONSTRUCTOR....
* TYPE（包含 Class, interface (including annotation type), or enum declaration ）
* @Target作用：限制自定义的注解的使用的目标位置
*
* （2）@Retention
* @Retention(RetentionPolicy.SOURCE)：源代码阶段 该注解只能被编译器读取
* @Retention(RetentionPolicy.CLASS)：字节码阶段 该注解只能被编译器和类加载器读取
* @Retention(RetentionPolicy.RUNTIME)：运行时阶段 该注解可以在运行时仍然被读取
*
* SOURCE < CLASS < RUNTIME
*
* @Retention的作用：限制自定义注解的寿命，可以“滞留”到什么阶段
* RetentionPolicy也是枚举类型，常量对象只有三个：SOURCE,CLASS,RUNTIME
*
* （3）@Documented
* 标记某个注解是否可以被javadoc读取到API中。
*
* （4）@Inherited
* 标记某个注解是否可以被子类继承
*
*/
package com.atguigu.annotation; import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target; public class TestDefineAnnotation { public static void main(String[] args) { //读取MyClass类上面的注解,用到了反射
Class clazz = MyClass.class;
MyAnnotation my = (MyAnnotation) clazz.getAnnotation(MyAnnotation.class);
System.out.println(my); Class clazz2 = MySub.class;
MyAnnotation my2 = (MyAnnotation) clazz2.getAnnotation(MyAnnotation.class);
System.out.println(my2); } } //@YoursAnnotation
class MyClass{
//@YoursAnnotation //不能在属性上使用,因为它规定了只能使用在METHOD即方法上
@MyAnnotation
private String filed; @MyAnnotation
@YoursAnnotation
public void test(){ } } class MySub extends MyClass{ } @Inherited //标记这个注解可以被子类继承;
@Retention(RetentionPolicy.RUNTIME) //可以在运行时阶段读取;
@interface MyAnnotation{ //自定义一个注解; }
@Documented
@Target(ElementType.METHOD) //限制自定义注解使用的目标位置
@Retention(RetentionPolicy.SOURCE) //只能被编译器读取;
@interface YoursAnnotation{ }
* 自定义注解
*
* 1、语法格式：
* @元注解
* 【修饰符】 @interface 注解名{
* }
*
*
* @元注解
* 【修饰符】 @interface 注解名{
* 配置参数
* }
*
* 没有配置参数的注解：
* （1）@Override
* （2）@Deprecated
* （3）@Documented
* （4）@Inherited
* （5）@Test
*
* 有配置参数的
* （1）@SuppressWarnings(xx)
* （2）@Target(xx)
* （3）@Retention(xx)
* （4）@WebServlet(xx)
*
* 1、配置参数的声明
* (1)声明格式：
* 数据类型 参数名();
* (2)配置参数在声明时，可以有默认值
* 数据类型 参数名() default 默认值; 如 String info() default "atguigu";
* (3)数据类型
* 注解的配置参数的数据类型的要求：8种基本数据类型，4种引用数据类型（String，Class，枚举，注解）
* 可以是它们的数组类型，例如：int[],String[]，枚举类型[]等
*
* 2、如果有配置参数，在使用时
*(1) @注解名(参数名1 = 参数值1,参数名2 = 参数值2，。。。。)
*(2)如果这个注解只有一个配置参数，并且它的名字叫做value，那么可以省略value=
*
*换句话说，声明配置参数时，参数名首先考虑value
*
* 3、读取配置参数值时， 变量 = 注解对象.参数名()
*
*
* 回忆:default
* (1)switch
* (2)接口
* (3)注解配置参数的默认值
*
* 数据类型：
* （1）数据类型有哪些:
* （2）变量的数据类型: 都可以
* （3）属性的数据类型什么要求: 都可以
* （4）形参的数据类型什么要求: 都可以
* （5）返回值类型的类型有什么要求: 都可以
* （6）switch(表达式)中表达式的类型要求：4种基本数据类型，2种引用数据类
* （7）注解的配置参数的数据类型的要求：8种基本数据类型，4种引用数据类型（String，Class，枚举，注解）
* 可以是它们的数组类型，例如：int[],String[]，枚举类型[]等
*/
public class TestAnnotation2 {
public static void main(String[] args) {
@SuppressWarnings("rawtypes")
Class clazz = TestA.class;
AnnotationA my = (AnnotationA) clazz.getAnnotation(AnnotationA.class);
System.out.println(my);
String str = my.info(); //对象.方法 来进行调用;
System.out.println(str);
}
}
@AnnotationA(info = "atguigu", age = 22, value = 88.9) //赋值时像属性,变量
class TestA{ //只有一个参数时可以省略value =
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface AnnotationA{
String info() default "尚硅谷"; //可以有默认值
int age(); //配置参数的声明;
char gender() default '男';
double value();
}
异常
* 所谓异常：程序大多数情况下是可以正常，正确的运行，但是有的时候因为一些不可控的因素，导致程序运行异常，中断。
* 例如：复制文件时，因为目标盘空间不足； 聊天功能时，因为网络中断；* 计算两个数的商，用户输入的除数为0
1）语法错误； 2）逻辑错误 --->> 它们不是异常。。。
异常的作用：使得系统可以通过捕获异常对象，然后处理异常，使得程序继续运行，否则，如果一旦异常，程序就会挂了。使得程序更健壮。
* Java中是如何处理异常？（原理）
* 当某句代码发生异常时，程序会在这句代码处“停”下来（下面的代码是无法执行的），
然后JVM（大多数是JVM，有的时候也可能是程序中自己new）会创建一个“合适类型的异常的对象”，并且“抛”出来；
JVM会在该句代码的“外围”搜索是否有"try..catch"可以“捕获”这个异常，如果可以“捕获”那么程序从"try..catch"下面继续运行，
如果没有找对应的"try..catch"，或者先有的"try..catch"无法“捕获”，
那么程序会把这个异常对象“抛”给“上级”，如果上级可以“捕获”，那么就从“上级”的"try..catch"下面继续运行，
否则接着往上抛，一直到main，如果main也“捕获”不了，就挂了。
异常的类型
* 异常的类型：
* java.lang.Throwable：Throwable 类是 Java 语言中所有错误或异常的超类。
* （1）只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。
* （2）只有此类或其子类之一才可以是 catch 子句中的参数类型。
*
* “抛”：JVM抛，throw抛
* “抓，捕获”：catch
*
* 两个子类的实例，Error 和 Exception，通常用于指示发生了异常情况。
* 通常，这些实例是在异常情况的上下文中新近创建的，因此包含了相关的信息（比如堆栈跟踪数据）。
*
* 分为：
* Error：错误，严重的异常，用于指示合理的应用程序不应该试图捕获(catch)的严重问题。
* 例如：VirtualMachineError的两个子类： OutOfMemoryError, *Error
* Exception：异常
* 非受检异常/运行时异常：RuntimeException及其它的子类
* 受检异常/编译时异常：除了运行时异常，剩下的都是编译时异常
*
* 编译器在检查程序时，遇到你throw或throws出RuntimeException，编译器不会强制要求你编写try..catch或继续throws处理；
* 编译器在检查程序时，遇到你throw或throws出非运行时异常，那么编译器会强制要求你编写try...catch或继续throws否则编译不通过。
*
Throwable是所有错误和异常的父类，超类。
Exception是所有异常的父类，它分为RuntimeException和非RuntimeException。
try..catch..finally形式有三种：1) try..catch； 2) try...catch..finally； 3) try..finally
try...catch
* try...catch
* 1、语法格式：
* try{
*
* 可能发生异常的语句块;
*
* }catch(异常类型1 异常名){
* 处理该异常的代码;
* }catch(异常类型2 异常名){ //catch -->> catch --> 一定是有先后顺序的，从子类---->>>父类，高级的
* 处理该异常的代码;
* }catch(异常类型3 异常名){
* 处理该异常的代码;
* }
* ....
*
* try..catch的执行过程：
* （1）如果try中的代码没有异常，那么try中的代码执行完，正常执行try..catch下面的代码
* （2）如果try中的代码发生异常，首先，try中发生异常那句代码 后面的代码是无法执行，其次，在try中抛出一个
* 异常对象，catch会按从上到下，依次尝试“捕获”，如果有一个“捕获”了，下面的catch就不看。
* 所有要求子异常类型写上面，父异常类型写下面。
* （3）如果try中的代码发生异常，并且所有的catch都没有“捕获”，那么try..catch下面的代码就无法执行了，
* 会把异常对象抛出“上级——调用者”，如果已经是最上级（main），就挂了。
*
* 这个特点有的像：
* if...else if....
*
*
*
* 提示：把字符串类型的数字转成int的值
* Integer.parseInt(字符串)
try...catch...finally
* try...catch...finally
* 2、语法格式：
* try{
*
* 可能发生异常的语句块;
*
* }catch(异常类型1 异常名){
* 处理该异常的代码;
* }catch(异常类型2 异常名){
* 处理该异常的代码;
* }catch(异常类型3 异常名){
* 处理该异常的代码;
* }finally{
* 无论try中是否发生异常，也不管catch是否能够捕获异常，finally中一定要执行。
* }
*
* finally块中一般编写：释放资源，断开连接等代码。
*
*
* 面试题：final,finally,finalize的区别？
* final是修饰符，修饰类，表示不能被继承，修饰方法，表示不能被重写，修饰变量，表示值不能被修改是常量。
* finally：是try..catch..finally的一部分，无论try中是否发生异常，也不管catch是否能够捕获异常，finally中一定要执行
* finalize：是一个方法名，在Object类中，表示当对象被“垃圾回收器GC”回收之前调用，有它在就不回收了，只有第一次有效，第二次无效会被gc回收。 * 形式：
* try..catch
* try..finally
* try..catch...finally
public static void main(String[] args) {
int num3 = test();
System.out.println("num3 = " + num3); //1
}
public static int test(){
int result = 0;
try {
result = 1/1;
System.out.println("result = " +result); //
return result;//(1)先把1，load到“方法的返回值存放区”（3）再结束当前方法，返回“方法的返回值存放区”的值
} catch (Exception e) {
return result;
}finally{
result++;//（2）result变量自增，变成2，这个2就不会放到“方法的返回值存放区” //如果变成return result++; 结果还是1 ；如果是return 3; 它就变成3了
System.out.println("result = " + result); //
}
* 结论：
* (1)finally中的部分无论如何都要执行
* (2)如果finally中有return，以finally中的return语句为主
* (3)如果finally中无return，以try或catch中的return语句为主
*/
考到try...catch...finally和return一起的时候：
(1)finally中代码，无论如何一定要执行，不管是否发生异常，也不管是否catch住异常；
(2)如果finally中没有return语句，那么就先执行finally，然后再回去执行try或catch中的return语句，第二个作用“结束当前方法”，返回值不受finally影响；
(3)如果finally中有return语句，那么就执行finally中的return语句，相当于try和catch中return语句“失效”。
throws
throws：显式声明当前方法中，没有处理的异常，由调用者来处理，特别是编译时异常
如果方法中有产生编译时异常，而又未处理，那么必须加throws声明，否则编译不通过
如果方法中有产生运行时异常，而又未处理，那么可以加throws也可以不加，因为编译期间检测不到运行时异常，编译可以通过。
* throws：
* 1、用于在声明方法时，显式的声明当前方法中没有处理的异常，要调用者来处理。
* 调用者在使用有throws的方法时，用try...catch就知道该catch什么更具体异常，否则就按Exception
用上throws（你得知道要抛出的是什么异常如ArithmeticException），写在方法名的后边，你再try...catch.. 选择try里边的代码右键选择Sound with 选择try，
它就知道要抛什么异常了，不然它只会抛Exception异常。
*
* 2、语法格式：
* 【修饰符】 返回值类型 方法名(【形参列表】)throws 异常列表{
* }
*
* 异常列表可以写好几个，用,分割
*
* 3、关于方法重写
* （1）方法名和形参列表必须相同
* （2）返回值类型
* 基本数据类型和void：必须一致
* 引用数据类型：<= 子类重写方法的返回值类型<=父类被重写方法的返回值类型
* （3）权限修饰符：>= 子类重写方法的权限修饰符的可见性范围 >= 父类被重写方法的权限修饰符的可见性范围
* （4）其他修饰符： 哪些不能重写 static,final,private
* （5）抛出的异常列表的类型：<= 子类重写方法抛出的异常类型 <= 父类被重写方法抛出的异常类型
*/
public class TestThrows {
public static void main(String[] args) {
try {
divide(1, 0);
} catch (ArithmeticException e1) {
e1.printStackTrace();
}
try {
copy("1.txt", "2.txt");
} catch (FileNotFoundException e) {
e.printStackTrace();
}
Father f = new Son();//多态引用
try {
f.test(); //编译时按照父类Father,运行时按子类Son,子类抛出RuntimeException异常,Exception要能够捕获到
} catch (Exception e) { //反过来按照子类抛出的Exception，这个时候发现catch就捕获不了
e.printStackTrace();
}
}
public static int divide(int a, int b) throws ArithmeticException{
return a/b;
}
public static void copy(String srcFilePath, String destFilePath) throws FileNotFoundException{
FileInputStream fis = new FileInputStream(srcFilePath);
FileOutputStream fos = new FileOutputStream(destFilePath);
}
}
class Father{
public void test()throws Exception{
}
}
class Son extends Father{
public void test() throws RuntimeException{ //子类的抛出的异常类型要比父类的小
//要保证子类抛出的异常父类能够接住
}
}
throw用于手动抛出异常对象
* 大多数异常对象是JVM根据情况抛出。有的时候需要手动抛出异常，
* throw：用于手动抛出异常对象
* 语法结构：
throw 异常对象;
可以代替return语句，即带回异常信息，而且可以结束方法的执行
public class TestThrow {
public static void main(String[] args) {
Account account = new Account();
try {
account.withdraw(100);
System.out.println("取款成功");
} catch (Exception e) {
System.out.println(e.getMessage()); // 打印的是条件不满足时抛出的异常,给用户看的
//e.printStackTrace(); //直接打印出红色异常信息,给开发者看的;
}
System.out.println("余额为:" + account.getBalance());
}
}
class Account{
private double balance = 1000;
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public void withdraw(double amount){
if(amount < 0){
//Illegal不合法，Argument参数
IllegalArgumentException e = new IllegalArgumentException("取款金额输入有误");
throw e;
}if(amount > balance){
throw new RuntimeException("余额不足");
}
balance -= amount;
}
}
自定义异常：
* (1)要继承Throwable或它子类
* 一般都继承Exception（编译时异常）,或者RuntimeException（运行时异常）
* (2) 异常名要见名知意
* (3)尽量保留父类的两个构造器：一个是无参构造，一个是为message赋值的构造器
* (4)自定义异常必须手动用throw来抛出，JVM无法给你自动抛出
*
* 一个异常：
* （1）类型要见名知意
* 例如：ArrayIndexOutOfBoundsException
* ClassCastException
* FileNotFoundException
*
* （2）自己的message消息
* 异常对象名.getMessage()可以获取
（3）堆栈跟踪信息
* 异常对象经历的抛出路线，从哪个方法到哪个方法
* 异常对象名.printStackTrace(); //Trace痕迹
* System.err：异常信息，默认是红色的
* System.out：普通信息
* System.err和System.out是两个线程，谁先抢到谁先打印
public class TestMyException {
public static void main(String[] args) {
try {
regist("admin", 22, "123@qq.com");
System.out.println("注册成功");
} catch (UsernameExistException e) {
e.printStackTrace();
System.out.println(e.getMessage());
}
}
public static void regist(String username, int age, String email) throws UsernameExistException{
//做一个假的注册，假设我的数据库已经存"admin"
if("admin".equals(username)){
throw new UsernameExistException("用户名已存在");
}
}
}
class UsernameExistException extends Exception{
public UsernameExistException(){
super();
}
public UsernameExistException(String message){
super(message);
}
}
异常类型
//下标越界
public class TestArrayIndexOutOfBoundsException {
public static void main(String[] args) {
int[] arr = new int[0]; try {
System.out.println(arr[0]);
} catch (Exception e) {
e.printStackTrace();//标准的异常信息的打印方法，信息比较全，（1）类型（2）message（3）堆栈跟踪信息
//或
System.out.println(e.getMessage());//只有message
}
}
}
运行时异常
异常栈e.printStank
NullPointerException：空指针异常，当对象是null，却用对象调用方法，属性等。
ArrayIndexOutOfBoundsExceptiom：数组下标越界异常，当下标的值超过[0,数组的长度-]的范围
ClassCastException：类型转换异常，当对象不是该类型的实例时
NumberFormatException：数字格式化异常，当把一个非数字的字符串转为数字
ArithmeticException：算术异常，例如当除一个0时 Java可能导致内存泄露的错误代码或者用简单代码演示内存溢出
public class TestOutOfMemoryError {
public static void main(String[] args) {
Object[] arr = new Object[Integer.MAX_VALUE];
System.out.println("Integer.MAX_VALUE =" + Integer.MAX_VALUE);
}
}
java.lang.OutOfMemoryError: Requested array size exceeds VM limit
----------------------------------------------------------------------------------
public class Test*Error {
public static void main(String[] args) {
test();
}
public static void test(){
test();
}
}
java.lang.*Error
错误异常从最下看
最后一个Caused by :xxx，然后再从下往上