instanceof判断对象是否是某各类所创建
例子：返回boolean类型
myobject instanceof ExampleClass
myobject：某各类的对象引用
ExampleClass：某个类
JAVA中的关键字都为小写
注意：虽然在方法重载中可以是两个方法的返回值不同，但只有返回值不同并不足以区分两个方法的重载，还需要通过参数的个数以及参数的类型来设置。
不定长参数方法的重载
例子：public int add(int...a){
int s=0;
for(int i=0;i<a.length;i++){
s+=a[i];
}
return s;
//由于它的参数是不定长的，可以满足根据参数个数区分重载的条件
}
抽象类与接口
抽象类：只要类中有一个抽象方法，此类就是抽象类
在接口中定义的任何字段都是static和final的
接口：
public interface drawTest{
void draw();
}//接口中定义的方法必须定义为public或abstract形式public:权限修饰符
interface：定义接口关键字
drawTest：接口名称
接口也可以实现向上转型，就是每一个实现接口的类的对象都是用接口创建的数组的成员，这个成员可以调用接口的方法。
接口可以继承另一个接口
封装
将类的属性定义为私有属性，然后用get,set方法对其属性进行限制，以达到规范的目的。
内部类
内部类的实例一定要绑定在外部类的实例上，如果从外部类中初始化一个内部类对象，那么内部类对象就会绑定在外部类上。
注意：如果在外部类和静态方法之外实例化对象，需要使用外部类 ，内部类的形式制定该对象的类型。
public class OuterClass {
innerClass in = new innerClass(); // 在外部类实例化内部类对象引用
public void ouf() {
in.inf(); // 在外部类方法中调用内部类方法
}
class innerClass {
innerClass() { // 内部类构造方法
}
public void inf() { // 内部类成员方法
}
int y = 0; // 定义内部类成员变量
}
public innerClass doit() { // 外部类方法，返回值为内部类引用
// y=4; //外部类不可以直接访问内部类成员变量
in.y = 4;
return new innerClass(); // 返回内部类引用
}
public static void main(String args[]) {
OuterClass out = new OuterClass();
// 内部类的对象实例化操作必须在外部类或外部类中的非静态方法中实现
OuterClass.innerClass in = out.doit();
OuterClass.innerClass in2 = out.new innerClass();
}
}异常
捕获异常
在处理异常时可用：
- getMessage()函数：输出错误性质。
- toString()函数：给出异常的类型与性质。
- printStackTrace()函数：输出异常的类型、性质、栈层次以及出现异常的位置。
finally不会执行的情况
- 在finally语句块中发生了异常。
- 在前面的代码中使用了System.exit()退出程序。
- 程序所在线程死亡。
try{
//程序代码块
}catch(Exception e){
e.printStackTrace();
}finally{
//始终要执行的程序
}常见异常
| 异常类 | 说明 |
|---|---|
| ClassCastException | 类型转换异常 |
| ClassNotFoundException | 未找到相应的类 |
| ArithmeticException | 算数异常 |
| ArrayIndexOutOfBoundsException | 数组下标越界异常 |
| ArrayStoreException | 数组中包含不兼容的值抛出的异常 |
| SQLException | 操作数据库异常类 |
| NullPointerException | 空指针异常 |
| NoSuchFieldException | 字段未找到异常 |
| NoSuchMethodException | 方法未找到抛出的异常 |
| NumberFormatException | 字符串转换为数字抛出异常 |
| NegativeArraySizeException | 数组元素个数为负数抛出的异常 |
| StringIndexOutOfBoundssException | 字符串索引超出范围抛出的异常 |
| IOException | 输入输出异常 |
| IllegalAccessException | 不允许访问某类的异常 |
| InstantiationException | 当应用程序试图使用Class类中的newInstance()方法创建一个类的实例，而指定的类对象无法实例化时，抛出该异常 |
| EOFException | 文件已结束异常 |
| FileNotFoundException | 文件未找到异常 |
自定义异常
创建步骤：
1. 创建自定义异常类
2. 在方法中通过throw关键字抛出异常对象（方法中用throw）
3. 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句块捕获并处理，否则在方法的声明出通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
4. 在出现异常的方法的调用者中捕获并处理异常。
异常的使用原则：
1.在当前方法声明中使用try-catch语句捕获异常
2.一个方法被覆盖时，覆盖他的方法必须抛出相同的异常或异常的子类
3.如果父类抛出多个异常，则覆盖方法必须抛出那些异常的一个子集
枚举类型（修饰符都是static和final）
也可以在类的内部定义，相当于内部类，示例：
public class ConstansTest{
enum Constans2{
Contants_A,
Contants_B,
}
//这样编译时会产生其他的.class文件| 方法名称 | 具体含义 | 使用方法 | 举例 |
|---|---|---|---|
| values() | 该方法可以将枚举类型成员以数组的形式返回 | 枚举类型名称.values() | Constans2.values() |
| valuesOf() | 该方法可以实现将普通字符串转换为枚举实例 | 枚举类型名称.valuesOf(“abc”) | Constans2.valuesOf(“abc”) |
| compareTo() | 该方法用于比较两个枚举类型在定义时的顺序 | 枚举对象.compareTo() | Contants_A.compareTo(Contants_B) |
| ordinal() | 得到索引位置 |
1.示例
"通过放在接口中的常量和枚举中的常量，突出枚举的优点"
interface Constants { // 将常量放置在接口中
public static final int Constants_A = 1;
public static final int Constants_B = 12;
}
public class ConstantsTest {
enum Constants2 { // 将常量放置在枚举类型中
Constants_A, Constants_B
}
// 使用接口定义常量
public static void doit(int c) { // 定义一个方法，这里的参数为int型
switch (c) { // 根据常量的值做不同操作
case Constants.Constants_A:
System.out.println("doit() Constants_A");
break;
case Constants.Constants_B:
System.out.println("doit() Constants_B");
break;
}
}
// 定义一个方法，这里的参数为枚举类型对象
"定义只能传入什么类型的值，防止2其他值的传入，从而保证参数传递安全"
public static void doit2(Constants2 c) {
switch (c) { // 根据枚举类型对象做不同操作
case Constants_A:
System.out.println("doit2() Constants_A");
break;
case Constants_B:
System.out.println("doit2() Constants_B");
break;
}
}
public static void main(String[] args) {
ConstantsTest.doit(Constants.Constants_A); // 使用接口中定义的常量
ConstantsTest.doit2(Constants2.Constants_A); // 使用枚举类型中的常量
ConstantsTest.doit2(Constants2.Constants_B); // 使用枚举类型中的常量
ConstantsTest.doit(3);
// ConstantsTest.doit2(3);
}
}
2.values（）
public class ShowEnum {
enum Constants2 { // 将常量放置在枚举类型中
Constants_A, Constants_B
}
// 循环由values()方法返回的数组
public static void main(String[] args) {
for (int i = 0; i < Constants2.values().length; i++) {
// 将枚举成员变量打印
out.println("枚举类型成员变量：" + Constants2.values()[i]);
}
}
}
3.value()与compareTo()
public class EnumMethodTest {
enum Constants2 { // 将常量放置在枚举类型中
Constants_A, Constants_B
}
// 定义比较枚举类型方法，参数类型为枚举类型
public static void compare(Constants2 c) {
// 根据values()方法返回的数组做循环操作
for (int i = 0; i < Constants2.values().length; i++) {
// 将比较结果返回
out.println(c + "与" + Constants2.values()[i] + "的比较结果为："
+ c.compareTo(Constants2.values()[i]));
}
}
// 在主方法中调用compare()方法
public static void main(String[] args) {
compare(Constants2.valueOf("Constants_B"));
}
}
4.ordinal()
"********枚举对象*********"
public class EnumIndexTest {
enum Constants2 { // 将常量放置在枚举类型中
Constants_A, Constants_B, Constants_C
}
public static void main(String[] args) {
for (int i = 0; i < Constants2.values().length; i++) {
// 在循环中获取枚举类型成员的索引位置,
out.println(Constants2.values()[i] + "在枚举类型中位置索引值"
+ Constants2.values()[i].ordinal());
}
}
}在枚举类型中定义构造方法的实例
public class EnumIndexTest {
enum Constants2 { // 将常量放置在枚举类型中
Constants_A("我是枚举成员A"), // 定义带参数的枚举类型成员
Constants_B("我是枚举成员B"), Constants_C("我是枚举成员C"), Constants_D(3);
private String description;
private int i = 4;
"******自定义构造方法*******"
private Constants2() {
}
// 定义参数为String型的构造方法
private Constants2(String description) {
this.description = description;
}
private Constants2(int i) { // 定义参数为整型的构造方法
this.i = this.i + i;
}
public String getDescription() { // 获取description的值
return description;
}
public int getI() { // 获取i的值
return i;
}
}
public static void main(String[] args) {
for (int i = 0; i < Constants2.values().length; i++) {
out.println(Constants2.values()[i] + "调用getDescription()方法为："
+ Constants2.values()[i].getDescription());
}
out.println(Constants2.valueOf("Constants_D") + "调用getI()方法为："
+ Constants2.valueOf("Constants_D").getI());//实现接口的方法
}
}
创建接口，使枚举类实现接口，然后使枚举类型实现接口中的方法。
import static java.lang.System.*;
interface d {
public String getDescription();
public int getI();
}
public enum AnyEnum implements d {
Constants_A { // 可以在枚举类型成员内部设置方法
public String getDescription() {
return ("我是枚举成员A");
}
public int getI() {
return i;
}
},
Constants_B {
public String getDescription() {
return ("我是枚举成员B");
}
public int getI() {
return i;
}
},
Constants_C {
public String getDescription() {
return ("我是枚举成员C");
}
public int getI() {
return i;
}
},
Constants_D {
public String getDescription() {
return ("我是枚举成员D");
}
public int getI() {
return i;
}
};
private static int i = 5;
public static void main(String[] args) {
for (int i = 0; i < AnyEnum.values().length; i++) {
out.println(AnyEnum.values()[i] + "调用getDescription()方法为："
+ AnyEnum.values()[i].getDescription());
out.println(AnyEnum.values()[i] + "调用getI()方法为："
+ AnyEnum.values()[i].getI());
}
}
}枚举类型的优点
- 类型安全
- 紧凑有效的数据定义
- 可以和其他部分完美的结合
- 运行效率高
扫一扫
304
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
