JAVA总复习

最新推荐文章于 2022-12-27 00:00:00 发布

伏地嘤嘤怪

最新推荐文章于 2022-12-27 00:00:00 发布

阅读量570

点赞数 7

分类专栏：笔记

本文链接：https://blog.csdn.net/weixin_52821835/article/details/121658755

版权

笔记专栏收录该内容

15 篇文章 0 订阅

订阅专栏

第二章（基本数据类型与数组）

标识符

标识符由字母，下划线，美元符号和数字组成，第一个字符不能是数字， $f a l s e$ 不是标识符。

关键字

关键词是Java语言中已经被赋予特定意义的一些单词，不可以把关键词作为名字来用。true 和 false 都不是关键词

基本数据类型

boolean , char , byte , short , int , long ,float , double
char 类型是两个字节的，在unicode表是从0开始到65535，在java里面是没有unsigned类型的

float型常量和double型常量

float常量必须用F或者f作为后缀。double常量用D或者d为后缀。但double常量允许省略后缀

获取数组的长度

获得一维数组的长度，获取二维数组中一维数组的个数。一维数组名.length 二维数组名.length

Example1

public class E{
	public static void main(String args[]){
		int x=8;
		byte b =127;   //【代码1】
		b=x;           //【代码2】
		x=12L;         //【代码3】
		long y=8.0;    //【代码4】
		float z=6.89;  //【代码5】
	}
}

里面代码2错误：因为int转byte，由大转小，需要强制转换。同理代码3 long long 转 int ,代码3不能把浮点类型变量赋给整型变量，代码5需要有后缀 f ,否则就默认是double类型，需要进行强制转换。

Example2

public class E {
    public static void main(String args[]) {
        int[] a = { 10, 20, 30, 40 }, b[] = { { 1, 2 }, { 4, 5, 6, 7 } };
        b[0] = a;
        b[0][1] = b[1][3];
        System.out.println(b[0][3]);        //【代码1】
        System.out.println(a[1]);           //【代码2】
    }
}

先把 $b$ 数组填完，当前的 $b$ 数组是：
$\begin{matrix} 1&2&0&0\\ 4&5&6&7\\ \end{matrix}$
然后进行操作相当于把a的引用赋值给b[0] , 现在就变成了：
$\begin{matrix} 10&20&30&40\\ 4&5&6&7\\ \end{matrix}$
再进行一个赋值操作，就变成了：
$\begin{matrix} 10&7&30&40\\ 4&5&6&7\\ \end{matrix}$
这个时候输出b[0][3] 的值为30，同时a[1] 的值也变成了7，因为a中的值也被修改了，在于a的引用赋值给了b[0],那么b[0] 和 a 指向同一块内存地址，那么如果修改了b[0] 中的值，a的值也会跟着相应的改变。

Example3

btye取值范围-128至127
short取值范围-32768至32767
int取值范围-2147483648至2147483647
long取值范围-9223372036854775808至9223372036854775807
float取值范围1.4E-45至3.4028235E38
double取值范围4.9E-324至1.79769E308
char 类型是两个字节的，在unicode表是从0开始到65535，在java里面是没有unsigned类型的

第三章（运算符，表达式，语句）

在精度上 char 的精度比 short 高，当 (char) + （int）时，最后的结果答案应该为 (char) ，两个（char）类型相加可能会爆 (char) 类型，最后的答案可以用 (int) 来接收。
精度递增的话：（从低到高）
byte -> short -> char -> int -> long -> float -> double
Java在计算算术表达式的时候，遵守以下的规则：

如果表达式里面有 double，则按 double 进行运算。
如果表达式的最高精度是 float ,则按 float 进行运算。
如果表达式的最高精度是 long ,则按 long 进行运算。
如果表达式的最高精度低于int , 则按 int 进行运算。
Java允许把不超出byte, short , char 的取值范围的算术表达式赋给 byte ,short ,char

// 假设有“int x=1;”,以下哪个代码导致“可能损失精度，找到int需要char”的编译错误？

    A. short t=12+'a';
    B. char c='a'+1;
    C. char m='a'+x;
    D. byte n='a'+1;

这道题的答案应该选C 因为A选项97+12是可以赋给short类型的，D选项与A选项同理，可以赋给byte类型，B选项和C选项差的只有一个常数，B和C ，B对的原因在于1是数字常量。编译器编译的时候，会进行自动合并，不会做类型转换。在编译阶段就能完成。C错的原因在于，x是变量，在编译阶段无法合并，只能在运行的时编译，运行时发现x是整型，‘a’+x自动转换成整型，无法直接赋值给char类型，需要进行强制转换（char)(‘a’+x)

example1

package ad;
public class E {
    public static void main(String args[]) {
        char c = '\0';
        for (int i = 1; i <= 4; i++) {
            switch (i) {
            case 1:
                c = 'J';
                System.out.print(c);
            case 2:
                c = 'e';
                System.out.print(c);
                break;
            case 3:
                c = 'p';
                System.out.print(c);
            default:
                System.out.print("好");
            }
        }
    }
}

输出答案为：
在这里插入图片描述
switch语句如果某个case中没有break的话，就会一直执行后面case的相关语句，知道遇到break为止。

第四章（类与对象）

面向对象语言特点分为 1. 封装性 2. 继承 3. 多态
类是一种用于创建具体实例（对象）的数据类型、类体中主要由两部分构成：

变量的声明：用来存储属性的值（体现对象的属性）
方法的声明：方法可以对类中声明的变量进行操作，给出算法（体现对象所具有的行为）

声明变量部分所声明的变量被称为成员变量或域变量

成员变量包括基本类型：整型、浮点型、字符型、逻辑类型；还包括引用类型：数组、对象和接口
成员变量的默认值：java编译器会为其指定默认值。对于boolean变量，默认值是false；对于byte，short, int, long变量，默认值是0，对于float 和double 变量默认值是0.0；对于“引用型”变量（数组以及对象），默认值是null

方法的定义

局部变量只在方法内有效，而且与其声明的位置有关。方法的参数在整个方法内都有效，方法内的局部变量从声明它的位置开始有效。
区分成员变量和局部变量：成员变量和局部变量名字相同，成员变量被隐藏，即该成员变量在这个方法内失效，如果想使用隐藏的成员变量，必须使用关键字 this，局部变量没有默认值

class{
    int x=10;y;
    void f(){
        int x=5;
        y=x+this.x  //这样最后的答案是15
    }
}

类图的画法

第一层是：名字层 如果该名字是常规字形表明该类是具体类；如果类的名字是斜体字形表明该类是抽象类
第二层是：变量层列出类的成员变量及类型格式是变量名字：类型
第三层是：方法层列出类中的方法，格式是方法名字：类型

构造方法

类中的构造方法的名字必须和它所在的类的名字完全相同，而且没有类型。允许一个类中编写若干个构造方法，但必须保证它们的参数不同，参数不同是指参数的个数不同，或参数的个数相同，但对应列表中的某个参数类型不同。
若类中没有编写构造方法，系统会默认该类只有一个构造方法，该默认的构造方法是无参数的，且方法体里面没有语句。

创建对象

如果在类中定义了一个或多个构造方法，那么java不提供默认的构造方法

class Dog{
    Dog(int m){
    }
    Dog(double m){
    }
    int Dog(int m){
        return 23;
    }
    void Dog(double m){
    }
}
public class Example {
    public static void main(String args[]){
       Dog p1,p2;
       p1=new Dog(10);
       p2=new Dog(10.0);
    }
}
//这里再用系统给默认方法是非法的  p1 = new Dog();

对象的引用和实体

一个类声明的两个对象如果具有相同的引用，两者就具有相同的引用，两者就具有完全相同的变量。且java里面存在垃圾收集机制，这种机制周期的检测某个实体是否已不在被任何对象所拥有，如发现，则释放实体占用的内存。
引用

方法重载

方法重载要求方法名相同，参数列表不同，可以是参数个数或者类型不同。构造方法也可以是重载的

类声明

类声明只能有public和友好类进行声明

protect 允许在同一个包中或者是子类调用
私有变量，私有方法不能直接使用对象调用

第五章（子类与继承）

子类与继承

如果子类和父类在同一个包里，那么子类继承其父类中不是private的成员变量作为自己的成员变量，并且也自然地继承了父类中不是private的方法不是private的方法，继承的成员变量和方法的访问权限保持不变。
当子类和父类不在同一个包里时，父类中的private和友好访问权限的成员变量不会被子类继承，也就是说，子类只继承父类的protected和public访问权限的成员变量作为子类的成员变量，同理方法一样。

方法重写需满足

父类中的方法和子类中的方法
方法名必须一致
方法参数必须一致
子类的方法的访问修饰符不能缩小访问权限
返回值类型要一致

成员变量的隐藏和方法重写

声明的成员变量的名字和从父类继承来的成员变量的名字相同（声明的类型可以不同），在这种情况下子类就会隐藏所继承类来的成员变量。
方法重写，子类一旦重写了父类的方法f(),就隐藏了继承的继承的方法f(),那么子类对象调用方法f()调用的一定是重写方法。如果子类想使用被隐藏的成员变量或方法，必须使用关键词super
如果子类隐藏了继承的成员变量m,那么子类继承的方法中操作的m,是被子类隐藏的m,而子类新增或重写的方法中操作的m一定是子类新声明的成员变量m。
重写的语法规则重写的方法的名字，参数个数，参数的类型和父类的方法完全相同。
在重写父类的方法时，不允许降低方法的访问权限，但可以提高访问权限。

用super操作被隐藏的成员变量和方法

如果在子类中使用被子类隐藏的成员变量或方法，就需要使用关键词super 。例如super.x 、super.play() 就是访问和调用的被子类隐藏的成员变量 x 和方法 play() 。
使用super调用父类的构造方法，由于子类不继承父类的构造方法，所以子类在其构造方法中需使用super来调用父类的构造方法。

上转型对象

上转型对象不能使用子类新增成员(包括成员变量,成员方法),只能使用子类重写父类的方法,被子类隐藏的父类变量;子类未重写的父类方法,未被隐藏的父类成员变量.

abstract类

使用关键词abstract修饰的类被称为abstract类（抽象类）
用关键词abstract修饰的方法称为abstract方法（抽象方法）
只有abstract类才可以有abstract方法，也可以拥有非abstract方法，只有abstract类不能用new标识符创建对象，且abstract的对象可以为上转型对象
private :因为一个abstract方法需要被重写，所以不能修饰为private
final:因为一个abstract方法需要被重写。被final修饰的方法是不能被重写的，所以不能同final共存
static:因为一个abstract方法没有方法体。静态方法需要对方法体执行内容分配空间，所以不能同static共存；（abstract是没有实现的，不能产生对象，而是static是属于类的，类本身是已经存在的对象）

class A{
    int m;
    int getM(){
        return m;
    }
    int seeM(){
        return m;
    }
}
class B extends A{
    int m;
    int getM(){
        return m+100;
    }
}
public class E{
public static void main(String args[]){
    B b = new B();
    b.m = 20;
    System.out.println(b.getM());//【代码1】
    A a = b;
    a.m = -100;        //上转型对象访问的是被隐藏的m
    System.out.println(a.getM());//【代码2】上转型对象调用的一定是子类重写的getM()方法
    System.out.println(b.seeM());//【代码3】子类继承的seeM()方法操作的m是被子类隐藏的m
    }
}

上转型对象访问的是被隐藏的成员变量调用的是子类重写的方法

Java
class A{
double f(double x,double y){
    return x+y;
}
    static int g(int n){
        return n*n;
    }
}
class B extends A{
    double f(double x,double y){
        double m = super.f(x,y);
        return m+x*y;
    }
    static int g(int n ){
        int m = A.g(n);
        return m+n;
    }
}
public class E{
    public static void main(String args[]){
        B b = new B();
        System.out.println(b.f(10.0,8.0));    //【代码1】
        System.out.println(b.g(3));    //【代码2】
        A a = new B();
        System.out.println(a.f(10.0,8.0));    //【代码3】
        System.out.println(a.g(3));    //【代码4】
    }
}

【代码1】调用b对象的f方法，b对象是B类实例化的，调用的是B类自己的f方法，传入10.0和8.0后，用super关键字调用了父类的f方法，得到18.0赋值给m，最后返回18.0+10.0*8.0也就是98.0。
【代码2】调用B类中的静态方法g传入3，方法内又去调用父类中的g方法传入3，得到9赋值给m后，输出9+3也就是12。
【代码3】a对象是上转型对象，上转型对象可以调用重写父类的方法以及父类派生的方法，所以a调用的f方法是它重写的方法，那么具体过程就跟【代码1】相同，答案为98.0
【代码4】在于g方法是静态方法，静态方法是不允许被重写的，所以B类中的g方法相当于该类特有的方法，那么a调用的g方法实际上是父类的，输出结果为9 。

第六章（接口与实现）

接口的意义

使 java 程序间接实现了多继承
接口更加直接的设计了整个程序的结构，方便程序的扩展和维护
程序的设计人员可以通过面向接口编程减少设计工作的复杂度
接口代表一种能力，实现接口的同时就代表这个类型的对象拥有了这种能力

接口的语法规则

接口中所有属性都是：共有静态常量 public，会默认加上public static final 修饰
接口中所有方法都是：共有抽象方法 public
接口中不允许有构造方法
接口不能实例化
只有default方法和static方法可以添加方法体
实现接口的类如果不能实现所有接口中待重写的方法，则必须设置为抽象类
接口可以实现多继承，即一个子接口可以同时继承多个父接口
一个类可以继承自一个父类，同时实现多个接口
当一个类同时实现多接口，且其中同时具有相同方法时，实现类需要重写该方法，否则会编译报错
接口中的抽象方法默认是public类，那么类在重写接口方法时不仅要去掉abstract修饰符，给出方法体，而且方法的访问权限一定要明显地用public来修饰（不能降低访问权限）

面向接口编程

使用接口进行程序设计的核心思想是使用接口回调，即接口变量存放实现该接口的类的对象的引用，从而接口变量就可以回调类实现的接口方法

第七章（异常类）

异常类就是程序运行时可能出现的一些错误，Exception是所有异常的父类，Java使用throw关键词抛出一个Exception子类的实例表示异常发生

java.lang包中的Integer类调用其类方法可以将“数字”格式的字符串，如“6789”，转化成int类型，但是试图将字符串“ab89”转化成数字时，方法parseInt()在执行过程中就会抛出NumberFormatException对象，及程序运行出现NumberFormatException异常
java允许定义方法时声明该方法调用过程的可能出现的异常，即允许方法调用过程中抛出异常对象，终止当前方法的继续执行。

try-catch语句

try{
   包含可能发生异常的语句
}
catch(ExceptionSubClass1 e){
   ...
}
catch(ExceptionSubClass2 e){
   ...
}

Java使用try-catch语句来处理异常，将可能出现的异常操作放在try-catch语句的try部分，一旦try部分抛出异常对象，或调用某个可能抛出异常对象的方法，并且该方法抛出了异常对象，那么try部分将立刻结束执行，转向执行相应的catch部分。所以程序可以将发生异常后的处理放在catch部分。try-catch语句可以由几个catch组成，分别处理发生的相应异常。
各个catch参数中的异常类都是Exception的某个子类，表明try部分可能发生的异常，这些子类之间不能有父子关系，否则保留一个含有父类参数的catch即可
自定义异常类
在编写程序时可以拓展Exception类定义自己的异常类
一个方法在声明时可以使用throws关键词声明要产生的若干个异常
使用throw关键词抛出该异常对象，至该方法结束

import java.io.IOException;

public class E {
    public static void main(String args[]) {
        try {
            methodA();
        } catch (IOException e) {
            System.out.println("你好");
            return;
        } finally {
            System.out.println("fine thanks");
        }
    }

    public static void methodA() throws IOException {
        throw new IOException();
    }
}

答案：你好
fine thanks
一个方法在声明时可以使用throws关键字声明要产生的若干个异常，并在该方法的方法体中具体给出产生异常的操作，即用相应的异常类创建对象，并使用throw关键字抛出异常对象，导致该方法结束执行。try-catch语句捕获到这个异常，输出你好。
在执行try-catch语句后，执行finally子语句，也就是说，无论在try部分是否发生过异常，finally子语句都会被执行。
如果在try-catch语句中执行了return语句，那么finally子语句依然会被执行，
try-catch语句中执行了程序退出代码，即执行System.exit(0);,则不执行finally子语句。

第八章（常用实用类）

String类

String 类在java.lang包中，由于java.lang包中的类被默认引入，java把String 类定义为 final 类，因此用户不能拓展String 类，即String 类不可以有子类
String 对象可以用“+”进行并置运算，即首尾相接得到一个新的String 对象
length()方法用来获取一个String对象的字符序列的长度
equals(string s)方法比较当前 String 对象的字符序列是否参数s指定的String 对象的字符序列相同，一样的话返回true
startWith(String s),endWith(String s),判断当前字符序列前缀是否是参数指定的String 对象s的字符序列
compareTo(String s)相同返回0，当前String对象的字符序列与s的相同，返回0，如果大于s的字符序列，该方法返回正值，不然返回-1
contains(String s)方法判断当前String对象的字符序列是否包含参数s的字符序列
indexOf(String s)找到首次检测到出现str的字符序列的位置，并返回该位置，没有检索到返回-1
substring(int startpoint)复制当前String 对象的字符序列中的startpoint位置到最后位置上的字符所得到的字符序列。
如果是substring(int start ,int end)的方法获得一个新的对象，新的String 对象的字符序列从start到end-1的位置上的字符
trim()这样是去掉前后空格的字符序列
字符串与基本数据的相互转换 int x=parseInt(s);string s=valueOf(int m);

StringTokenizer类

StringTokenizer（String s):为String对象s构造一个分析器。使用默认的分隔符标记，即换行符，回车符，tab符，空格符，进纸符做分隔标记
StringTokenizer(String s,String delim)：为String对象s构造一个分析器。参数delim的字符序列中的字符的任意排列作为分隔标记