学习的总结

内部类

内部类就是在一个类的内部在定义一个类 ，比如，A类中定义一个B类，那么B类就相当于A类来说就称为内部类，而A类相对于B来说就是外部类了

1. 成员内部类

2. 静态内部类

3. 局部内部类

4. 匿名内部类

   一个java类中可以有多个class类，但是只能有一个public class

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
​
        //通过这个外部类来实例化内部类
​
        Outer.Inner inner = outer.new Inner();
        inner.in();
​
    }
}
​
/*
public class Outer {
​
    private int id = 10;
​
​
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
​
        //获得外部类的私有属性~
        public void getID(){
            System.out.println(id);
        }
    }
}
​
 */

异常机制

异常指程序运行中出现的不期而至的各种状况，如：文件找不到、网络连接失败、非法参数等。

异常发生在程序运行期间，它影响了正常的程序执行流程。

Exception：异常

Error：错误

异常处理机制

抛出异常

捕获异常

 

异常处理五个关键字

try、catch、finally、throw、throws

public class Demo01 {
    public static void main(String[] args) {
        int a = 1;
​
        int b = 0;
        try {//try 监控区域
            System.out.println(a/b);
        }catch (ArithmeticException e){//catch(想要捕获的异常类型)
            System.out.println("程序出现异常，变量b不能为0");
        }finally {//处理善后工作
            System.out.println("finally ");
        }
​
​
        //finally   可以不要finally， IO流，资源，关闭
    }
​
}

快捷键 Ctrl + Alt + T 选中测试行代码 选try的

public class Text {
​
    public static void main(String[] args) {
        try {
            new Text().text(1,0);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }
    }
    //假设这个方法中，处理不了这个异常，在方法上抛出异常
    public void text(int a, int b) throws ArithmeticException{
        if (b == 0) {
            throw new ArithmeticException();//主动抛出异常,一般在方法中使用
        }
        System.out.println(a/b);
    }
​
}

JAVA中常用的类

java中的共同父类：Object类

Object 是 java 类库中的一个特殊类，也是所有类的父类。也就是说，Java 允许把任何类型的对象赋给 Object 类型的变量。当一个类被定义后，如果没有指定继承的父类，那么默认父类就是 Object 类。

测试hashCode()方法

public class Test{
    public static void main(String[] args) {
        Test test1 = new Test();
        Test test2 = new Test();
        System.out.println(+test1.hashCode());
        System.out.println(+test2.hashCode());
}

解释：test1 和test2所引用的Text类型对象虽然内容相同，但其hashCode码却不同，且保存在不同的空间中

toString()方法

toString() 方法返回该对象的字符串，当程序输出一个对象或者把某个对象和字符串进行连接运算时，系统会自动调用该对象的 toString() 方法返回该对象的字符串表示。

public class Demo1{
}
public class ObjectDemo01 {
    public static void main(String[] args) {
        Demo d = new Demo(); // 实例化Demo对象
        System.out.println("不加toString()输出：" + d);
        System.out.println("加上toString()输出：" + d.toString());
    }
}

public class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String toString() {
        return "姓名：" + this.name + "：年龄" + this.age;
    }
    public static void main(String[] args) {
        Person per = new Person("123", 30);// 实例化Person对象
        System.out.println("对象信息：" + per);// 打印对象调用toString()方法
    }
}

加和不加 toString() 的最终输出结果是一样的，也就是说对象输出时一定会调用 Object 类中的 toString() 方法打印内容。

equals() 方法

在前面学习字符串比较时，曾经介绍过两种比较方法，分别是==运算符和 equals() 方法，==运算符是比较两个引用变量是否指向同一个实例，equals() 方法是比较两个对象的内容是否相等，通常字符串的比较只是关心内容是否相等。

public class Person{
    // 验证用户名和密码
    public static boolean validateLogin(String uname, String upwd) {
        boolean con = false;
        if (uname.equals("admin") && upwd.equals("admin")) { // 比较两个 String 对象
            con = true;
        } else {
            con = false;
        }
        return con;
    }
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("------欢迎使用大数据管理平台------");
        System.out.println("用户名：");
        String username = input.next(); // 获取用户输入的用户名
        System.out.println("密码：");
        String pwd = input.next(); // 获取用户输入的密码
        boolean con = validateLogin(username, pwd);
        if (con) {
            System.out.println("登录成功！");
        } else {
            System.out.println("用户名或密码有误！");
        }
    }
}

==当hashCode（）不同是，判断的时候会输出false

装箱和拆箱

基本数据类型转换为包装类的过程称为装箱，例如把 int 包装成 Integer 类的对象；包装类变为基本数据类型的过程称为拆箱，例如把 Integer 类的对象重新简化为 int。

public class Demo {
    public static void main(String[] args) {
        int m = 500;
        Integer obj = m;  // 自动装箱
        int n = obj;  // 自动拆箱
        System.out.println("n = " + n);
      
        Integer obj1 = 500;
        System.out.println("obj等价于obj1返回结果为" + obj.equals(obj1));//true
    }
}

包装类的应用

可以通过 Integer 类的构造方法将 int 装箱，通过 Integer 类的 intValue 方法将 Integer 拆箱。

1. 实现 int 和 Integer 的相互转换

public class Demo {
    public static void main(String[] args) {
        int m = 500;
        Integer obj = new Integer(m);  // 手动装箱
        int n = obj.intValue();  // 手动拆箱
        System.out.println("n = " + n);
       
        Integer obj1 = new Integer(500);
        System.out.println("obj等价于obj1的返回结果为" + obj.equals(obj1));//true
    }
}

1. 字符串转换为数值类型

public class Demo {
    public static void main(String[] args) {
        String str1 = "30";
        String str2 = "30.3";
        // 将字符串变为int型
        int x = Integer.parseInt(str1);
        // 将字符串变为float型
        float f = Float.parseFloat(str2);
        System.out.println("x = " + x + "；f = " + f);
    }
}

使用以上两种方法时，字符串中的数据必须由数字组成，否则转换时会出现程序错误。

1. 将整数转换为字符串

Integer 类有一个静态的 toString() 方法，可以将整数转换为字符串

public class Demo {
    public static void main(String[] args) {
        int m = 500;
        String s = Integer.toString(m);
        System.out.println("s = " + s);
    }
}