【JavaSE】类和对象（下）
类和对象（下）
-
- 7. static成员
-
- 7.1 再谈学生类
- 7.2 static修饰的成员变量
-
- 7.2.1 静态成员变量的访问
- 7.3 static修饰成员方法
- 7.4 static成员变量初始化
- 8. 代码块
-
- 8.1 代码块概念以及分类
- 8.2 普通代码块
- 8.3 构造代码块
- 8.4 静态代码块
- 9. 内部类
-
- 9.1 内部类的分类
- 9.1 内部类
-
- **静态内部类**
- 非静态内部类
- 局部内部类
- 匿名内部类
- 10. 对象的打印
7. static成员
7.1 再谈学生类
使用前文中介绍的学生类实例化三个对象s1、s2、s3，每个对象都有自己特有的名字、性别，年龄，学分绩点等成
员信息，这些信息就是对不同学生来进行描述的，如下所示：
public class Student{
// ...
public static void main(String[] args) {
Student s1 = new Student("Li leilei", "男", 18, 3.8);
Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
Student s3 = new Student("Jim", "男", 18, 2.6);
}
}
假设三个同学是同一个班的，那么他们上课肯定是在同一个教室，那既然在同一个教室，那能否给类中再加一个成员变量，来保存同学上课时的教室呢？答案是实在太麻烦了。
之前在Student类中定义的成员变量，每个对象中都会包含一份(称之为普通成员变量)，因为需要使用这些信息来描述具体的学生。而现在要表示学生上课的教室，这个教室的属性并不需要每个学生对象中都存储一份，而是需要让所有的学生来共享。在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的。
因此我们的成员变量可以分为两类
成员变量：
- 静态成员变量/类变量/类成员
- static修饰的非静态成员变量/普通成员变量
7.2 static修饰的成员变量
static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。
【静态成员变量特性】
- 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
- 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
- 类变量存储在方法区当中，普通成员变量存储在堆区
- 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)
7.2.1 静态成员变量的访问
class Student {
private String name;
private int age;
public static String classRoom = "class107";
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public void doClass() {
System.out.println("上课");
}
}
public class Test2 {
public static void main(String[] args) {
Student student1 = new Student("gaobo",10);
//静态成员变量可以直接通过类名进行访问
System.out.println(Student.classRoom);
//静态成员变量也可以通过对象进行访问，但是编译器并没有进行提示，并且给予警告
System.out.println(student1.classRoom);
}
}
静态成员变量不依赖于对象，所以可以不用通过对象的引用进行访问，可以直接可以通过类名进行访问。
7.3 static修饰成员方法
既然static可以修饰成员变量，那么也可以修饰成员方法
成员方法：
- 静态成员方法/类方法
- 非静态成员方法/普通成员方法
class Student {
private String name;
private int age;
public static String classRoom = "class107";
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public void doClass() {
System.out.println(name + "上课");
}
public static void func() {
System.out.println("staticFunc()");
}
}
public class Test2 {
public static void main(String[] args) {
Student student1 = new Student("gaobo",10);
//可以通过对象进行调用静态成员方法，但是不推荐
student1.func();
//建议通过类进行调用静态成员方法
Student.func();
}
}
我们之前说过main方法的时候都写成
public static ...的形式
public static void func(){}
因为如果没有static修饰的话就成为了成员方法，调用成员方法，需要现实例化一个对象后再通过对象进行调用。然而静态成员方法不依赖于对象，直接通过类进行访问。
而调用静态成员方法
-
在类外：只需要通过类进行调用。
-
在类内：直接通过方法名进行调用
1.在静态方法内部，不能直接调用非静态方法，需要通过实例化对象进行调用，所有的非静态方法一定是依赖于对象进行调用，在调用静态方法的时候是需要通过类进行调用
class Student {
private String name;
private int age;
public static String classRoom = "class107";
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public void doClass() {
System.out.println(name + "上课");
}
public static void func() {
System.out.println("staticFunc()");
}
}
public class Test2 {
public static void main(String[] args) {
Student student = new Student("gaobo",20);
//非静态成员方法调用方式
student.doClass();
//静态成员方法调用方式
Student.func();
}
}
2.在静态方法内部不能够直接用非静态的成员变量如果想使用，也是要现进行对象实例化
class Student {
private String name;
private int age;
public static String classRoom = "class107";
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public void doClass() {
System.out.println(name + "上课");
}
public static void func() {
System.out.println("staticFunc()");
/*System.out.println(this.name);
System.out.println(name);*/
//通过实例化进行调用成员变量
Student student1 = new Student("123",123);
System.out.println(student1.name);
}
}
public class Test2 {
public static void main(String[] args) {
}
}
3.在静态成员方法中不能使用this关键字
4.在同一个类中调用静态方法只需要通过静态方法名进行调用
class Student {
private String name;
private int age;
public static String classRoom = "class107";
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public void doClass() {
System.out.println(name + "上课");
func();
}
public static void func() {
System.out.println("staticFunc()");
//通过静态方法名调用
func2();
}
public static void func2() {
System.out.println("staticFunc()");
}
}
- 静态方法无法重写，不能用来实现多态(此处大家暂时不用管，后序多态位置详细讲解)。
补充：不论是静态方法还是非静态方法，调用静态方法在一个类当中的直接调用，在类外通过类名.方法名进行调用。
调用非静态的需要进行实例化对象，特殊情况时当在一个类当中，非静态方法调用非静态方法不需要实例化直接调用外，其他情况都需要进行实例化。
7.4 static成员变量初始化
注意：静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性。
静态成员变量的初始化分为两种：就地初始化 和 静态代码块初始化。
- 就地初始化
就地初始化指的是：在定义时直接给出初始值
class Student {
private String name;
private int age;
//就地初始化
public static String classRoom = "class107";
}
- 默认初始化
- 可以通过get和set方法进行初始化
class Student {
private String name;
private int age;
private static int size;
public static int getSize() {
return size;
}
public static void setSize(int size) {
Student.size = size;
}
}
public class Test2 {
public static void main(String[] args) {
Student.setSize(20);
System.out.println(Student.getSize());
}
}
//---------------
//编译器运行结果为
//20
因为一般情况成员变量的权限属于private,所以我们不直接通过Student.size = 20;进行修改
- 在构造方法中进行初始化
class Student {
private String name;
private int age;
public static int getSize() {
return size;
}
public static void setSize(int size) {
Student.size = size;
}
//在构造函数当中进行初始化
public Student(String name, int age, int si) {
this.name = name;
this.age = age;
Student.size = si;
}
}
public class Test2 {
public static void main(String[] args) {
Student student = new Student("20",20,20);
System.out.println(Student.getSize());
}
}
//--------------
//编译器运行结果为
//20
虽然可以在构造函数当中进行对静态成员变量的初始化，但是我们不建议这么写，因为静态成员变量是对象共享的，不能通过实例化对象的时候随意进行更改。
- 通过代码块进行赋值
什么是代码块呢，接着往下看~~
8. 代码块
8.1 代码块概念以及分类
**使用{} 定义的一段代码称为代码块。**根据代码块定义的位置以及关键字，又可分为以下四种：
-
普通代码块
-
构造块
-
静态块
-
同步代码块（后续讲解多线程部分再谈）
其中构造块也叫做非静态代码块/实例代码块
8.2 普通代码块
普通代码块：定义在方法中的代码块.
public static void main(String[] args) {
//普通代码块
{
int a = 10;
}
}
8.3 构造代码块
构造代码块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。
class Person{
{
System.out.println("这就是一个构造代码块");
}
}
在调用构造方法之前，先执行的是构造代码块，无论两部分代码的顺序
代码示例1
class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
System.out.println("带有两个参数的构造方法");
}
{
System.out.println("非静态代码块/实例代码块/构造代码块 -> 一般用来初始化非静态的数据成员");
}
}
public class Test2 {
public static void main(String[] args) {
Student student = new Student("mengdehong",10);
}
}
//---------------------
//编译器运行结果为
//非静态代码块/实例代码块/构造代码块 -> 一般用来初始化非静态的数据成员
//带有两个参数的构造方法
代码示例2
class Student {
public String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
System.out.println("带有两个参数的构造方法");
}
{
name = "caocao";
System.out.println("非静态代码块/实例代码块/构造代码块 -> 一般用来初始化非静态的数据成员");
}
}
public class Test2 {
public static void main(String[] args) {
Student student = new Student("mengdehong",10);
}
}
//-----------------
//编译器运行结果为
//非静态代码块/实例代码块/构造代码块 -> 一般用来初始化非静态的数据成员
//带有两个参数的构造方法
//mengdehong（这里没有打印函数，但是意思是构造方法后执行赋值，所以才打印mengdehong）
代码示例3
class Student {
public String name;
private int age;
private static int size;
public Student() {
System.out.println("不带参数的构造方法");
}
{
name = "caocao";
System.out.println("非静态代码块/实例代码块/构造代码块 -> 一般用来初始化非静态的数据成员");
}
}
public class Test2 {
public static void main(String[] args) {
Student student = new Student();
System.out.println(student.name);
}
}
//-------------------
//编译器运行结果为
//非静态代码块/实例代码块/构造代码块 -> 一般用来初始化非静态的数据成员
//不带参数的构造方法
//caocao
代码示例4
class Student {
public String name = "wusuowei";
private int age;
private static int size;
public Student() {
System.out.println("不带参数的构造方法");
}
{
name = "caocao";
System.out.println("非静态代码块/实例代码块/构造代码块 -> 一般用来初始化非静态的数据成员");
}
}
public class Test2 {
public static void main(String[] args) {
Student student = new Student();
System.out.println(student.name);
}
}
//-------------------
//编译器运行结果为
//非静态代码块/实例代码块/构造代码块 -> 一般用来初始化非静态的数据成员
//不带参数的构造方法
//caocao
如果代码示例4中的实例代码块的顺序在name赋值为wusuowei的前面，那么结果就是wusuowei
011432…这是个什么的鬼玩意顺序
总结：如果都是非静态的，那么看定义顺序
例如
String name = "wusuowei";
//可以把这段代码看作是实例代码
重点：在编译的过程中会把实例代码块中的东西放到构造函数当中，并且是最前面
8.4 静态代码块
使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。
class Student {
public String name = "wusuowei";
private int age;
private static int size;
public Student() {
System.out.println("不带参数的构造方法");
}
static {
System.out.println("静态的代码块");
}
{
name = "caocao";
System.out.println("非静态代码块/实例代码块/构造代码块 -> 一般用来初始化非静态的数据成员");
}
public class Test2 {
public static void main(String[] args) {
Student student = new Student();
}
}
//----------------------
//编译器运行结果为
//静态的代码块
//非静态代码块/实例代码块/构造代码块 -> 一般用来初始化非静态的数据成员
//不带参数的构造方法
class Student {
static {
System.out.println("静态的代码块");
}
public static void func2() {
System.out.println("staticFunc()");
}
}
public class Test2 {
public static void main(String[] args) {
Student.func2();
}
}
-----------
编译器运行结果为
静态的代码块
staticFunc()
说明只要类被加载，那么静态代码块就会执行
另外静态的只会被执行一次
class Student {
static {
System.out.println("静态的代码块");
}
public static void func2() {
System.out.println("staticFunc()");
}
}
public class Test2 {
public static void main(String[] args) {
Student.func2();
Student.func2();
}
}
-----------
编译器运行结果为
静态的代码块
staticFunc()
staticFunc()
注意事项
- 静态代码块不管生成多少个对象，其只会执行一次
- 静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
- 如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)
- 实例代码块（非静态代码块）只有在创建对象时才会执行
9. 内部类
当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服
务，那么这个内部的完整结构最好使用内部类。在 Java 中**可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。**内部类也是封装的一种体现。
public class OutClass {
class InnerClass{
}
}
// OutClass是外部类
// InnerClass是内部类
【注意事项】
- 定义在class 类名{}花括号外部的，即使是在一个文件里，都不能称为内部类
public class A{
}
class B{
}
// A 和 B是两个独立的类，彼此之前没有关系
- 内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件
9.1 内部类的分类
先来看下，内部类都可以在一个类的那些位置进行定义
public class OutClass {
// 成员位置定义：未被static修饰 --->实例内部类
public class InnerClass1{
}
// 成员位置定义：被static修饰 ---> 静态内部类
static class InnerClass2{
}
public void method(){
// 方法中也可以定义内部类 ---> 局部内部类：几乎不用
class InnerClass5{
}
}
}
根据内部类定义的位置不同，一般可以分为以下几种形式：
- 成员内部类(普通内部类：未被static修饰的成员内部类 和 静态内部类：被static修饰的成员内部类)
- 局部内部类(不谈修饰符)、匿名内部类
注意：内部类其实日常开发中使用并不是非常多，大家在看一些库中的代码时候可能会遇到的比较多，日常开始中
使用最多的是匿名内部类。
内部类是组成外部类的一部分
内部类分类
1.静态内部类
2.非静态内部类/实例内部类
3.局部内部类
4.匿名内部类
9.1 内部类
静态内部类
class OuterClass {
public int data1 = 1;
private int data2 = 2;
public static int data3 = 3;
//静态内部类
static class InnerClass {
public int data4 = 4;
private int data5 = 5;
public static int data6 = 6;
public void func() {
System.out.println(123);
}
}
}
既然是一个类，那么怎么实例化一个静态内部类呢？
public static void main(String[] args) {
InnerClass innerClass = new InnerClass();//error
OuterClass.InnerClass innerClass1 = new OuterClass.InnerClass();
}
在静态内部类当中，不能直接访问外部类的非静态成员
class OuterClass {
public int data1 = 1;
private int data2 = 2;
public static int data3 = 3;
//静态内部类
static class InnerClass {
public int data4 = 4;
private int data5 = 5;
public static int data6 = 6;
public void func() {
System.out.println(123);
System.out.println(data1);//error
System.out.println(data2);//error
System.out.println(data3);
System.out.println(data4);
System.out.println(data5);
System.out.println(data6);
}
}
}
不能直接访问，但是如果要访问的话，可以通过实例化外部类对象进行访问。
class OuterClass {
public int data1 = 1;
private int data2 = 2;
public static int data3 = 3;
//静态内部类
static class InnerClass {
public int data4 = 4;
private int data5 = 5;
public static int data6 = 6;
public void func() {
OuterClass outerClass = new OuterClass();
System.out.println(123);
System.out.println(outerClass.data1);
System.out.println(outerClass.data2);
System.out.println(data3);
System.out.println(data4);
System.out.println(data5);
System.out.println(data6);
}
}
}
成员方法访问静态内部类
class OuterClass {
public int data1 = 1;
private int data2 = 2;
public static int data3 = 3;
//静态内部类
static class InnerClass {
public int data4 = 4;
private int data5 = 5;
public static int data6 = 6;
public void func() {
OuterClass outerClass = new OuterClass();
System.out.println(123);
System.out.println(outerClass.data1);
System.out.println(outerClass.data2);
System.out.println(data3);
System.out.println(data4);
System.out.println(data5);
System.out.println(data6);
}
}
public void test(){
InnerClass innerClass = new InnerClass();
System.out.println(data1);
System.out.println(data2);
System.out.println(data3);
System.out.println(innerClass.data4);
System.out.println(innerClass.data5);//外部类可以访问静态内部类当中的所有成员，包括private修饰的成员
System.out.println(InnerClass.data6);
}
}
补充
静态内部类的字节码文件也有些不同。
外部类$内部类.class
非静态内部类
class OuterClass {
public int data1 = 1;
private int data2 = 2;
public static int data3 = 3;
//非静态内部类
class InnerClass {
public int data4 = 4;
private int data5 = 5;
public static int data6 = 6;//error
public void func() {
}
}
public void test(){
}
}
在实例内部类当中，不能定义静态的成员，如果非要定义静态的成员变量需要通过final进行修饰
class OuterClass {
public int data1 = 1;
private int data2 = 2;
public static int data3 = 3;
//非静态内部类
class InnerClass {
public int data4 = 4;
private int data5 = 5;
public static final int data6 = 6;
public void func() {
}
}
public void test(){
}
}
如何实例化非静态内部类的对象呢？
class OuterClass {
public int data1 = 1;
private int data2 = 2;
public static int data3 = 3;
//非静态内部类
class InnerClass {
public int data4 = 4;
private int data5 = 5;
public static final int data6 = 6;
public void func() {
}
}
public void test(){
}
}
public class Test {
public static void main(String[] args) {
OuterClass outerClass = new OuterClass();
OuterClass.InnerClass innerClass = outerClass.new InnerClass();
}
}
静态内部类和非静态内部类实例化的比较
如何访问外部类和内部类的成员变量呢？
class OuterClass {
public int data1 = 1;
private int data2 = 2;
public static int data3 = 3;
//非静态内部类
class InnerClass {
public int data4 = 4;
private int data5 = 5;
public static final int data6 = 6;
public void func() {
System.out.println(data1);
System.out.println(data2);
System.out.println(data3);
System.out.println(data4);
System.out.println(data5);
System.out.println(data6);
}
}
public void test(){
InnerClass innerClass = new InnerClass();
System.out.println(data1);
System.out.println(data2);
System.out.println(data3);
System.out.println(innerClass.data4);
System.out.println(innerClass.data5);
System.out.println(InnerClass.data6);
}
}
当内部类和外部类有一个相同的变量的时候遵循就近原则
class OuterClass {
public int data1 = 1;
private int data2 = 2;
public static int data3 = 3;
//非静态内部类
class InnerClass {
public int data1 = 11111;
public int data4 = 4;
private int data5 = 5;
public static final int data6 = 6;
public void func() {
System.out.println(data1);
System.out.println(OuterClass.this.data1);
System.out.println(data2);
System.out.println(data3);
System.out.println(data4);
System.out.println(data5);
System.out.println(data6);
}
}
public void test(){
InnerClass innerClass = new InnerClass();
System.out.println(data1);
System.out.println(data2);
System.out.println(data3);
System.out.println(innerClass.data4);
System.out.println(innerClass.data5);
System.out.println(InnerClass.data6);
}
}
public class Test {
public static void main(String[] args) {
OuterClass outerClass = new OuterClass();
OuterClass.InnerClass innerClass = outerClass.new InnerClass();
innerClass.func();
}
}
//打印
11111
1
2
3
4
5
6
在内静态内部类当中使用
this表示内部类的this
OuterClass.this表示外部类的this
静态内部类我们使用的比较多，实例内部类用的比较少
局部内部类
定义在外部类的方法体或者{}中，该种内部类只能在其定义的位置使用，一般使用的非常少，此处简单了解下语法格式。
public class OutClass {
int a = 10;
public void method(){
int b = 10;
// 局部内部类：定义在方法体内部
// 不能被public、static等访问限定符修饰
class InnerClass{
public void methodInnerClass(){
System.out.println(a);
System.out.println(b);
}
}
// 只能在该方法体内部使用，其他位置都不能用
InnerClass innerClass = new InnerClass();
innerClass.methodInnerClass();
}
public static void main(String[] args) {
// OutClass.InnerClass innerClass = null; 编译失败
}
}
class OuterClass3{
public void func(){
class InnerClass {
public int a = 1;
public void test() {
System.out.println("hello");
}
}
InnerClass innerClass = new InnerClass();
innerClass.test();
}
}
public class Test {
public static void main(String[] args) {
OuterClass3 outerClass3 = new OuterClass3();
outerClass3.func();
}
}
【注意事项】
- 局部内部类只能在所定义的方法体内部使用
- 不能被public、static等修饰符修饰
- 编译器也有自己独立的字节码文件，命名格式：外部类名字$数字内部类名字.class
- 几乎不会使用
匿名内部类
匿名内部类涉及到了接口的知识
一般情况下接口的使用
interface IA {
void func();
}
class AA implements IA{
@Override
public void func() {
System.out.println("hello");
}
}
public class Test {
public static void main(String[] args) {
IA ia = new AA();
ia.func();
}
}
这里还有一种匿名内部类的使用方法
interface IA {
void func();
}
class AA implements IA{
@Override
public void func() {
System.out.println("hello");
}
}
public class Test {
public static void main(String[] args) {
new IA(){
@Override
public void func() {
System.out.println(123);
}
};
}
}
这两段代码是等价的，表示一个类实现了这个接口，并且重写了方法，但是第二段代码中由于这个类的名字未知，所以叫做匿名内部类
那么怎么调用这个匿名内部类呢？
interface IA {
void func();
}
public class Test {
public static void main(String[] args) {
new IA(){
@Override
public void func() {
System.out.println(123);
}
}.func();
}
}
//打印
123
匿名内部类也会生成自己对应的字节码文件。
10. 对象的打印
public static void main(String[] args) {
Student student = new Student("123",123);
System.out.println(student);
}
------------
Student@1b6d3586
Student是类型的全路径
@是分隔符
1b6d3586是真实地址的一个哈希值，可以近似地理解为这就是地址，唯一的
class Person{
int age;
String name;
@Override
public String toString() {
return "Person{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}
public class Test {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person);
}
}
//打印
//Person{age=0, name='null'}
class Person{
int age;
String name;
@Override
public String toString() {
return "gaobo is cool";
}
}
public class Test {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person);
}
}
//打印
//gaobo is cool
如果自己实现了，那么久调用自己的，此时发生的是重写，先记住如果自己写了toString函数那么就用自己的。以后学了继承和多态才明白
什么是前端？
作业讲解
2022-11-07_类和对象的认识等_作业
第 1 题（单选题）
题目名称：
下面代码的运行结果是（C）
public static void main(String[] args){
String s;
System.out.println("s="+s);
}
题目内容：
A .代码编程成功，并输出”s=”
B .代码编译成功，并输出”s=null”
C .由于String s没有初始化，代码不能编译通过。
D .代码编译成功，但捕获到NullPointException异常
第 2 题（单选题）
题目名称：
阅读如下代码。 请问，对语句行 test.hello(). 描述正确的有（A）
package NowCoder;
class Test {
public static void hello() {
System.out.println("hello");
}
}
public class MyApplication {
public static void main(String[] args) {
// TODO Auto-generated method stub
Test test=null;
test.hello();
}
}
题目内容：
A .能编译通过，并正确运行
B .因为使用了未初始化的变量，所以不能编译通过
C .以错误的方式访问了静态方法
D .能编译通过，但因变量为null，不能正常运行
第 3 题（单选题）
题目名称：
下面哪一项不是 java 类访问控制关键字B
题目内容：
A .public
B .this
C .private
D .protected
第 4 题（单选题）
题目名称：
以下哪项说法是正确的？D
题目内容：
A .public关键字只能修饰类名
B .public关键字只能修饰方法
C .public关键字只能修饰成员变量
D .以上说法都不对
第 5 题（单选题）
题目名称：
以下代码在编译和运行过程中会出现什么情况A
public class TestDemo{
private int count;
public static void main(String[] args) {
TestDemo test=new TestDemo(88);
System.out.println(test.count);
}
TestDemo(int a) {
count=a;
}
}
题目内容：
A .编译运行通过，输出结果是88
B .编译时错误，count变量定义的是私有变量
C .编译时错误，System.out.println方法被调用时test没有被初始化
D .编译和执行时没有输出结果
第 6 题（单选题）
题目名称：
关于包的说法, 下列错误的是:（C）
题目内容：
A .包是一组类的集合
B .包能防止类的名字冲突
C .import 语句能够导入一个指定的包
D .import static 能够导入一些静态方法
//import只能导一个具体的类
第 7 题（单选题）
题目名称：
在JAVA中，假设A有构造方法A(int a)，则在类A的其他构造方法中调用该构造方法和语句格式应该为（B）
题目内容：
A .this.A(x)
B .this(x)
C .super(x)
D . A(x)
第 8 题（编程题）
题目名称：
修改Data类的定义
题目内容：
描述
现有一个Data类，内部定义了属性x和y，在main方法中实例化了Data类，并计算了data对象中x和y的和。但是，Data类的定义存在错误，请你将这些错误修正过来，使得main方法中的求和逻辑可以正常执行。
输入描述：
两个整数
输出描述：
两个整数的和
示例1
输入：
1 2
复制
输出：
3
代码如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNextInt()) {
int x = scanner.nextInt();
int y = scanner.nextInt();
Data data = new Data(x, y);
System.out.println(data.getX() + data.getY());
}
}
}
class Data {
private int x;
private int y;
private Data(int x, int y) {
x = x;
y = y;
}
private int getX() {
return x;
}
private int getY() {
return y;
}
}