JAVA 暑假复习

最新推荐文章于 2024-11-11 21:19:25 发布

小豫梨

最新推荐文章于 2024-11-11 21:19:25 发布

阅读量214

点赞数

分类专栏： JAVA 文章标签： java

本文链接：https://blog.csdn.net/weixin_51237324/article/details/118580149

版权

JAVA 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

20210708-20210718

1 给属性赋值的两种方式？

1 通过set()方法。

2 通过含有这个属性的构造方法。

2 程序片段思考：

D:\idea-workplace\Test\src\javaa\daer\daershujia\D210708T01.java

D:\idea-workplace\Test\src\javaa\daer\daershujia\D210708T02.java

3 final：

表示不可变，最终的。

其修饰的类不能被继承；修饰的方法不能被覆盖、继承；修饰的变量不能被修改。

其修饰的引用对象不能重新指向其他对象，但对象内部数据可以被修改。

final修饰的的实例变量不会被系统初始化赋值，需要手动赋值（new时赋值）。

final修饰的实例变量常和static连用构成常量（常量名大写）。

4 程序片段思考：

D:\idea-workplace\Test\src\javaa\daer\daershujia\D210709T01.java

5 抽象类：

无法实例化，无法创建对象，用来被子类继承的(所以不能与final连用)，被非抽象类继承必须将抽象方法全部覆盖（/重写）。

其子类依旧可为抽象类。

1 抽象类是半抽象的。

2 无法实例化，但其内有构造方法用来给子类实例化。

3 支持单继承。

super（）调用父类的无参构造（调用不到则报错）。

抽象类中不一定有抽象方法，反之不然。

6 接口：

尽量面向接口编程。

1 接口时完全抽象的。

2 其内没有抽象方法，只有抽象方法和常量，通常提取行为动作。

3 接口支持多继承（继承多个接口）。

继承和实现共存时，继承在前，实现在后。

其内的方法必须全加public与abstract（不能有方法体），所以可以省略不写；常量的static也可省略。

是一种引用数据类型。

类之间是继承，类和接口之间是实现。但仍是继承思想。

非抽象类实现接口时，要将其内所有抽象方法实例化（/覆盖/重写）。

7 强转：

无论是向上（/向下）转型都需要类之间有继承关系，但不适用于接口（没有关系的接口也能强转，但可能会出现异常）。

向下转型要加上instanceof判断类型。

8 程序片段思考：

D:\idea-workplace\Test\src\javaa\daer\daershujia\D210711T01.java

9 多态：/解耦合：

作用：1面向抽象编程。 2降低耦合度，提高程序扩展力。

解耦合：每一个接口都有实现者和调用者，接口可将两者关系解耦，调用者面向接口调用，实现者面向接口实现。

10 类之间关系：

is a / has a / like a --> extends / { } (即关联) / implements

11 访问控制权限修饰符：

	本类	同包	子类	任意位置
public	可	可	可	可
protected	可	可	可	否
默认	可	可	否	否
private	可	否	否	否

范围从大到小排序：public--> protected--> 默认--> private

12 equals / ==:

== 比较两个对象的内存地址（比较基本数据类型的数据）

equals 判断两个对象是否相等（比较引用数据类型的数据) (比较两个字符串时，使用equals,因为String类中重写了此方法)

13 匿名内部类

定义：再类内部定义的无名类。

分类：

1 静态内部类：类似静态变量。

2 实例内部类：类似实例变量。

3 局部内部类：类似局部变量。（定义在类中的方法内部）

特点：可读性差，不能复用（因为无名不能多次调用）。

14 程序片段思考：

public class D210715T01 {
    public static void main(String[] args) {
        //new jisuan().jssumM(new MyMath3Impl(),1,2);
        /*...(){...}表达了对接口的实现*/
        new jisuan().jssumM(new MyMath3() {
            public int sumM(int num1, int num2) {
                return num1 + num2;
            }
        }, 1, 2);
    }
}
interface MyMath3 {
    int sumM(int num1, int num2);
}
//实现类
//class MyMath3Impl implements MyMath3 {
//    @Override
//    public int sumM(int num1, int num2) {
//        return num1+num2;
//    }
//}
class jisuan {
    public void jssumM(MyMath3 mymath3, int num1, int num2) {
        System.out.println(mymath3.sumM(num1, num2));
    }
}
//D:\idea-workplace\Test\src\javaa\daer\daershujia\D210715T01.java

15 数组：

1 本身为引用数据类型（所以存在堆内存中），其内可存放基本数据类型数据和引用数据类型数据（数据类型要一致）。

2 数组内数据的内存地址是顺序连续排列的。

3 存储的若是Java对象则是存储的内存地址（即对象的引用）。

4 一旦创建长度不能改变。

5 数组内存地址为第一个数据的内存地址。

6 每个数据都有下标并以0开始逐渐递增（存取时需要）。

特点：

（优点）查询元素的效率高（可以说最高的）。（因为：1 内存地址连续 2 元素类型相同即占用空间相同 3 可位移计算出下标）

（缺点）1 增删元素效率低（因为地址连续会牵扯到下一个元素存放）（最后一个元素的增删效率无影响）；2 不能存放大数据量（因为难开辟一块大的连续内存空间）。

7 动态/静态一维数组的正反遍历

/*数组正反遍历
 * 1 数组长度为末尾下标+1
 * 2 初始化数组的两种方式*/
public class D210716T01 {
    public static void main(String[] args) {
        int[] int1 = {1, 2, 2};//静态初始化数组
        for (int i = 0; i < int1.length; i++) {
            System.out.println("下标" + i + ":" + int1[i]);
        }
        System.out.println("--------");
        int[] int2 = new int[2];//动态初始化数组 2为数组长度
        for (int i = int2.length - 1; i >= 0; i--) {
            System.out.println("下标" + i + ":" + int2[i]);
        }
    }
}
/*D:\idea-workplace\Test\src\javaa\daer\daershujia\D210716T01.java
* 测试结果：
下标0:1
下标1:2
下标2:2
--------
下标1:0
下标0:0
*/

8 简易验证登录功能

/*简易验证登录功能*/
public class D210718T02 {
    public static void main(String[] args) {
        loginM(new String[]{"sdf", "sdf"});
        loginM(new String[]{"admin", "123"});
    }

    public static void loginM(String[] args) {
        if (args.length != 2) {
            System.out.println("检查登录信息");
        } else if (args.length == 2 && args[0] == "admin" && args[1] == "123") {
            System.out.println("登录成功");
        } else {
            System.out.println("登录信息异常");
        }
    }
}
/*D:\idea-workplace\Test\src\javaa\daer\daershujia\D210718T02.java
运行结果：
登录信息异常
登录成功*/

9 一维数组的扩容

（数组长度确定后不可变）数组满后要扩容。

扩容：1 新建一个大数组 2 拷贝小数组到大数组中（此时小数组被垃圾回收）

特点：效率低（尽量不扩容/拷贝）（拷贝对象：实际拷贝的是对象的内存地址）

10 二维数组

是特殊的一维数组，其内每个元素是一个一维数组。（三维数组同理）

11 静态/动态二维数组的正反遍历

/*D:\idea-workplace\Test\src\javaa\daer\daershujia\D210722T01.java
静态/动态二维数组的正反遍历*/
public class D210722T01 {
    public static void main(String[] args) {
        int[][] ints1 = {
                {1, 2, 3},
                {4, 5, 6},
                {7, 8, 9}
        };
        int[][] ints2 = new int[3][3];
        for (int i = 0; i < ints1.length; i++) {
            for (int j = 0; j < ints1[i].length; j++) {
                System.out.print(ints1[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println("---------");
        for (int i = 0; i < ints2.length; i++) {
            for (int j = 0; j < ints2[i].length; j++) {
                System.out.print(ints2[i][j] + " ");
            }
            System.out.println();
        }
    }
}

16 其他：

1 包名命名规范：公司域名倒写+项目名+模块名+功能名。

2 Java.lang包下不用经过导入就可使用。

3 API：即Java的应用程序编程接口，整个jdkd的类库就是一个javase的API，每个API都配一套API帮助文档。

4 static{ ... } :此为静态代码块，在类加载时执行且只执行一次。

5 UML:统一建模语言（画图的），面向对象的编程语言都可用UML。

可描述类之间的关系，程序执行流程图，对象的状态。（Java开发人员需要做到看懂。）

6 重写后的方法不能比之前的方法抛出更多的异常。

20210719-20210729

异常

1 异常以类和对象的形式存在。

2 异常的分类

Exception（可处理的）下的分支{

1 Exception下的直接子类叫编译时异常（/受检异常/受控异常）。（编译时异常在编译阶段发生吗？不，其表示在编译阶段要预处理的异常，否则编译器报错。）

2 RuntimeException下的子类叫运行时异常（/未受检异常/非受控异常）。（其可在编译阶段处理，也可不处理。）

/*特点：

（编译时异常）发生概率高；（运行时异常）发生概率低。

两种异常都在运行时报错（因为运行时才可new对象），但编译时异常不预先处理编译就不通过*/

}

Exception（可处理的）的同级分支---- Error（不可处理的，直接退出JVM），两者共同的向上级为Throwable。

3 两种处理方式

上抛：在方法声明的位置使用throws抛给上级调用者。(注意：1 最终抛给main-->jvm，此时就只能终止执行（所以不建议在main上使用throws）。2 上抛时其方法内之后的代码不执行)

捕捉：try ... catch {

注意：1 try中某一行异常则其后代码不执行，捕捉异常后才能执行。

2 catch可写多个（但必须从小到大，每个catch精确处理一个问题，便于调试）。

3 finally：其内代码最后执行且一定执行（无论是否有异常出现），但退出jvm后不执行。

必须和try一起出现，不能单独出现。可以出现try ... finally没有catch情况。

4 try... catch ... 下的代码执行不到。

5 catch后多个异常比直接Exception效率高。

}

4 两种方式怎么选？希望调用者处理则上抛（throws），其他捕捉。

5 异常中的两个方法？

 try {
      temperature.getTemperature(39);
 } catch (HotException e) {
      System.out.println(e.getMessage());//获取异常的描述信息
      /*e.printStackTrace();打印异常追踪的堆栈信息*/
      /*查看异常堆栈信息时，从上往下逐行看自己编写的代码（用包名判断是否自己的代码）（sun编写的没问题）*/
 }

6 final finally finalize的区别？

final：关键字。修饰的类/方法/变量无法被继承/覆盖/重新赋值。

finally: 关键字，如上。

finalize: 标识符，一个方法名。

7 自定义异常：

8 空指针异常：判断变量是否为null时， “null==变量” 此形式更好，方式写 “变量==null” 时误写 “变量=null” 而赋变量值为null。

9 finally 与 return共存时