java期末复习知识点整理(上)

Posted 2021-12-12 eyes++

概述

1. Java发展历史——大概理解

   • 1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言。希望用于控制嵌入在有线 电视交换盒、PDA等的微处理器
   • 1994年将Oak语言更名为Java
   • 1998年JDK1.2时，更名为Java 2 Platform
   • 分为标准版J2SE,企业版J2EE,微型版J2ME
   • Java 既安全、可移植，又可跨平台，而且人们发现它能够解决Internet 上的大型应用问题
   • Internet使Java成为网上最流行的编程语言

2. 分成J2ME，J2SE，J2EE

   J2SE(Java 2 Platform Standard Edition) 标准版

   学习Java编程就是从J2SE入手。

   J2SE是Java的标准版，主要用于开发客户端（桌面应用软件），例如常用的文本编辑器、下载软件、即时通讯工具等，都可以通过J2SE实现。

   J2SE包含了Java的核心类库，例如数据库连接、接口定义、输入/输出、网络编程等。

   J2EE(Java 2 Platform Enterprise Edition) 企业版

   J2EE是功能最丰富的一个版本，主要用于开发高访问量、大数据量、高并发量的网站，例如美团、去哪儿网的后台都是J2EE。通常所说的JSP开发就是J2EE的一部分。

   J2EE包含J2SE中的类，还包含用于开发企业级应用的类，例如EJB、servlet、JSP、XML、事务控制等。

   J2EE也可以用来开发技术比较庞杂的管理软件，例如ERP系统（Enterprise Resource Planning，企业资源计划系统）。

   J2ME(Java 2 Platform Micro Edition) 微型版

   Java的初衷就是做这一块的开发。

   J2ME 只包含J2SE中的一部分类，受平台影响比较大，主要用于嵌入式系统和移动平台的开发，例如呼机、智能卡、手机（功能机）、机顶盒等。

   在智能手机还没有进入公众视野的时候，你是否还记得你的摩托罗拉、诺基亚手机上有很多Java小游戏吗？这就是用J2ME开发的。

3. Java语言的特点（开放、简单、健壮、安全、面向网络、完全的OOP、跨平台）

   1.面向对象
   Java 是一种面向对象的语言，它对对象中的类、对象、继承、封装、多态、接口、包等均有很好的支持。为了简单起见，Java 只支持类之间的单继承，但是可以使用接口来实现多继承。使用 Java 语言开发程序，需要采用面向对象的思想设计程序和编写代码。
   2. 平台无关性
   ​ 平台无关性的具体表现在于，Java 是“一次编写，到处运行（Write Once，Run any Where）”的语言，因此采用 Java 语言编写的程序 具有很好的可移植性，而保证这一点的正是 Java 的虚拟机机制。在引入虚拟机之后，Java 语言在不同的平台上运行不需要重新编译。
   ​ Java 语言使用 Java 虚拟机机制屏蔽了具体平台的相关信息，使得 Java 语言编译的程序只需生成虚拟机上的目标代码，就可以在多种平台上不加修改地运行。
   ​ 3. 简单性
   Java 语言的语法与 C 语言和 C++ 语言很相近，使得很多程序员学起来很容易。对 Java 来说，它舍弃了很多 C++ 中难以理解的特性，如操作符的重载和多继承等，而且 Java 语言不使用指针，加入了垃圾回收机制，解决了程序员需要管理内存的问题，使编程变得更加简单。
   ​ 4. 解释执行
   Java 程序在 Java 平台运行时会被编译成字节码文件，然后可以在有 Java 环境的操作系统上运行。在运行文件时，Java 的解释器对这些字节码进行解释执行，执行过程中需要加入的类在连接阶段被载入到运行环境中。
   5. 多线程
   Java 语言是多线程的，这也是 Java 语言的一大特性，它必须由 Thread 类和它的子类来创建。Java 支持多个线程同时执行，并提供多线程之间的同步机制。任何一个线程都有自己的 run() 方法，要执行的方法就写在 run() 方法体内。
   6. 分布式
   Java 语言支持 Internet 应用的开发，在 Java 的基本应用编程接口中就有一个网络应用编程接口，它提供了网络应用编程的类库，包括 URL、URLConnection、Socket 等。Java 的 RIM 机制也是开发分布式应用的重要手段。
   7. 健壮性
   Java 的强类型机制、异常处理、垃圾回收机制等都是 Java 健壮性的重要保证。对指针的丢弃是 Java 的一大进步。另外，Java 的异常机制也是健壮性的一大体现。
   8. 高性能
   Java 的高性能主要是相对其他高级脚本语言来说的，随着 JIT（Just in Time）的发展，Java 的运行速度也越来越高。
   9. 安全性
   Java 通常被用在网络环境中，为此，Java 提供了一个安全机制以防止恶意代码的攻击。除了 Java 语言具有许多的安全特性以外，Java 还对通过网络下载的类增加一个安全防范机制，分配不同的名字空间以防替代本地的同名类，并包含安全管理机制。

4. Java和C++的比较：
   

5. 辨析JVM、JRE、JDK之间的区别与联系
   JDK(Java Development Kit)
   是整个JAVA的核心，包括了Java运行环境，一堆Java工具（javac/java/jdb等）和Java基础的类库（即Java API 包括rt.jar）。
   JDK是java开发工具包，基本上每个学java的人都会先在机器 上装一个JDK，那他都包含哪几部分呢？在目录下面有 六个文件夹、一个src类库源码压缩包、和其他几个声明文件。其中，真正在运行java时起作用的 是以下四个文件夹：bin、include、lib、 jre。有这样一个关系，JDK包含JRE，而JRE包 含JVM。
   JRE（Java Runtime Environment，Java运行环境）
   包含JVM标准实现及Java核心类库。JRE是Java运行环境，并不是一个开发环境，所以没有包含任何开发工具（如编译器和调试器）
   JRE是指java运行环境。光有JVM还不能成class的 执行，因为在解释class的时候JVM需要调用解释所需要的类库lib。 （jre里有运行.class的java.exe）
   JRE （ Java Runtime Environment ），是运行 Java 程序必不可少的（除非用其他一些编译环境编译成.exe可执行文件……），JRE的 地位就象一台PC机一样，我们写好的Win64应用程序需要操作系统帮 我们运行，同样的，我们编写的Java程序也必须要JRE才能运行。
   JVM（Java Virtual Machine）
   即java虚拟机, java运行时的环境，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。针对java用户，也就是拥有可运行的.class文件包（jar或者war）的用户。里面主要包含了jvm和java运行时基本类库（rt.jar）。rt.jar可以简单粗暴地理解为：它就是java源码编译成的jar包。Java虚拟机在执行字节码时，把字节码解释成具体平台上的机器指令执行。这就是Java的能够“一次编译，到处运行”的原因。
   

6. Java程序（.java文件）先由编译器编译成字节码（.class），由解释器解释执行。

7. 一个Java文件可以包含多个类的定义，但是只能有一个public类。文件名必须和public类同名（大小写也要一致）。

8. Java的编译器：javac，解释器：java
   Java编译器：将Java源文件（.java文件）编译成字节码文件（.class文件，是特殊的二进制文件，二进制字节码文件），这种字节码就是JVM的“机器语言”。javac.exe可以简单看成是Java编译器。
   Java解释器：是JVM的一部分。Java解释器用来解释执行Java编译器编译后的程序。java.exe可以简单看成是Java解释器。
   注意：通常情况下，一个平台上的二进制可执行文件不能在其他平台上工作，因为此可执行文件包含了对目标处理器的机器语言。而Class文件这种特殊的二进制文件，是可以运行在任何支持Java虚拟机的硬件平台和操作系统上的！

9. 两个环境变量（PATH,CLASSPATH）的作用、含义，及其配置——着重理解
   PATH的作用：作用是指定命令搜索路径，在i命令行下面执行命令如javac编译java程序时，它会到PATH变量所指定的路径中查找看是否能找到相应的命令程序。我们需要把jdk安装目录下的bin目录增加到现有的PATH变量中，bin目录中包含经常要用到的可执行文件如javac/java/javadoc等待，设置好PATH变量后，就可以在任何目录下执行javac/java等工具了。
   CLASSPATH的作用：作用是指定类搜索路径，要使用已经编写好的类，前提当然是能够找到它们了，JVM就是通过CLASSPTH来寻找类的。我们需要把jdk安装目录下的lib子目录中的dt.jar和tools.jar设置到CLASSPATH中，当然，当前目录“.”也必须加入到该变量中。
   

10. 包的定义（package）、包的导入（import）

包的定义：

package test;   //定义包
package com.baidu.search.utils;   //定义多级包

知识点：

• package 语句必须作为 Java 源文件的第一条非注释语句。
• 一个 Java 源文件中只能有一条 package 语句。
• Java 源文件中可以定义多个类，在声明包之后，这些类生成的字节码文件，将全部位于这个包下。
• 多个 Java 源文件可以声明同一个包，即多个 Java 源文件，可以存放在同一个文件夹下。
• 多级包相当于嵌套的文件目录，如 “com \\ baidu \\ search \\ utils” 目录，Java 源文件和编译生成的字节码文件都将存放在 utils 子目录下。
• 多级包建议写成 “ 公司域名反写 . 项目名 . 模块名” 的形式。例如，“com.baidu” “search” “utils” 分别对应 “公司域名反写” “项目名” “模块名”。

包的导入：

import 包名.*;   //导入指定包中的所有类
import 包名.类名;   //导入指定包中的指定类

知识点：

• import 语句不是必须的，完整包名.类名 变量名 = new 完整包名.类名(); 这种形式也是可以的。
• 当导入的两个或多个包，具有同名的类时，编译器将会无法区分，需要使用 完整包名.类名 变量名 = new 完整包名.类名(); 的形式加以区分。
• 一个 Java 源文件中只能有一条 package 语句，但可以有多条 import 语句。
• import * 只能导入当前包中的源文件，子文件夹下的源文件不能被导入。

Java的语法

11. 标示符的命名
    （1）不能是java的保留字；
    （2）不能数字开头；
    （3）不能包含Java操作符：+,-,*,/,%；
    （4）可以是汉字等unicode字符；
    （5）无define, const关键字，使用final

12. Java的数据类型
    （1）简单:8种，参数传递的是值；
    （2）复杂：类、接口、枚举、数组，参数传递采用的是引用模型，也就是传地址；
    

13. Java中char采用的是2个字节的unicode编码

14. Java采用8个数据类型类对8种基本数据类型进行封装
    

16. Java中的字符串类，String，StringBuffer。String的典型方法：equals(), indexOf()

17. Java中的类型转换：自动转换、强制转换。 int age = 1.5；//在Java中是错误的
    
    

18. Java中的数组的定义，使用。数组的length属性。类的数组的初始化分为两步——如何理解

19. Java中带标号的break，continue语句的含义
    

20. 生成随机数数组的例题

package test;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

public class test {
    public int[] getArr(int n) {
        int[] targetArr = new int[n];

        ArrayList<Integer> arr = new ArrayList<>();
        for (int i = 1; i <= n; i++) arr.add(i);

        Random r = new Random();
        for (int i = 0; i < n; i++) {
            int length = arr.size();
            int index;
            if (length > 1) {
                index = r.nextInt(length - 1);
            } else {
                index = 0;
            }
            targetArr[i] = arr.get(index);
            arr.remove(index);
        }
        
        return targetArr;
    }

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n;
        while(true) {
            System.out.println("请输入数组元素数量：");
            if (scan.hasNextInt()) {
                n = scan.nextInt();
                if (n > 0) break;
            } else {
                System.out.println("输入的不是正整数，请重新输入！");
            }
        }
        
        System.out.println("获得的随机数组如下：");
        test t = new test();
        int[] targetArr = new int[n];
        targetArr = t.getArr(n);
        for (int i = 0; i < n; i++)
            System.out.println("targetArr["+i+"]:"+targetArr[i]);
    }
}

OOP

20. OOP的三大特征：封装、继承、多态
    封装特征
    在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制。封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。
    
    封装的优点：

    • 良好的封装能够减少耦合。
    • 类内部的结构可以自由修改。
    • 可以对成员变量进行更精确的控制。
    • 隐藏信息，实现细节。
      
      

    继承特征
    

多态特征

21. 类的定义、类的成员变量、成员方法的定义的语法

22. 如何理解静态变量、静态方法（static）
    
    在类中，使用 static 修饰符修饰的属性（成员变量）称为静态变量，也可以称为类变量，常量称为静态常量，方法称为静态方法或类方法，它们统称为静态成员，归整个类所有。
    
    静态成员不依赖于类的特定实例，被类的所有实例共享，就是说 static 修饰的方法或者变量不需要依赖于对象来进行访问，只要这个类被加载，Java 虚拟机就可以根据类名找到它们。
    
    
    

23. 构造方法：
    （1）和类同名；
    （2）无返回值；
    （3）由new调用；
    （4）可以重载；
    （5）Java为哪些类提供无参的构造方法

24. 封装：
    （1）类的访问控制：public，非公有；
    （2）类的成员的访问控制：public，protected，default，private，他们表达的访问控制策略是什么？——一张表格的理解
    

25. 继承：
    （1）java仅支持类的单重继承；
    （2）使用extends关键字，所有的类默认继承Object；
    （3）子类自动拥有父类中非私有的变量和方法；

26. 方法的重载和方法的重写（覆盖）的区别。
    

27. this，super关键字的使用（分别修饰变量、方法和构造方法）
    

class Person {
    private int age = 10;
    public Person(){
    System.out.println("初始化年龄："+age);
}
    public int GetAge(int age){
        this.age = age;
        return this.age;
    }
}
 
public class test1 {
    public static void main(String[] args) {
        Person Harry = new Person();
        System.out.println("Harry's age is "+Harry.GetAge(12));
    }
}

package base.io;

class Country {
    String name;
    void value() {
        name = "China";
    }
}
public class Test extends Country {
    String name;
    void value() {
        name = "Shanghai";
        super.value();      //调用父类的方法
        System.out.println(name);
        System.out.println(super.name);
    }
    public static void main(String[] args) {
        Test c=new Test();
        c.value();
    }
}

package base.io;


class Person {
    public static void prt(String s) {
        System.out.println(s);
    }

    Person() {
        prt("父类·无参数构造方法： " + "A Person.");
    }//构造方法(1)

    Person(String name) {
        prt("父类·含一个参数的构造方法： " + "A person's name is " + name);
    }//构造方法(2)
}

public class Test extends Person {
    Test() {
        super(); // 调用父类构造方法（1）
        prt("子类·调用父类无参数构造方法： " + "A chinese coder.");
    }

    Test(String name) {
        super(name);// 调用父类具有相同形参的构造方法（2）
        prt("子类·调用父类含一个参数的构造方法： " + "his name is " + name);
    }

    Test(String name, int age) {
        this(name);// 调用具有相同形参的构造方法（3）
        prt("子类：调用子类具有相同形参的构造方法：his age is " + age);
    }

    public static void main(String[] args) {
        Test cn = new Test();
        cn = new Test("codersai");
        cn = new Test("codersai", 18);
    }
}

28. 方法覆盖overrride的两个原则：
    （1）访问控制；
    （2）声明的异常

29. 多态：运行时多态、编译时多态

30. 运行时多态的两个前提：
    （1）上溯造型；
    （2）方法重写（覆盖）

31. final关键字修饰 变量、方法、类的时候，分别表示什么含义？

修饰对象	解释说明	备注
类	无子类，不可以被继承,更不可能被重写。	final类中的方法默认是final的
方法	方法不能在子类中被覆盖	类的private方法会隐式地被指定为final方法。final方法不能被子类的方法覆盖，但可以被继承。
变量	称为常量，初始化以后不能改变值。	用final修饰的成员变量表示常量，值一旦给定就无法改变！final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。

33. 抽象类和接口的知识点——重点

抽象类

33. abstract修饰的类叫抽象类，抽象类不能实例化对象

34. abstract修饰的方法叫抽象方法，抽象方法没有方法体

35. 抽象类中包含N个抽象方法（n>=0）

36. 非抽象方法可以调用抽象方法

37. 一个非抽象子类继承了一个抽象类，必须覆盖（重写）父类中的所有抽象方法

38. 思考抽象类存在的必要性？
    

接口

39. 接口interface，类实现接口implements，接口只包含常量+抽象方法

40. 接口中的常量自动是public static final, 方法自动有public abstract

41. 一个类允许实现多个接口，接口可以多重继承

42. 一个非抽象类实现了某个接口，必须重写接口里面的所有抽象方法

内部类：

成员内部类不能有static属性和静态方法

成员内部类可以无障碍的访问外部类的任何成员（变量、方法）

系统类

43. Object是所有类的父类（间接父类）
    

44. 重点掌握Object的equals()，getClass()，toString（）方法；
    
    

45. 复习String类的用法
    

46. 基本数据类型到String之间相互转换；
    

47. 动态数组Vector，ArrayList的使用（结合实验二）
    
    

如果有兴趣了解更多相关知识，欢迎来到我的个人网站看看：eyes++的个人空间