前言：这些都是很基本的，还有很多没有写出来，重点在于编程序理解。

第一章概述

课堂总结

相关习题

第二章：语言基础

课堂总结

相关习题

第三章：类和对象

内容总结

相关习题

第四章：类的派生与继承

内容总结

第一章概述

课堂总结

1.它的源代码的运行机制：java语言的特点：

特点一：面向对象

        两个基本概念：类、对象

        三大特性：封装、继承、多态

特点二：健壮性
特点三：跨平台性（平台无关性）
特点四：简单  自动的垃圾回收机制
其他：多线程、动态性

2.它的源代码的运行机制：

3.java生成的字节码文件不依赖于平台，原因就在于JRE，他为一个java程序创建了一个独立的JVM容器运行程序；Java语言通过在不同架构系统上安装对应的JRE，实现Java程序的跨平台运行(一次编译，处处运行)

4.JDK编译java源码为字节；JRE，Java运行时环境；JVM，java虚拟机；

JDK(JavaDevelopment Kit )，免费开源的Java应用开发工具包；JDK编译java源码为字节码(bytecode)JRE，Java运行时环境，包含工具库类(提供对线程，时间，文件，网络等的操作) ，核心运行文件；

JRE为每一个Java程序创建一个独立的JVM容器运行程序

JVM，Java虚拟机，模拟了包括CPU指令集，寄存器，堆栈等计算机架构，通过调用真实计算机环境，解析执行Java字节

5.通过JDK的编译工具（javaac.exe）将java源码（.java）编译为JVM可执行的字节码（.class）

第二章：语言基础

课堂总结

1.定义：用来标识类名、变量名、方法名、类型名、数组名等等

规定：

标识符有字母、下划线、美元符号和数字组成，长度不受限制
标识符的第一个字符不能是数字字符
标识符不能是关键字
禁止以`$`/`_`为前缀声明变量。后期框架通过反射等操作自动生成的变量可能包含`$`/`_`前缀，避免冲突。

2.在Java中“引用”是指向一个对象在内存中的位置，在本质上是一种带有很强的完整性和安全性的限制的指针

3.Java的数据类型

注意：

java的整型常量默认为int型，声明long型常量须加L"
float常量后面必须要有后缀“f”或“F”

布尔型注意与C/C++不同，无法与零/非零数替换

所有基本类型变量不与其他变量共享值，基本数据类型为值传递，而非引用传递。因此当被"引用"的值改变时，不会影响"引用"其值的变量

4. 转换规则

5.数组

创建数组时必须同时确定数组的长度

多维数组在使用new运算符的时候，至少要给出最高维的大小；

6.在计算算术表达式的值时：

a.按最高精度进行运算；

b.如果表达式的最高精度低于int，则按int进行运算；

c.char型数据的运算结果的精度为int；

7.instanceof 运算符

在Java中，instanceof是一个二元运算符，用于检查一个对象是否是某个类或其子类的实例。instanceof运算符返回一个布尔值，如果对象是该类或其子类的实例，则返回true，否则返回false。

8.

break和continue
再循环体中可以使用break语句和continue语句
如果在某次循环中执行了break语句，那么整个循环语句就结束；
如果在某次循环中执行了continue语句那么本次循环就结束，转而进行下一次循环

第三章：类和对象

内容总结

1.类的构成

变量（属性）

方法（功能行为）

2.类（class）和对象（object）是面向对象的核心概念；

将抽象得到的属性和方法相结合，形成一个整体抽象的数据类型叫类

对象是实际存在的该类事物的个体，因而也称实例；

3.构造方法：

它的名字必须与它所在的类的名字完全相同
不返回任何数据类型，即它是void型，但void必须省略不写
允许一个类中有若干个构造方法，但这些构造方法的参数必须不同，即或者是参数的个数不同，或者是参数的类型不同。
如果用户在一个定义类中未定义构造方法，系统将为它定义一个缺省的空构造方法。如果用户自己定义构造方法，系统就不再提供默认的

4.面向对象的三个特性 封装继承多态

5.成员变量和类变量：
类变量用static修饰，类变量是和该类所创建的所有对象相关联的变量，因此类变量可以通过对象和类名访问；
实例变量仅仅是和相应的对象关联的变量，不同对象的实例变量互不相同，即分配不同的内存空间，其必须通过对象来访问；

6.实例方法和类方法：
实例方法可以操作实例变量和类变量，但实例方法必须用对象来调用；
类方法不能操作实例变量，可以通过对象和类名来调用；

7.this关键字：
使用this指的就是当前对象；
类方法中不可以使用this；
this区分局部变量和成员变量，若成员变量和局部变量名字相同，如果想在该方法中使用成员变量加this；

8.访问权限：

9.static代码块和构造代码块：

static代码块：使用static关键字声明的代码块，在JVM加载类时执行，且每个静态代码块只执行一次。

构造代码块：直接在类中定义且没有加static关键字的代码块。构造代码块在创建对象时被调用，每次创建对象都会被调用，且构造代码块的执行次序优先于类构造方法。

10.方法签名（Method Signature）是指方法的名称和参数列表(方法参数数量，相应位置的参数类型)。它用于唯一标识一个方法。方法签名不包括方法的返回类型和访问修饰符。

11.getter/setter方法

12.在Java中，子类继承父类，子类创建对象时，执行顺序如下： ①父类静态代码块>>②子类静态代码块>>③父类非静态代码块>>④父类构造函数>>⑤子类非静态代码块>>⑥子类构造函数。总结: 父类早于子类，静态早于非静态，非静态早于构造函数，父类非静态和构造函数早于子类非静态和构造函数

相关习题

1.类Test1定义如下 public class Test1{ public float aMethod(float a,float b){ } ( ) } 将以下哪种方法插入( )是不合法的。（B）

A. public float aMethod(float a, float b,float c){ }
B. public float aMethod(float c,float d){ }
C. public int aMethod(int a, int b){ }
D. public int aMethod(int a,int b,int c){ }

这是一个关于Java方法重载的问题。在Java中，方法重载允许在同一个类中定义多个具有相同名称但参数列表不同的方法。因此，选项A、C和D都是合法的，因为它们都有与原方法不同的参数列表。但是选项B不合法，因为它与原方法具有相同的参数类型和数量，只是参数名称不同，这并不能构成重载。所以正确答案是B。

2.实例变量的作用域整个的（C）

A. 语句块
B. 方法
C. 类
D. 以上答案都不对

实例变量的作用域是整个类。实例变量是定义在类中，方法外的变量，它属于该类的每一个对象。这意味着，当你创建一个类的对象时，每个对象都会有自己的实例变量副本。因此，正确答案是C。

3.给出下列代码,如何使成员变量m 被方法fun( )直接访问。class Test { private int m; public static void fun() { ... } } （C）

A. 将private int m 改为protected int m
B. 将private int m 改为 public int m
C. 将private int m 改为 static int m
D. 将private int m 改为 int m

在这个例子中，要使成员变量m能够被静态方法fun()直接访问，需要将m声明为静态变量。静态方法只能访问静态成员变量，因为静态方法在没有创建类的实例时就可以被调用。因此，正确答案是C。

4.关于类的定义以下说法错误（B）

A. 类定义使用class关键字
B. 每个类中必须有一个main方法
C. 一个包可以包含多个类
D. java中所有类都是Object类的子类

关于类的定义，选项B是错误的。在Java中，一个类并不一定要有一个main方法。main方法是Java程序的入口点，它只需要在程序的启动类中定义即可。其他类可以没有main方法。

选项A、C和D都是正确的。类定义使用class关键字[A]；一个包可以包含多个类[C]；Java中所有类都是Object类的子类[D]。

5.下列程序运行的结果是(C)。

public class A{
    int z=20;

    static void f(int y){
        y=z;
        System.out.println(y);
    }

    public static void main(String args[]){
        f(10);
    }
}

A. 10
B. 20
C. 程序编译错误
D. 以上都不对

这段程序会编译错误，因此正确答案是C。

错误发生在方法f中的语句y=z;。在静态方法中，不能直接访问非静态成员变量。在这里，z是一个非静态成员变量，而方法f是一个静态方法，因此不能在方法f中直接访问变量z。

6.下列代码的运行结果是(D)。

public class J_Test{
    static short m_index;
    static int m_age;

    public static void mb_setData(long n){
        m_index = n;
    }

    public static void main(String args[]){
        mb_setData(98);
        System.out.println("Index=" + m_index + ";Age="+m_age);
    }
}

A. Index = 98 ;Age=0
B. Index = 0 ;Age=0
C. Index = 0;Age=98
D. 以上都不对

错误发生在方法mb_setData中的语句m_index = n;。在这里，m_index是一个short类型的变量，而n是一个long类型的变量。由于long类型的数据范围比short类型更大，因此不能直接将一个long类型的值赋给一个short类型的变量，需要进行强制类型转换。正确的写法应该是：m_index = (short)n;

7.当重写了带参数的构造方法,系统默认的不带参数的构造方法依然存在

A. 对
B. 错

8.类变量在该类被加载时被创建,不能用new Xxxx()创建,所有该类的实例对象共享类变量,其生存期是类的生存期。

A. 对
B. 错

类变量（也称为静态变量）是在类被加载时创建的，它不需要使用new关键字来创建。所有该类的实例对象都共享同一个类变量，它的生存期与类的生存期相同。

9.在同一个类的不同构造方法中调用该类的其它构造方法需要使用this(…)的形式,this(…)不能在构造方法的第一行调用。

A. 对
B. 错

在Java中，可以在一个构造方法中使用this(...)的形式来调用该类的其他构造方法。但是，this(...)必须出现在构造方法的第一行，否则会编译错误

10.类及其属性、方法可以同时有一个以上的修饰符来修饰。

A. 对

B. 错

在Java中，类及其属性和方法可以同时使用多个修饰符来修饰。例如，一个方法可以同时被public和static修饰符修饰，表示这个方法是公开的静态方法。

11.package语句必须放到java程序的最开始

A. 对
B. 错

在Java中，如果一个类属于某个包，那么package语句必须放在源文件的最开始。package语句用来指定类所属的包。它必须是源文件中的第一条非注释语句。

12.一个类的非静态方法可以访问静态成员变量,一个类的静态方法不可以访问该类的非静态成员变量。

A. 对
B. 错

在Java中，一个类的非静态方法可以访问静态成员变量，因为静态成员变量属于类，而不属于某个特定的实例。但是，一个类的静态方法不能直接访问该类的非静态成员变量，因为静态方法在没有创建类的实例时就可以被调用，而非静态成员变量属于类的实例。

13.允许在构造函数中调用另一构造函数，但调用语句必须声明在第一行执行

A. 对
B. 错

在Java中，可以在一个构造方法中使用this(...)的形式来调用该类的其他构造方法。但是，this(...)必须出现在构造方法的第一行，否则会编译错误。

14.默认package-private级的类，无法在上级包中被访问调用，但可以在同级及其子包内访问

A. 对
B. 错

在Java中，如果一个类没有指定访问修饰符，那么它的访问级别是包级别的（也称为包私有）。这意味着，这个类只能在同一个包中的其他类中访问，不能在其他包中访问。它不能在上级包、同级包或子包中访问。

15.(单选题)下列程序运行的结果是（D）

public class Test {
    private int i = 20;
    static void fuc(int i) {
        this.i = i * 2;
        System.out.println(this.i);
    }
    public static void main(String[] args) {
        fuc(10);
    }
}

A. 10
B. 20
C. 40
D. 无法编译

这段代码无法编译，因为在静态方法fuc中使用了this关键字。this关键字只能在非静态方法中使用，它表示当前对象的引用。静态方法不属于任何对象，因此不能使用this关键字。

16.以下代码的输出结果（C）

public class Test {
    private static int j = 20;
    public void fuc(int x) {
        x = x * 2;
        j = j * 2;
    }
    public static void main(String[] args) {
        int i = 10;
        Test t = new Test();
        t.fuc(i);
        System.out.println(i + " and " +j);
    }
}

A. 20 and 40
B. 20 and 20
C. 10 and 40
D. 无法编译

这段代码可以编译并运行。在main方法中，变量i的初始值为10，然后调用了t.fuc(i)方法。在fuc方法中，参数x的值被修改为20，但是这并不影响main方法中的变量i的值，因为Java中的参数传递是值传递。在fuc方法中，静态变量j的值被修改为40。因此，最后输出的结果是“10 and 40”。

第四章：类的派生与继承

内容总结

继承的概念

Java的继承具有层次结构，支持多层继承；但不支持多继承，就是一个子类只能有一个直接父类

Java语言中所有类的根类是：Object；

如果在子类中未显式调用父类构造方法，则编译器会自动调用父类的不带参数的构造方法

成员变量的隐藏：子类中定义和父类中同名的变量

注意的是，尽管子类可以隐藏从父类继承来的成员变量，但是子类仍然可以使用从父类继承的方法操作被隐藏的成员变量

成员方法的重写：

两同：方法名相同参数列表一致

两小：子类返回值类型应该更小或者相等；子类的抛出的异常小于等于父类的抛出的异常类

一大：子类的访问权限比父类访问权限要大和相等

注意和方法的重载区分。

类变量能够被继承和隐藏；类方法不能被重写，可以被重新定义。

super：表示当前对象最近的一个父类对象

super.属性名称；访问父类的成员变量

super.方法名称()；访问父类的成员方法

调用父类的构造方法：

只能在子类的构造方法中。

必须在方法的第一句。

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

final：

修饰基本数据类型变量，为常量，值不可变；

修饰引用数据类变量，引用不变，引用对象的值可变；

修饰方法，方法不可重写；

修饰类，无子类，不可以被继承。

引用成员之间的转换：

向上转型：子类转换成父类由小到大类似基本数据类型的自动类型转换

向下转型：父类转换成子类由大到小类似基本数据类型的强制类型转换

多态的前提条件：1、子类继承父类 2、子类重写父类方法、 3、父类引用指向子类对象多态的

类加载实例化过程

当Java虚拟机（JVM）加载并初始化一个类及其父类时，它会按照以下顺序执行：

父类的静态变量和静态代码块按照在代码中出现的顺序依次执行。
子类的静态变量和静态代码块按照在代码中出现的顺序依次执行。
父类的成员变量和非静态代码块按照在代码中出现的顺序依次执行。
父类的构造函数执行。
子类的成员变量和非静态代码块按照在代码中出现的顺序依次执行。
子类的构造函数执行。

第五章：抽象类和接口

内容总结

抽象类：

用abstract修饰的类；
不能用new创建该类对象，只能先创建子类
可以声明对象，作为子类的上转型对象；
抽象方法不可用static,final,private修饰；
抽象类中可以有抽象方法，也可以没有，含有抽象方法的类一定是抽象类

抽象类在Java中有以下特点：

1.不能被实例化：抽象类只能被继承，不能直接创建实例对象。

2.可以包含抽象方法：抽象类可以包含抽象方法，抽象方法没有具体实现，需要在子类中实现。

3.可以包含非抽象方法，可以包含静态方法

可以包含静态变量和实例变量

可以实现接口：抽

4.子类必须实现抽象方法：如果一个类继承了抽象类，那么它必须实现所有抽象方法，注意:抽象类的子类也可以是抽象类，子类是抽象类时不必实现抽象超类的所有抽象方法。

匿名类

匿名类（也称为匿名内部类）是一种特殊的内部类，它没有名称。它通常用于创建一个只需要使用一次的类，比如在实现接口或继承抽象类时。适合于仅声明使用一次的不会被复用的类

接口：

用Interface来定义一个接口；
接口中的变量自动都是public static final;
接口中的方法自动为public abstract;
实现接口一个类可以通过implements声明自己
接口回调

接口中没有构造方法，也就不能通过new来构建对象，只能像抽象类一样去标示数据类型。

接口也具有继承性；

在Java中有以下特点：

接口定义抽象出重要的行为标准，该行为标准用抽象方法来表示。接口中只有常量和抽象方法。

接口中的变量自动都是public static final；

接口中的方法自动为public abstract；

程序填空及读程序

1.以下程序要求从键盘输入一个整数，判别该整数为几位数，并输出结果，请将下面的程序填写完整。

import java.io.IOException;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        int count = 0, t;
        int x = sc.nextInt();
        sc.close();
        t = x;
        while (t != 0) {
            count++;
            t /= 10;
        }
        System.out.println(x + "是" + count + "位数。");
    }
}

2.构造一个类来描述一个点，该类的构成包括点的x和y两个坐标，以及一些对点进行的操作，包括：取得点的坐标值，利用另一个点对当前点的坐标进行赋值，请将下面的程序填写完整。

class Point {
    int x, y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public Point getPoint() {
        Point temp = new Point(0, 0);
        temp.x = x;
        temp.y = y;
        return temp;
    }

    public void setPoint(Point s) {
        this.x = s.x;
        this.y = s.y;
    }
}

3.在父类中定义了printA()方法，输出"A"，子类中覆盖printA()方法输出"AA"

class Father {
    public void printA() {
        System.out.println("A");
    }
}

class Child extends Father {
    public void printA() {
        System.out.println("AA");
    }
}

4.定义一个接口A，类B实现接口A，完成程序填空。

public interface A {
    void a();
}

class B implements A {
    public void a() {
    }

    public static void main(String[] args) {
        A b = new B();
        b.a();
    }
}