JAVA阶段考内容知识点的梳理
前言：这些都是很基本的，还有很多没有写出来，重点在于编程序理解。
目录
第一章概述
课堂总结
相关习题
第二章：语言基础
课堂总结
相关习题
第三章：类和对象
内容总结
相关习题
第四章：类的派生与继承
内容总结
相关练习
第五章：抽象类和接口
内容总结
相关练习
程序填空及读程序
第一章概述
课堂总结
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. (单选题, 20分)下列Java命令中,哪一个可以编译HelloWorld.java文件(D )
- A. java HelloWorld
- B. java HelloWorld.java
- C. javac HelloWorld
- D. javac HelloWorld.java
答案解析：javac命令用于编译.java文件;java命令用户解析.class文件
2. (单选题, 20分)下列关于Java特点的描述中,错误的是(C )
- A. Java语言不支持指针
- B. Java具有自动垃圾回收的机制
- C. Java只能运行在Window和Linux平台
- D. Java允许多个线程同时执行
答案解析：JAVA是一门面向对象的语言,它没有指针的概念,并提供了自动垃圾回收的机制,具有跨平台,多线程等特点。
3. (判断题, 20分)使用“public class 类名称”声明一个类时,类名称必须与文件名称一致,否则程序将无法编译。
- A. 对
- B. 错
答案解析：在Java中，只有当类是公共类时，类名称才必须与文件名称相同。如果类不是公共类，则类名称可以与文件名称不同。
4.Java源码文件位置(A)
- A. 必须在其声明的包所在目录下
- B. 可以不在其声明的包所在目录下但必须说明
- C. 可以在任意目录
- D. 所有源码文件必须置于同一级目录下
答案解析：Java源码文件位置应该在其声明的包所在目录下，即源码文件应该放在包名所对应的目录下，例如，包名为com.example，则源码文件应该放在com/example/目录下1
第二章：语言基础
课堂总结
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. (单选题, 4.5分)下列哪一项叙述是正确的(B)
- A. char型字符在Unicode表中的位置范围是0至32767
- B. char型字符在Unicode表中的位置范围是0至65535
- C. char型字符在Unicode表中的位置范围是0至65536
- D. char型字符在Unicode表中的位置范围是-32768至32767
答案解析：char型字符在Unicode表中的位置范围是0至65535。char类型是一个16位无符号整数，它的取值范围是0到65535。
2. (单选题, 4.5分)将有三个boolean值的数组初始化为true的是(B )
- A. boolean []b=new boolean[3]
- B. boolean []b={true,true,true}
- C. boolean [3]b={true,true,true}
- D. boolean []b=new boolean[3]; b={true,true,true}
3. (单选题, 4.5分)以下的变量定义中,合法的语句是(B )
- A. float 1_variable=3.4;
- B. int abc_=21;
- C. double a=1+4e2.5;
- D. short do=15;
答案解析： int abc_=21; 是合法的语句。变量名称可以包含字母、数字和下划线，但不能以数字开头。因此，选项A中的变量名称是非法的。选项C中的表达式“1+4e2.5”是非法的，因为指数必须是整数。选项D中的变量名称“do”是Java中的保留字，不能用作变量名称。
4. (单选题, 4.5分)现有1个char类型的变量c1=66和1个整型变量i=2,当执行c1=c1+(char)i;语句后,c1的值为(D)
- A. 'd'
- B. 'D'
- C. 68
- D. 语句在编译时出错
答案解析：在Java中，char类型的变量c1=66，而整型变量i=2。当执行c1=c1+(char)i;语句后，c1的值为68。因为两个字符型的数据相加，得到的是一个整数，而如果把整数再赋值给一个字符型变量则会在编译时出错
5. (判断题, 5分)在Java中所实现的二维数组,实际上是由一维数组构成的数组
- A. 对
- B. 错
答案解析：Java中的二维数组是由一维数组构成的数组，即二维数组为一个特殊的一维数组，其每个元素又是一个一维数组12。Java并不直接支持二维数组，但是允许定义数组元素是一维数组的一维数组，以达到同样的效果
5. (单选题)package，包应声明在(C)
- A. import语句下部，类的上部
- B. 可以声明在除类内部的任意位置
- C. 在代码的最顶部
- D. 类的内部
答案解析：Java中，package应该声明在源文件的第一行，而且每个源文件中只能有一个包定义语句，适用于所有类型（类、接口、枚举和注释）的文件
6. (判断题)变量与常量在声明时都必须显式初始化
- A. 对
- B. 错
答案解析：变量与常量在声明时都必须显式初始化，这个说法是错误的。变量在声明时可以不进行初始化，但是未初始化的变量在使用前必须进行初始化
7. (判断题)switch语句中，若传入的参数没有匹配的case分支将引发程序异常
- A. 对
- B. 错
答案解析：在switch语句中，如果传入的参数没有匹配的case分支，程序会执行default子句（如果有），否则程序会继续执行switch语句后面的语句
第三章：类和对象
内容总结
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）加载并初始化一个类及其父类时，它会按照以下顺序执行：
父类的静态变量和静态代码块按照在代码中出现的顺序依次执行。
子类的静态变量和静态代码块按照在代码中出现的顺序依次执行。
父类的成员变量和非静态代码块按照在代码中出现的顺序依次执行。
父类的构造函数执行。
子类的成员变量和非静态代码块按照在代码中出现的顺序依次执行。
子类的构造函数执行。
相关练习
1.下列叙述中,正确的是?（C）
- A. 子类继承父类的所有属性和方法
- B. 子类可以继承父类的私有的属性和方法
- C. 子类可以继承父类的公有的属性和方法
- D. 创建子类对象时,父类的构造方法都要被执行
子类可以继承父类的公有属性和方法，但不能继承私有属性和方法。创建子类对象时，父类的构造方法也会被执行。
2.关于继承下面说法正确的是（C）
- A. 子类能够继承父类私有的属性;
- B. 子类可以重写父类的final方法;
- C. 子类能够继承不同包父类的protected属性;
- D. 子类能够继承不同包父类的缺省属性;
正确的叙述是 C。子类不能继承父类的私有属性，也不能重写父类的 final 方法。子类能够继承不同包父类的 protected 属性，但不能继承不同包父类的缺省属性。
3.如果子类中的某个变量的变量名与它的父类中的某个变量完全一样,则称子类中的这个变量____了父类的同名变量
正确答案：
(1) 隐藏;覆盖
4.如果子类中的方法mymethod()覆盖了父类中的方法mymethod(),假设父类方法头部定义如下:void mymethod(int a),则子类方法的定义不合法的是:（C）
- A. public void mymethod(int a)
- B. protected void mymethod(int a)
- C. private void mymethod(int a)
- D. void mymethod(int a)
在Java中，子类可以覆盖父类中的方法，但是子类中的方法必须满足一些条件。子类中的方法访问修饰符的可见性不能低于父类中的方法。因此，选项C是不合法的，因为它将方法的可见性从父类的默认可见性降低到了private。
因此，选项C是不合法的，因为它将方法的可见性从父类的默认可见性降低到了private。
5.下列关于对象类型转换的说法中正确的是:（B）
- A. 某类的对象引用只能指向它的直接子类的对象。
- B. 不存在祖先与后代关系的两个类的对象之间一定不能进行类型转换。
- C. 后代类的对象引用能指向其祖先类的对象。
- D. 对象类型转换只有强制转换而没有自动转换
正确的选项是B。在Java中，如果两个类之间不存在继承关系，那么它们的对象之间不能进行类型转换。选项A不正确，因为一个类的对象引用可以指向它的任何子类的对象，不仅仅是直接子类。选项C不正确，因为后代类的对象引用不能指向其祖先类的对象。选项D不正确，因为对象类型转换既有自动转换也有强制转换。
6.关于继承，下列叙述错误的是（C）
- A.
子类无法继承父类的私有成员
- B.
子类无法继承不同包父类的缺省package级成员
- C. 子类可以重写父类构造函数
- D. 子类可以继承父类protected级成员
子类不能重写父类的构造函数，但是可以通过super()调用父类的构造函数。
7.关于final，下列叙述错误的是
- A. 修饰的类无法创建对象
- B. 修饰的方法无法被重写
- C. 修饰的变量无法被修改
- D. 无法修饰接口
final修饰的类可以创建对象，但是无法被继承。
8.子类对象的引用可以直接赋值给超类变量
- A. 对
- B. 错
子类对象的引用可以直接赋值给超类变量，这种情况下，超类变量只能访问子类对象中超类部分的成员。
9.子类对象的引用可以直接赋值给另一子类变量
- A. 对
- B. 错
子类对象的引用不能直接赋值给另一子类变量，除非两个子类之间存在继承关系。
10.超类对象的引用可以直接赋值给子类变量
- A. 对
- B. 错
超类对象的引用不能直接赋值给子类变量，除非通过强制类型转换。
第五章：抽象类和接口
内容总结
抽象类：
- 用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.关于接口，下列叙述错误的是（C）
- A.
可以被继承
- B.
可以只声明常量，而不声明任何方法
- C. 可以声明私有常量
- D. 可以声明静态方法
C. 可以声明私有常量。接口中的常量默认为 public static final，不能声明为私有。
2.以下正确在接口中声明常量的是（D）
- A. public interface Clickable {
public abstract int NUM = 10;
} - B. public interface Clickable {
public static abstract int NUM = 10;
} - C. public interface Clickable {
public final NUM = 10;
} - D. public interface Clickable {
int NUM = 10;
}
接口中的常量默认为 public static final，因此可以省略这些修饰符。
3.一个接口可以有多个实现类
- A. 对
- B. 错
一个接口可以有多个实现类
4.一个类可以实现多个接口
- A. 对
- B. 错
5.接口中可以声明变量
- A. 对
- B. 错
接口中不能声明变量，只能声明常量
程序填空及读程序
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();
}
}