JavaSE | 接口| 枚举| 注释| 异常
包
1、包的作用：
（1）避免类的同名（区分类）；类的全名称：包.类名
例如：java.util.Scanner、 java.util.Arrays、 java.lang.String
（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; } }
接口
* 1、声明一个接口 * 【修饰符】 interface 接口名{ } //类似于类的声明(class)
可以用来修饰interface的有public, static也对； private和protected都不对；接口的内部成员都是public
* 2、接口的成员 * JDK1.8之前： * （1）全局静态的常量 public static final 如 int MAX_SPEED = 20000; * （2）公共的抽象的方法 public abstract 如:void run(); * JDK1.8之后：增加了两个成员 * （1）默认方法 * （2）静态方法 * * 3、如何使用接口？ * （1）全局静态的常量：通过接口名直接调用 * （2）抽象方法，由实现类（就是子类）来实现它；；；“子类“要实现接口重写接口的方法，不一定要继承父类。 * * 【修饰符】 class 实现类名 implements 接口们{ * //如果这个类不是抽象类，那么必须实现接口的所有的抽象方法 * } * * 接口可以比喻成“干爹”，可以有好几个 * 继承可以比喻成“亲爹”，只能有一个，所以单继承 * * 4、接口的特点 * （1）接口也是不能直接创建对象 * （2）一个类可以同时实现多个接口 * （3）一个类可以同时继承它的父类，又实现接口，要求必须继承在前，实现在后 * 【修饰符】 class 实现类名 extends 父类 implements 接口们{ * //如果这个类不是抽象类，那么必须实现接口的所有的抽象方法 * } * （4）接口和父类有点像，所以接口的变量与实现类对象可以构成多态引用 * （5）一个实现类实现接口时，必须实现接口的所有的抽象方法，否则这个实现类也得是抽象类 * （6）接口可以继承接口，并且可以继承多个接口。 * 【修饰符】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() + "]"; } }
@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(); }
单元测试
* 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("嘿哈"); }
异常
* 所谓异常：程序大多数情况下是可以正常，正确的运行，但是有的时候因为一些不可控的因素，导致程序运行异常，中断。
* 例如：复制文件时，因为目标盘空间不足； 聊天功能时，因为网络中断；* 计算两个数的商，用户输入的除数为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, StackOverflowError * 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); //1 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); //2 }
* 结论：
* (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 TestStackOverflowError { public static void main(String[] args) { test(); } public static void test(){ test(); } } java.lang.StackOverflowError
错误异常从最下看
最后一个Caused by :xxx，然后再从下往上
