【JavaSE】类和对象（下）

最新推荐文章于 2024-11-03 11:01:20 发布

菜菜求捞

最新推荐文章于 2024-11-03 11:01:20 发布

阅读量260

点赞数 3

分类专栏： JavaSE 文章标签： java jvm 算法

本文链接：https://blog.csdn.net/m0_71545436/article/details/129650337

版权

JavaSE 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

文章详细介绍了Java中的static修饰的成员变量和方法，包括它们的访问、初始化以及在类和对象中的作用。同时，讨论了不同类型的代码块（普通代码块、构造代码块和静态代码块）的执行顺序和用途。此外，文章还涵盖了内部类的概念，如静态内部类、实例内部类、局部内部类和匿名内部类的基本用法和特点。

摘要由CSDN通过智能技术生成

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;
    }

}