JAVA期末

JAVA 复习资料

Java语言的特点（选择题、判断题）

• 简单、面向对象、与平台无关、多线程、动态

标识符命名规则。（选择题、判断题）

• 由字母、下划线、美元符号、数字组成
• 第一个字符不能是数字
• 标识符不能是关键字;不能是true\false\null

开发与运行Java程序的三步骤（简答题）

• 编写源文件：使用文本编辑器编写源文件。将编写好的源文件保存，源文件的扩展名必须是.java
• 编译源文件：使用Java编辑器(javac.exe)编译源文件，得到字节码文件(扩展名是.class)
• 运行程序：使用Java SE平台中的Java解释器(java.exe)来解释，执行字节码文件

java程序文件名命名规则（java源程序文件名与应用程序类名），及文件扩展名（选择题）、main方法（选择题、判断题）、主类

• 源文件中可以有多个类，但最多一个类是public类
• 如果源文件中有public,源文件名必须要和public类的名字完全相同；如果源文件中没有public类，源文件名只需要和某个类的名字相同
• 源文件的扩展名是.java;字节码文件扩展名是 .class
• 一个Java应用程序中必须有且仅有一个类含有main方法(public static void main(Sting args[])，称这个类为主类

整型（十进制、八进制、十六进制）合法常量的表示方法、字符型常量（单个字符、字符串常量）的表示方法、实型合法常量的表示方法。字符采用的编码（选择题、判断题）。

• 整型常量：
  • 十进制：无前缀
  • 八进制：0做前缀
  • 十六进制：0x或0X做前缀
• 字符型常量：
  • 单个字符：用单引号’ ’括起来
  • 字符串常量：用双引号" "括起来
• 实型合法常量：
  • float:必须要有后缀f或F,存储时保留8位有效数字
  • double:可以有后缀d或D,存储时保留16位有效数字
• 字符采用ASCII编码

混合数据类型运算的表达式求值：（选择题、判断题、阅读程序）

掌握教材提到的常用运算符的运算规则，以及运算对象（如 %、/ 、逻辑运算符&&和||等）的特殊要求，包括复合赋值运算符（+=，-=，*= 等）

 逻辑运算符：
 +、-、*、/；
 a+=b;//a=a+b;
 a-=b;//a=a-b;
 自增：a++(执行完代码后，再自增，即先用后加) a=a+1
     ++a(执代码前，先自增，即先加后用)
 自减同理a--、--a
 幂运算：需要用工具函数来执行；

 位运算符：
     &&（与）、||（或）、!（非）
    - a&&b 与运算 有假为假
    - a||b 或运算 有真为真
    - !a、!b 非运算 假为真，真为假
    - !(a&&b)异或运算 同号为假，异号为真

 短路运算：当*与运算*时，若靠左的逻辑运算若为假，则不继续走右边逻辑运算，直接结束运算。
 A=0011 1100
 B=0000 1101
 -----------------------------
 A&B 0000 1100(都为1则为1，有一个非1为0)；
 A|B 0011 1101(都为0则为0，存在一个1直接为1)；
 A^B 0011 0001(相同为0，不同为1)；
 ~B 1111 0010（取反）
 2<<3 2左移3位 0000 0010->0001 0000 则结果为16
 >>右移除二
 <<左移乘二
 三元运算符
 //? :
 //x?y:z   (如果x==true，则结果为y,否则为z)

数据类型转换：自动转换条件、以及何种情况下需要强制转换与语法格式

• 自动转换条件：低精度转高精度

• 强制转换：高精度转低精度

• 强制转换语法格式：(类型名)要转换的值 例如：int x=(int)34.98

• 不能把一个高精度的变量直接赋值给低精度变量，因为编译器只会检查变量的类型而不是变量的值 例如有int x=1;byte y;不能y=x,必须y=(byte)x

• 注意点：：

  • 不能对布尔值(boolean，只能为其变量赋值true和false)进行转换
  • 不能把对象类型转换为不相干的类型
  • 高容量转换为低容量的时候强制转换可能内存溢出或者精度问题。

    //强制转换：
    int i=128;
    byte b=(byte)i;

    //自动转换：
    int i=128;
    double b=i;

条件运算符的使用

• 加减运算符、乘除求余运算符、自加自减运算符、关系运算符、逻辑运算符、赋值运算符、位运算符、intanceof运算符(二目运算符，左边是一个对象，右边是类，当左边的对象是右边的类或者子类创建的对象的时候，返回true,否则false)

掌握分支结构与循环结构程序设计（选择题、程序阅读题、编程题）

（1）if语句、if~else语句　
（2）switch语句

• switch后面的表达式的值不能是long型
• 表达式的值和case常量值匹配，匹配成功则执行当中的语句，直到遇到break语句；如果没遇到break，则进行下一个匹配
• 如果表达式的值不与任何一个case常量值相等，则执行default语句，default语句也可以没有，default语句可以在任意位置

（3）循环语句的结构（for、while、do-while）

• while与do-while的区别：do-while至少执行一次

（4）break和continue语句return语句使用的用法。

• break被执行，整个循环结束，不再执行循环语句
• continue被执行，本次循环结束，进入下一次循环
• return返回某个值
  （5）以及它们的组合使用。

一维数组的定义与使用；二维数组的定义与使用；数组元素的访问

• 一维数组声明：
  • 1.类型 数组名[](int a[])
  • 2.类型 [] 数组名(int [] a)

 int[]nums;//首选声明类型
 int nums2[];//C语言风格 
 nums=new int[10];//创建一个数组
 int [] num=new int [10];//创建与声明相结合
 int [] numbers={
   10,20,30,40,50};//定义数组：

• 二维数组声明：
  • 1.类型 数组名[][](int a[][])
  • 2.类型 [][] 数组名(int [][] a)
• 一次声明多个数组:
  • 类型 [] 数组名1,数组名2(声明两个数组a,b：int [] a,b)
• 一维数组分配元素：数组名=new 类型[个数](a=new int[3])
• 二维数组分配元素：数组名=new 类型[一维个数][二维个数](a=new int[2][3])
• 创建数组(声明并分配元素)：如：int a[][]=new int[3][2]
• 数组初始化：如float a[]={21.f,34.23f,56,78f,90,12f}
• 数组属于引用型变量

Java面向对象编程

掌握类的定义（成员变量、成员方法和构造方法）和使用，对象创建

• 成员变量：成员变量有默认值：
  • 成员变量=属性=field(字段)
  • 属性是类的一个组成部分，一般是基本数据类型，也可以是引用类型（对象、数组）
  • 属性的定义语法同变量： 访问修饰符 属性类型 属性名;
  • 对于boolean变量,默认值是false;
  • 对于 byte short、int 和long 变量，默认值是0；
  • 对于char 变量,默认值是’\0’(空宇符)；
  • 对于float和double 变量，默认值是0.0；对于“引用型”变量，默认值是null
• 成员方法：
  1.成员方法(实例方法)内声明的变量是局部变量；
  2.方法内声明的局部变量如果与成员变量的名字相同，那么成员变量被隐藏
• 构造方法：
  1.构造方法没有返回值
  2.构造方法的名字与类名一样
  3.构造方法名可以一样，但必须参数类型或者参数个数不同(重载)
  4.如果类中没有编写构造方法，那么系统会给一个默认的构造方法
• 对象：
  1.创建：类名 对象名=new 类名()
  2.对象属于引用型变量，存放的是引用值；创建对象分为声明和分配内存
  3.对象可以调用类中的方法、自己的变量

实例变量与局部变量的区别（简答题）

属性	局部变量
有默认值，可以不赋值直接使用	无默认值,必须赋值在使用
可以被本类使用，或其它类使用(通过对象调用)	只能在本类中对应的方法中使用
可以加修饰符	不可以加修饰符
可以重名，访问时准寻就近原则	在同一个作用域中比如在同一个成员方法中，两个局部变量不能重名
生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁	生命周期较短，伴随着他的代码块的执行而创建，伴随着代码块的结束而销毁

• 实例变量(成员变量)在类体内方法外声明，与对象共存亡，在类中有效，有默认值，通过(对象名+.)访问
• 局部变量在方法内声明，与方法共存亡，在方法内有效(且与在方法内的位置有关），没有默认值，可以直接访问

类与对象的关系（简答题）

• 用类声明的变量被称为对象。在用类声明对象后还必须创建对象，即为对象分配所拥有的变量。类是创建对象的模板，没有类就没有对象

package与import的用法（选择题、判断题）

• package语句：package 包名(包名可以是一个合法的标识符，也可以是若干个标识符加上”.”分隔而成；有包名的类的存储目录必须包含包名)
• import语句：表示引入一个包中的所有类，但可能会增加编译的时间

方法的调用与参数传递，参数传递的方法（值传递与引用传递）（选择、程序阅读题）

• 参数传递

1. 值传递：向该参数传递的值的级别不可以高于该参数的级别，比如不可以向一个int型参数传递一个float值

2. 引用传递：传递的是变量中的引用

   • 基本数据类型赋值（值拷贝）

   int n1=10;
   int n2=n1;
   n2=80;
   //输出n1为10；n2为80；
   //n2的变化不会影响n1的值
   

   • 数组引用传递（地址拷贝）

   int[] arr1={
        1,2,3};
   int[] arr2=arr1;
   //赋的是一个地址，arr2的变化会影响到arr1
   arr2[0]=10;
   //输出的arr1为 10 2 3
   

this与super的各自作用（简答题，阅读程序题）

• this
  1.构造方法中使用，代表使用该构造方法所创建的对象
  2.实例方法中使用，代表正在调用该方法的当前对象
• super
  1.用super操作子类隐藏的继承的成员变量和方法
  2.用super调用父类的构造方法

• super注意点：
  • super调用父类的构造方法，必须在构造方法的第一个/第一行
  • super必须只能出现在子类的方法或者构造方法中。
  • super和this不能同时调用构造方法，因为this()也只能放在构造器的第一行
• super和this的区别:
  • 代表的对象不同
    • this:本身调用者这个对象
    • super:代表父类对象的应用
  • 前提
    • this:没有继承也可以使用
    • super:只能在继承条件才能使用
  • 构造方法：
    • this():本类的构造
    • super():父类的构造

类的访问修饰符有哪些（选择题、判断题）

1. 公开级别 public 对外公开
2. 受保护级别 protected 对子类和同一个包中的类公开
3. 默认级别 没有修饰符号 向同一个包的类公开
4. 私有级别 private 只有类本身可以访问，不对外公开
   访问修饰符的访问范围：
   

注意事项

• 修饰符可以用来修饰类中的属性，成员方法以及类
• 只有默认和public才能修饰类，并且遵循上述访问权限的特点
• 成员方法的访问规则和属性完全一样

类的私有成员和公共成员

• 类的私有成员只供本类调用(当声明了一个私有成员变量时，但可以通过public方法来修改它的属性)
• 类的公共成员，可以被任何类调用

成员的访问修饰符：private、protect、public、缺省修饰符，它们的访问权限各是什么（选择题、判断题）

• private：本类
• protected：本类、同包类、不同包的子类
• public:所有类
• 缺省修饰符：本类、同包类

方法的重载的格式 （选择题、判断题）

• 参数个数不同或者参数个数相同但是参数类型不同

构造方法的作用与定义，构造方法的重载与调用（选择题、判断题，程序阅读题）

• 是类的一种特殊方法，作用是完成对新对象的初始化,并不是创建对象。

基本语法：

[修饰符]方法名(形参列表){
    
    方法体;
    }

• 参数列表和成员方法一样的规则

• 构造器的修饰符可以默认，也可以是public、protected、private

• 构造器必须和类的名字相同

• 必须没有返回类型，也不能写void

• 构造器的调用，由系统完成

• 一旦定义了自己的构造器，默认的构造器就覆盖了，就不能再使用默认的无参构造器，除非故意的定义声明一下，即： Person(){}

• 如果没有定义构造器，系统会自动给类生产一个默认无参构造器
  对象的创建和使用：

• 必须使用new 关键字创造对象，设构造器 person mosun

  • 对象的属性 mosun.name
  • 对象的方法 mosun.run()

//构造器实例化初始值
//使用new关键字，必须要有构造器，本质是在调用构造器
//用来初始化值
//对象属性：字段field 成员变量
//默认初始化：
// 数字：0 0.0
// char:u0000
// boolean:false
// 引用类型：null
public Student(){
   
    this.name="mosun"//没实例化之前类的对象为null

}
//有参构造（alt+insert默认生成有参）：
public Person(String name){
   
    this.name=name;
}
//================================================
public class pet {
   
    public String name;
    public int age;
    public void shout(){
   
        System.out.println("汪了一声");
    }
}
public class 使用类 {
   
        public static void main(String[] args) {
   
            pet dog = new pet();

            dog.name="messi";
            dog.age=3;
            dog.shout();
            System.out.println(dog.name);
            System.out.println(dog.age);
        }
        //输出汪了一声
        //messi
        //3

    }

构造器重载：eg: 两个Person构造器，一个指定人名和年龄，一个只指定人名

class Person{
   
    String name;
    int age;
    public Person(String pName,int pAge){
   //指定人名和年龄
        name=pName;
        age=pAge;
    }
    public Person(String pName){
   //只指定人名
        name=pName;
    }
}

静态成员变量和静态成员方法的使用 （选择题、判断题，程序阅读题）

• 声明成员变量时，用static修饰的称为静态成员变量(类变量)
  1.所有对象共享类变量，也就是说改变一个对象的类变量其他对象的这个类变量也会改变，而每个对象的实例变量不同
  2.也可以通过类名直接访问类变量
• 加static修饰的方法是类方法
  1.类方法不可以操作实例变量
  2.类方法要通过类名调用，不能通过对象调用

类方法发也叫静态方法

• 形式：访问修饰符 static 数据返回类型 方法名(){}

• 调用（满足访问修饰符的访问权限和范围）：类名.类方法名或者对象名.类方法名
  

• 类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区：类方法中无this的参数（this代表当前对象，而static表示对象的共享，因此不能存在this在静态方法中）

  • 普通方法中隐含着this参数
  • 类方法中不允许使用和对象有关的该句子（this、super等）普通方法可以

• 普通方法和对象有关，需要通过对象名调用，不能通过类名调用

• 静态方法(类方法)只能访问静态变量或者静态方法

• 普通成员方法既可以访问非静态成员也可以访问静态成员
  

继承与多态的概念（简答题）

• 继承：一种已有的类创建新类的机制
• 多态：父类的某个方法被其子类重写时可以各自产生自己的功能行为

子类的创建（注意，在子类构造方法中自动调用父类构造方法），上转型对象（程序阅读题）

• 先调用父类的某个构造方法，再调用组合类的构造方法，最后调用子类自己的构造方法
• 上转型对象
  1. 不能调用子类新增的成员变量和方法
  2. 不能调用子类重写的static方法
  3. 不能调用隐藏的方法

方法的重载与重写（也称为覆盖）的区别（简答题）

• 重载：只看参数(参数类型或者个数不同)(返回类型和参数名字不参与比较)
• 重写：只有方法体不同(返回类型，方法名，参数都相同)

抽象类的定义

• 关键字abstract修饰
• 抽象类中可以有抽象方法也可以没有
• 抽象方法只允许声明，不允许实现，也就是没有方法体
• 抽象类不能用new标识符创建对象
• 如果一个非抽象类是抽象类的子类，那它必须重写父类的抽象方法；如果一个抽象类是抽象类的子类，那可以重写或者继承父类的抽象方法

接口与接口的实现，利用接口实现多重继承

接口(特殊的抽象)就是给出一些没有实现的方法，封装到一起，到某个类到使用的时候，再根据具体情况把这些方法发写出来

• 语法：

  interface 接口名{
       
    //属性
    //方法(1. 抽象方法 2.默认实现方法 3.静态方法)
  }
  class 类名 implements 接口{
       
    自己属性;
    自己方法;
    必须实现的接口的抽象方法
  }
  

• 如果一个类implements(实现)接口，需要将该接口的所有抽象方法都实现

• 接口不能被实例化，不能被使用

• 接口中所有的方法都是public方法，接口中抽象方法，可以不用abstract修饰

• 一个普通类实现接口，就必须将该接口的所有方法都实现

• 抽象类实现接口时，可以不用实现接口的方法

• 一个类可以同时实现多个接口

• 接口中的属性，只能是final，而且是public static final修饰符

  • 比如 int a=1;实际上是 public static final int a=1;

• 接口中属性的访问形式：接口名.属性名

• 一个接口不能继承其他的类，但是可以继承多个别的接口

• 接口的修饰符只能是public和默认(和类的修饰符一样)

• 接口与继承

  • 继承满足is-a关系，接口只需满足like-a关系
  • 当子类继承了父类，就自动的拥有父类的功能
  • 如果子类需要拓展功能，可以通过实现接口的方式拓展
  • 可以理解实现接口是对java单继承机制的一种补充

• 接口在一定程度上实现代码解耦（即接口规范性+动态绑定）

接口与抽象类的区别（简答题）

• 接口中只有常量而没有变量，抽象类中都可以有
• 抽象类强调的是继承关系和代码复用，而接口是针对一个行为的实现

程序对错误与异常的处理方式，异常处理的基本结构try-catch-finally使用，throw和throws的使用及各自的作用（选择题、判断题, 程序阅读题）

异常：将程序执行中发生的不正常情况称为异常(语法错误和逻辑错误不是异常)

• 执行过程中发生的异常事件可分为两类

  • Error(错误):JAVA虚拟机无法解决的致命严重问题
  • Exception(异常)：其他因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理
    • 运行时异常：程序运行时发生的异常(编译器检测不出来)
    • 编译时异常：编写程序时，由编译器检测出的异常

• 为保证程序的健壮性，如果程序员认为一段代码出现异常/问题，可以使用try-catch异常处理机制来解决

  • 如果程序出现了异常，程序仍然可以继续执行

  
        int num1=10,num2=0;
        int res= 0;
  //    res = num1/num2;//分母为0，会报错导致执行失败(运行时异常)
        try {
       
            res = num1/num2;//选定指定代码后快捷键Ctrl+alt+t࿰