Java学习记录

已于 2024-01-02 13:49:44 修改
阅读量1.1k 收藏 27
点赞数 22
文章标签： java 学习 开发语言
于 2024-01-01 23:39:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/moguihe/article/details/135321349
版权

因为要找工作的缘故，不得不重新学习java，虽然java目前看来很卷，但是我还是选择了这条路，没办法，自己选择的路，跪着也要走完。

目录

Java面向对象程序设计

第1章 Java入门

1.1 安装JDK

 1.2 第1个Java程序

 习题 1

1. 判断题

2.  单选题

3. 挑错题

第2章 基本数据类型、数组和枚举类型

2.1 基本数据类型

2.1.1 整数类型

2.1.2 字符类型

2.1.3 浮点类型

2.2 数组

2.2.1 声明数组

 2.2.2 创建数组

2.2.3 length的使用

习题 2

 1. 判断题

2. 单选题

3. 挑错题

4. 阅读程序题

第3章 运算符、表达式和语句

习题 3

1. 判断题

2. 单选题

3. 挑错题

4. 阅读程序题

第4章 类与对象

习题 4

1. 判断题

2. 单选题

3. 挑错题

4. 阅读程序题

第5章 继承与接口

习题 5

1. 判断题

2. 单选题

3. 挑错题

4. 阅读程序题

Java面向对象程序设计

第1章 Java入门

1.1 安装JDK

网址：Archived OpenJDK GA Releases (java.net)icon-default.png?t=N7T8https://jdk.java.net/archive/

 设置环境变量：

 1.2 第1个Java程序

public class Main{
    public static void main(String args[]){
        System.out.println("Hello,Java");
    }
}

 习题 1

1. 判断题

(1)  Java语言的主要贡献者是James Gosling。(✔)

(2) Java源文件中只能有一个类。(X)

(3) 一个源文件中必须要有public类。(X)

(4) 源文件中如果有多个类，那么至多有一个类可以是public类。(✔)

(5) Java应用程序必须有主类。(X)

(6) Java应用程序的主类必须是public类。(X)

(7) 下列源文件可保存成dog.java。(X)

public class Dog {
    public void cry() {
        System.out.println("wangwang");
    }
}
2.  单选题

(1) 下列选项中，(B)是JDK提供的编译器。

A. java.exe          B. javac.exe

C. javap.exe        D.javaw.exe

(2) 下列选项中，(D)是Java应用程序主类中正确的main方法。

A. public void main (String args[])

B. static void main (String args[])

C. public static void Main (String args[])

D. public static void main (String args[])

(3) 下列选项中，(A)是正确的。

A. Java源文件由若干个书写形式互相独立的类组成

B. Java源文件中只能有一个类

C. 如果源文件中有多个类，那么至少有一个类必须是public类

D. Java源文件的扩展名是.txt

(4) 对于下列源文件，(C)叙述是正确的。

A. 源文件名字必须是A.java

B. 源文件有错误

C. 源文件必须命名为E.java，编译无错误。有两个主类，E 和 A。程序可以执行主类E也可以执行主类A

D. 源文件中的E类不是主类

public class E {
    public static void main(String[] args) {
        System.out.println("ok");
        System.out.println("您好");
    }
}

class A {
    public static void main(String[] args) {
        System.out.println("ok");
        System.out.println("您好");
    }
}

(5) 下列选项中，(C)叙述是正确的。

A. Java语言是2005年5月Sun公司推出的编程语言

B. Java语言是1995年5月IBM公司推出的编程语言

C. Java语言的名字是印度尼西亚一个盛产咖啡的岛名

D. Java语言是的主要贡献者是比尔 · 盖茨

3. 挑错题

(1) (D)

public class Example1{                          //A
    public static void main(String[] args) {    //B
        System.out.println("ok");               //C
        System.out.println("hello");
        system.out.println("您好");              //D
    }
}

(2) (A)

Qublic class Example2{                          //A
    public static void main(String[] args) {    //B
        System.out.println("ok");               //C
        System.out.println("hello");
        System.out.println("您好");              //D
    }
}

(3) (B)

public class Example3{                          //A
    public static void main(string[] args) {    //B
        System.out.println("ok");               //C
        System.out.println("hello");
        System.out.println("您好");              //D
    }
}

第2章 基本数据类型、数组和枚举类型

2.1 基本数据类型

逻辑类型：boolean。

整数类型：byte、short、int、long。

字符类型：char。

浮点类型：float、double。

2.1.1 整数类型

int型变量的取值范围是-2{^{31}} ~ 2{^{31}-1}。

byte型变量的取值范围是-2{^{7}} ~ 2{^{7}-1}。

short型变量的取值范围是-2{^{15}} ~ 2{^{15}-1}。

long型变量的取值范围是-2{^{63}} ~ 2{^{63}-1}。

2.1.2 字符类型

char型变量的取值范围是0~65535。

除了ASCII表外，很多中文字符和其他字符都存储在Unicode表中。

2.1.3 浮点类型

float型变量的取值范围是1.4E-45~3.4028235E38和-3.4028235E38~-1.4E-45。

常量后面必须有后缀“f”或“F”。

double型变量的取值范围是4.9E-324~1.7976931348623157E308和-1.7976931348623157E308~-4.9E-324。

2.2 数组

2.2.1 声明数组

声明一维数组有下列两种格式：

数组的元素类型        数组名字[];

数组的元素类型[]      数组名字；

声明二维数组有下列两种格式：

数组的元素类型        数组名字[][];

数组的元素类型[]      []数组名字；

例如：

float boy[];

char cat[][];

 2.2.2 创建数组

声明数组仅仅是给出了数组名字和元素的数据类型，要想真正使用数组，还必须为它分配内存空间，即创建数组。

为数组分配内存空间的格式如下：

数组名字 = new 数组元素的类型[数组元素的个数];

例如：

boy = new float[4]; 

注：和C语言不同的是，Java允许使用int型变量的值指定数组元素的个数。例如：

int size = 30;

double number[] = new double[size];

2.2.3 length的使用

对于一维数组，“数组名字.length”的值就是数组中元素的个数；对于二维数组，“数组名字.length”的值是它含有的一维数组的个数。

例如，对于：

float a[] = new float[12];

int b[][] = new int[3][6];

a.length的值是12，b.length的值是3 

习题 2

 1. 判断题

(1)  main是Java语言规定的关键字。(X)

(2) “float area = 1e1;”是错误的float变量声明。(✔)

(3) “float height = 1.0f;”是正确的float变量声明。(✔)

(4) “byte amount = 128;”是正确的float变量声明。(X)

(5) “int[] a,b;”声明了两个int型一维数组a和b。(✔)

(6) “int a[],b;”声明了一个int型一维数组a和一个int型变量b。(✔)

(7) 对于“int[][] a = {{1,2,3},{4,5,6,7}};”,a[0].length的值是3,a[1].length的值是4。(✔)

(8) 对于“int a[][] = new int[2][9];”,a.length的值是2,a[0].length、a[1].length的值都是9。(✔)

(9) “int a[20];”是正确的数组声明。(X)

(10) “boolean yes = TRUE;”是正确的boolean变量声明。(X)

2. 单选题

(1) 下列选项中，(B)叙述是错误的。

A. “int[] a,b[];”声明了一个int型一维数组a和一个int型二维数组b

B. “float a[20];”是正确的数组声明

C. “boolean yes = false;”是正确的boolean变量声明

D. 1e2和2.05E2都是double型常量

(2) 下列选项中，(A)叙述是错误的。

A. System是关键字

B. _class可以作为标识符

C. char 型字符在Unicode表中的位置范围为0~65535

D. 对于“int a[] = new int[3];”,a.length的值是3

(3) 下列选项中，(C)字符序列可以是标识符。

A. true        B. default        C. _int        D. good-class

(4) 下列选项中，(A)是正确的float变量的声明。

A. float foo = 1;                B. float foo = 1.0;

C. float foo = 2e1;            D. float foo = 2.02;

(5) 下列选项中，(D)是正确的float变量的声明。

A. float foo = 1e2;                B. float foo = 3.14;

C. float foo = 3.03d;             D. float foo = 0x0123;

(6) 下列选项中，(B)是正确的char型变量的声明。

A. char ch = "R";                   B. char ch = '\\';

C. char ch = 'ABCD';             D. char ch = "ABCD";

(7) 下列选项中，(B、D)叙述是错误的。

A. 对于“int a[][] = new int[6][4];”,a.length的值是6

B. 对于“int a[][] = new int[2][9];”,a.length、a[0].length、a[1].length的值都是9

C. 对于“int[] a = new int[3];”,a[0]、a[1]、a[2]的值都是0

D. “float height = 1eF;”是正确的float变量声明

(8) 对于下列Test.java代码，(D)叙述是正确的。

public class Test {
    public static void main(String[] args) {
        int arr[] = new int[10];
        System.out.println(arr[1]);
    }
}

A. 产生编译错误                               B. 输出null

C. 编译正确，发生运行异常             D. 输出0

3. 挑错题

(1) (D)

public class Test1{
    public static void main(String[] args) {
        char c = 65535;                        //A
        byte b = 127;                          //B
        int height = 100;                      //C
        float f = 3.14;                        //D
    }
}

 (2) (A)

public class Test2{
    public static void main(String[] args) {
        int x = 8;                        
        byte b = 127;                          
        b = x;                           //A
        x = 'a';                         //B
        long y = b;                      //C
        float z = (int)6.89;             //D                     
    }
}

 (3) (B)

public class Test3 {
    public static void main(String[] args) {
        char c = 'a';                //A
        byte b = 128;                //B
        int height = 100;            //C
        float f = 3.14F;             //D
    }
}

 (4) (C)

public class Test4 {
    public static void main(String[] args) {
        char c = 30320;                //A
        byte b = 127;                  //B
        int public = 100;              //C
        float f = 3.14F;               //D
    }
}
4. 阅读程序题

(1) 127

public class E {
    public static void main(String[] args) {
        System.out.println(Byte.MAX_VALUE);
    }
}

 (2) 200

public class E {
    public static void main(String[] args) {
        int a[] = {1,2,3,4};
        int b[] = {100,200,300};
        a = b;
        System.out.println(a[1]);
    }
}

 (3) 1

public class E {
    public static void main(String[] args) {
        int[][] a = {{1,2,3,4},{5,6},{7,8,9}};
        a[2] = a[0];
        System.out.println(a[2][0]);
    }
}

 (4) 600

public class E {
    public static void main(String[] args) {
        int[][] a = {{0,1,2,3,4},{5,6},{7,8,9}};
        int[] b = {100,200,300};
        a[0] = b;
        int m = a[0][2]+b[2];
        System.out.println(m);
    }
}

第3章 运算符、表达式和语句

习题 3

1. 判断题

(1)  表达式10>20-17的结果是1。(X)

(2) 表达式5/2的结果是2。(✔)

(3) 逻辑运算符的运算结果是boolean型数据。(✔)

(4) 关系运算符的运算结果是int型数据。(X)

(5) 12 = 12是非法的表达式。(✔)

(6) 表达式2>8&&9>2的结果为false。(✔)

(7) while(表达式)...语句中的“表达式”的值必须是boolean型数据。(✔)

(8) 在while语句的循环体中，执行break语句的结果是结束while语句。(✔)

(9) switch 语句中必须有default选项。(X)

(10) if语句中的条件表达式的值可以是int型数据。(X)

2. 单选题

(1) 下列叙述正确的是(A)。

A. 5.0/2+10的结果是double型数据

B. (int)5.8+1.0的结果是int型数据

C. '苹'+'果'的结果是char型数据

D. (short)10+'a'的结果是short型数据

(2) 用下列代码替换程序标注的【代码】会导致编译错误的是(C)。

public class E {
    public static void main(String[] args) {
        int m = 10,n = 0;
        while(【代码】){
            n++;
        }
    }
}

A. m-->0                B. m++>0

C. m = 0                D. m>100&&true

(3) 对于Test.java，下列叙述正确的是(B)。

public class Test {
    public static void main(String[] args) {
        boolean boo = false;
        if (boo = true) {
            System.out.print("hello");
            System.out.print("你好");
        }
        else {
            System.out.print("ok");
            System.out.print("yes");
        }
    }
}

A. 出现编译错误                           B. 程序输出的结果是hello 你好

C. 程序输出的结果是ok                D. 程序输出的结果是okyes

(4) 对于“int n=6789;”,表达式的值为7的是(C)。

A. n%10        B. n/10%10        C. n/100%10        D. n/1000%10

(5) 用下列代码替换程序标注的【代码】会使程序输出hello的是(C)。

A. m--<=0                B. ++m>0

C. m++> 0                D. --m<0

3. 挑错题

 (1) (D)

public class Test {
    public static void main(String[] args) {
        byte b = 'a';                   //A
        int n = 100;
        char c = 65;                    //B
        b = b;                          //C
        b = b+1;                        //D
    }
}

 (2) (B)

public class Test {
    public static void main(String[] args) {
        char ch = '花';                 //A
        byte n = -100;
        ch = ch-ch;                     //B
        n = n;                          //C
        n = 127;                        //D
    }
}

 (3) (D)

public class Test {
    public static void main(String[] args) {
        int m = 1000;
        while (m > 100) {                   //A
            m = m--;                        //B
            if (m == 600) {                 //C
                continue;
                m++;                        //D
            }
        }
    }
}
4. 阅读程序题

 (1) truehello10

public class Test {
    public static void main(String[] args) {
        boolean boo = false;
        int x = -1;
        boo = ((x=10)>9)||((x=100)>99);
        System.out.println(boo+"hello"+x);
    }
}

 (2) truehello100

public class Test {
    public static void main(String[] args) {
        boolean boo = false;
        int x = -1;
        boo = ((x=10)>9)|((x=100)>99);
        System.out.println(boo+"hello"+x);
    }
}

 (3) 321

public class Test {
    public static void main(String[] args) {
        int m = 123;
        int sum = 0,t = 100;
        while(t>0){
            sum = sum+m%10*t;
            m = m/10;
            t = t/10;
        }
        System.out.printf("%d",sum);
    }
}

 (4) 5

public class Test {
    public static void main(String[] args) {
        int m = 0;
        char ch = 'A';
        switch (ch){
            case 9:
            case 'a' : m = m+1;;
                        break;
            case 'A' : m = m+1;
            case 66 : m = m+1;
            default: m = m+3;
        }
        System.out.println(m);
    }
}

第4章 类与对象

习题 4

1. 判断题

(1) 类是最重要的“数据类型”，类声明的变量被称为对象变量，简称对象。(✔)

(2) 构造方法没有类型。(✔)

(3) 类中的实例变量在用该类创建对象的时候才会被分配内存空间。(X)

(4) 类中的实例方法可以用类名直接调用。(X)

(5) 局部变量没有默认值。(✔)

(6) 构造方法的访问权限可以是public、protected、private或友好的。(✔)

(7) 方法中声明的局部变量不可以用访问修饰符public、proteced、private修饰。(✔)

(8) this可以出现在实例方法和构造方法中。(✔)

(9) 成员变量的名字不可以和局部变量的相同。(X)

(10) static方法不可以重载。(X)

2. 单选题

(1) 对于下列Dog类，（D）是错误的。

A. Dog（int m）与 Dog（double m）互为重载的构造方法。
B. int Dog（int m）与 void Dog（ double m）互为重载的非构造方法。

C.Dog类只有两个构造方法，而且没有无参数的构造方法。
D.Dog类有3个构造方法。

class Dog {
    Dog(int m){
    }
    Dog(double m){
    }
    int Dog(int m){
        return 23;
    }
    void Dog(double m){
    }
}

(2) 当用new运算符和构造方法创建对象时，（A)是正确的。

A. ①为成员变量分配内存，并指定默认值。
    ②初始化成员变量，即用户声明成员变量时给定的默认值。
    ③执行构造方法。
    ④计算出一个引用值。
B. ①计算出一个引用值。
    ②为成员变量分配内存，并指定默认值。
    ③初始化成员变量，即用户声明成员变量时给定的默认值。
    ④执行构造方法。
C. ①执行构造方法。
     ②为成员变量分配内存，并指定默认值。

     ③初始化成员变量，即用户声明成员变量时给定的默认值。

     ④计算出一个引用值。
D. ①为成员变量分配内存，并指定默认值。

     ②初始化成员变量，即用户声明成员变量时给定的默认值。
     ③计算出一个引用值。
     ④执行构造方法

(3) 对于下列Tom类，（C）是正确的。

A. 程序运行时输出：ok。

B. 没有构造方法。
C. 有编译错误，因为创建对象 cat使用的不是构造方法，java编译器已经不提供默认的构造方法了。
D. 程序运行时无任何输出。

public class Test{
    public static void main(String args[]){
        Tom cat = new Tom();
    }
}
class Tom{
    void Tom(){
        System.out.println("ok");
    }
    Tom(int m){
        System.out.printIn("你好");
    }
}


(4) 下列叙述正确的是(A)。

A. 成员变量有默认值。
B. this可以出现在static方法中。
C. 类中的实例方法可以用类名调用。
D. 局部变量也可以用访问修饰符public、proteced、private修饰。

(5) 下列叙述正确的是（D)。

A. 源文件可以有两条包语句（package）。
B. 源文件不可以有多条import语句。
C. 如果源文件有package语句，该语句也可以是源文件的第2条语句。
D. 类中的类方法（static方法）只能操作类变量（static变量），不可以操作实例变量。

3. 挑错题

(1) (B)

public class People {
    int m = 10,n;       //A
    n = 200;            //B 
    void f() {
        if (m == n)
            n = + m;     //C
        else
            n = n-m;    //D
    }
}

 (2) (C)

class E {
    int x;       
    public void f(int n) {
        int m;              //A
        int t = x+n;        //B
        int y = x+m;        //C
        m = 10;
        y = x+m;            //D
    }
}

 (3) (C)

class Tom{
    int x;
    static int y;
    void showXY(){
        System.out.printf("%d,%d\n",x,y);
    }
    static void showY(){
        System.out.printf("%d\n",y);
    }
}
public class E{
    public static void main(String[] args) {
        Tom.y = 100;                        //A
        Tom cat = new Tom();
        cat.x = 100;                        
        cat.y = 200;                        //B
        Tom.x = 300;                        //C
        cat.showXY();
        Tom.showY();                        //D
    }
}
4. 阅读程序题

  (1) 120:110:110

class Fish{
    int weight;
}
class Lake{
    Fish fish;
    void setFish(Fish s){
        fish = s;
    }
    void foodFish(int m){
        fish.weight = fish.weight+m;
    }
    Fish getFish(){
        fish.weight -= 10;
        return fish;
    }
}
public class E{
    public static void main(String[] args) {
        Fish redFish = new Fish();
        Lake lake = new Lake();
        lake.setFish(redFish);
        lake.foodFish(120);
        int w = lake.fish.weight;
        Fish fishOK = lake.getFish();
        System.out.printf("%d:%d:%d",w,lake.fish.weight,fishOK.weight);
    }
}

  (2) 100:88:188

class B{
    int x = 100,y = 200;
    public void setX(int x){
        x = x;
    }
    public void setY(int y){
        this.y = y;
    }
    public int getXYSum(){
        return x+y;
    }
}
public class Test{
    public static void main(String[] args) {
        B b = new B();
        b.setX(-100);
        b.setY(88);
        System.out.printf("%d:%d:%d",b.x,b.y,b.getXYSum());
    }
}

  (3) 10:50

class Tom{
    static int sum;
    int getSum(int ...item){
        for(int n:item){
            sum+=n;
        }
        return sum;
    }
}
public class Test{
    public static void main(String[] args) {
        Tom cat1 = new Tom();
        Tom cat2 = new Tom();
        int resultOne = cat1.getSum(1,2,3,4);
        int resultTwo = cat2.getSum(10,30);
        System.out.printf("%d:%d",resultOne,resultTwo);
    }
}

  (4) 20:11

class Circle{
    int radius = 1;
    void setRadius(int radius){
        if(radius>0){
            this.radius = radius;
        }
    }
}
class Geometry{
    Circle c;
    void setCircle(Circle c){
        c.radius += 10;
        this.c = c;
    }
}
public class Test{
    public static void main(String[] args) {
        Circle circle = new Circle();
        circle.setRadius(10);
        Geometry geometry = new Geometry();
        geometry.setCircle(circle);
        Circle circleTwo = new Circle();
        geometry.setCircle(circleTwo);
        System.out.printf("%d:%d",circle.radius,geometry.c.radius);
    }
}

第5章 继承与接口

习题 5

1. 判断题

(1) 子类继承父类的构造方法。（X）
(2) 子类中想使用被子类隐藏的实例成员变量或实例方法，就需要使用关键字super。（✔）

(3) 可以用 final 修饰构造方法。（X）
(4) 如果在子类的构造方法中，没有显式地写出 super关键字来调用父类的某个构造方法，那么编译器默认地有“super();”调用父类的无参数的构造方法；如果父类没有这样的构造方法，代码将出现编译错误。（✔）
(5) 可以同时用final和abstract修饰同一个方法。（X）
(6) 子类继承的方法所操作的成员变量一定是被子类继承或隐藏的成员变量。（✔）

(7) 如果一个类的所有构造方法的访问权限都是private的，意味着这个类不能有子类。理由是：一个类的private方法不能在其他类中被使用，但子类的构造方法中一定会调用父类的某个构造方法。（✔）
(8) 子类在方法重写时，不可以把父类的实例方法重写为类(static)方法，也不可以把父类的类(static)方法重写为实例方法。（✔）
(9) abstract类中只可以有 abstract方法。（X）
(10) 接口中的方法也可以用private或protected修饰。（X）

2. 单选题


(1)下列代码中,（D）是正确的。

interface Com{
    int MAX;
    public void stop();
    void start();
    abstract void loop();
}

A. “void start();＂会导致编译出错。
B. “public void stop();＂会导致编译出错。
C.“abstract void loop();＂会导致编译出错。
D.“int MAX;＂会导致编译出错。

(2)下列选项中，（A）代码替换源文件Com.java中的【代码】不会导致编译错误。

public interface Com{
    int N ＝200;
    int f();
}
class ImpCom implements Com{
    【代码】
}

A. public int f(){                                                        B. int f(){

        return 100＋M;                                                       return 100;

}                                                                               }

C. public double f(){                                                 D. public abstract int f();
        return 2.6;

}

（3）下列选项中，（B）代码放入程序中标注的【代码】处将导致编译错误。

A. public float getNum(){return 4. 0f;}

B. public void getNum(){}

C. public void getNum(double d){}

D. public void getNum(float d){return 4.0d;}

class A{
    public float getNum(){
        return 3.0f;    
    }
}
public class B extends A{
    【代码】
}

 （4）下列选项中，（C）是正确的。

A. final类不可以有父类

B. 可以用new运算符和abstract类的构造方法创建对象

C. 如果一个类中有absstract方法，这个类必须是abstract类

D. static 方法也可以同时是abstract方法

（5）假设C是B的子类，B是A的子类,cat是C类的一个对象，bird是B类的一个对象，下列选项中,（D）是错误的。

A. cat instanceof B的值是true                                B. bird instanceof A的值是true

C. cat instanceof A的值是true                                D. bird instanceof C的值是true 

（6）下列选项中,（A）是正确的。

A. final类不可以有子类

B. abstract类中只可以有abstract方法

C. abstract类中可以有非abstract方法，但该方法不可以用final修饰

D. bird instanceof C的值是true

3. 挑错题

(1) (B)

abstract class AAA {
    final static void speakHello(){}    //A
    final abstract void cry();          //B
    static final int f(){return 0;}     //C
    abstract float g();                 //D
}

 (2) (D)

abstract class Animal {
    int m = 100;
}
class Dog extends Animal{
    double m;
}
public class E{
    public static void main(String[] args) {
        Animal animal = null;           //A
        Dog dog = new Dog();            
        animal = dog;                   //B
        dog.m = 3.14;                   //C
        animal.m = 3.14;                //D
    }
}

(3) (D)

public interface Com{
    abstract void cry();                //A
    public int x = 0;                   //B
    static int y = 0;                   //C
}
abstract class Cat implements Com{
    abstract void cry();                //D
}

(4) (D)

interface Com{
    int MAX = 100;                      //A
    void f();
}
abstract class Animal implements Com{
    int MIN;                            //B
}
class Dog extends Animal{
    public void f(){
        MIN = 10;                       //C
        MAX = 200;                      //D
    }
}
4. 阅读程序题

  (1) 22

class A{
    int f(int x,int y){
        return x+y;
    }
}
class B extends A{
    int f(int x,int y){
        int m = super.f(x,y)+10;
        return m;
    }
}
public class E{
    public static void main(String[] args) {
        A a = new B();
        System.out.println(a.f(2,10));
    }
}

  (2) 6:6:100

class Animal{
    int m = 100;
    public int seeM(){
        return m;
    }
    public int getM(){
        return m;
    }
}
class Dog extends Animal{
    int m = 6;
    public int seeM(){
        return m;
    }
}
public class E{
    public static void main(String[] args) {
        Animal animal = null;
        Dog dog = new Dog();
        animal = dog;
        System.out.printf("%d:%d:%d",dog.seeM(),animal.seeM(),animal.getM());
    }
}

  (3) 18:18

interface Com{
    int add(int a,int b);
}
abstract class People{
    abstract int add(int a,int b);
}
class Student extends People implements Com{
    public int add(int a,int b){
        return a+b;
    }
}
public class E{
    public static void main(String[] args) {
        Student stu = new Student();
        Com com = stu;
        int m = com.add(12,6);
        People p = stu;
        int n = p.add(12,6);
        System.out.printf("%d:%d",m,n);
    }
}

  (4) 18:12:7:6

interface Com{
    int add(int a,int b);
    public static int get(int n){
        return n;
    }
    public default int see(int n){
        return n;
    }
    public default int look(int n){
        return n;
    }
}
class A implements Com{
    public int add(int a,int b){
        return a+b;
    }
    public int see(int n){
        return n+1;
    }
}
public class E{
    public static void main(String[] args) {
        A a = new A();
        int m = a.add(12,6);
        int n = Com.get(12);
        int t = a.see(6);
        int q = a.look(6);
        System.out.printf("%d:%d:%d:%d",m,n,t,q);
    }
}
因人成事
关注
  • 22
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
Java知识习题汇总【入门基础篇】
weixin_63544745的博客
02-08 4285
入门基础篇练习题
java章节测试学习通
热门推荐
weixin_57038416的博客
12-23 1万+
java面向对象程序设计 章节测验答案 学习通
4.7 数组简介
黑猫警长的博客
08-20 324
在许多程序中，数组很重要。数组可以作为一种储存多个相关项的便利方式。我们在第10章中将详细介绍数组，但是由于循环经常用到数组，所以在这里先简要地介绍一下。 数组（array）是按顺序储存的一系列类型相同的值，如10个char类型的字符或15个int类型的值。整个数组有一个数组名，通过整数下标访问数组中单独的项或元素（element）。例如，以下声明： float a[20]; 声明a是一个内含20个元素的数组，每个元素都可以储存float类型的值。数组的第1个元素是a[0]，第2个元素是a[1]，以
Java基础习题大全
s1642622514的博客
02-14 1万+
Java基础练习题
为什么float类型会报错，而改成double类型就不会
baidu_38730364的博客
03-21 1900
java编译器看到0.1，会自动认为是double类型的值。float a=0.1  会认为把一个双精度的值赋予一个单精度浮点数。这种情况下，java不会为我们自动转换，只会报错提醒。方法:1.     float a=0.1f    明确指定0.1 是单精度浮点数，然后赋值给a2.     float a=(float)0.1      强制转换...
Java学习笔记
11-21
Java学习笔记 1、连接数据库步骤 2、不同数据库的驱动程序和连接字符串 3、连接数据库常见问题 4、B/S结构和C/S结构的区别 5、如何处理中文乱码问题 6、使用JavaMail发送注册验证邮件 7、不安全的用户名密码验证 8、...
java学习笔记总结
04-02
这份“java学习笔记总结”涵盖了作者在深入学习Java过程中积累的知识点和实践经验，旨在帮助读者理解和掌握Java的核心概念。 首先，Java的基础部分包括语法、变量、数据类型、运算符和流程控制。Java支持八种基本...
java学习笔记.zip
11-16
java学习笔记java学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记...
Java学习笔记学习笔记
最新发布
10-24
Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习...
java学习笔记markdown
03-12
【Java学习笔记Markdown版】是针对Java初学者和进阶者的一份详尽教程，以Markdown格式编写，便于阅读和整理。Markdown是一种轻量级的标记语言，它允许用户使用易读易写的纯文本格式编写文档，然后转换成结构化的HTML...
java学习笔记资源合集
05-25
java学习笔记 Java 自 1995 年诞生，至今有 16 年的历史，从诞生之日起，逐渐被广泛接受并成为推 动了 web 迅速发展。Java 的三种核心机制为虚拟机机制、代码安全机制、垃圾回收机制。 Java 最大的特点是平台无关性...
java学习笔记.pdf
12-28
"Java学习笔记" 本资源是一个关于Java编程语言的学习笔记，涵盖了Java的基础知识、语法、数据类型、变量、类型转换等方面的内容。 标题:"java学习笔记.pdf" 描述:"想自学的小伙伴可以看俺" 标签:"Java" 部分...
(完整版)最全的java学习笔记(必看).pdf
05-27
Java学习笔记 Java是一种流行的编程语言，广泛应用于Android应用程序开发、Web应用程序开发、桌面应用程序开发等领域。以下是Java学习笔记的摘要信息： 一、Java技术基础 * 1.1 编程语言：Java是一种面向对象的...
java学习笔记java学习笔记java学习笔记java学习笔记
07-31
java学习笔记
JAVA(第六版)——期末复习2
Liusr_lxy的博客
05-20 5924
Java期末复习2
有关数组的知识点
w583923769的博客
05-07 655
1.一维数组的定义格式为： 类型说明符  数组名［常量表达式］；  例如：  int a［10］;   它表示定义了一个整形数组，数组名为a，有10个元素。 2.在定义数组时，需要指定数组中元素的个数，方括弧中的常量表达式用来表示元素的个数，即数组长度。 3.常量表达式中可以包括常量和符号常量，但不能包含变量。 注意： C语言不允许对数组的大小作动态定义，即数组的大小不依赖于程序运行过
第三章问题
weixin_43502549的博客
10-12 1026
1.以下语句执行后输出什么？ printf("%d",0x17); 输出为23 解析：十六进制·以0x开头 printf("%f",1e2); 输出为100.000000 解析：1e2=1*10的2次方，又因为以float格式输出，所以小数点后保留6位小数。 printf("%c",'\141'); 输出为a，\是转义字符，后面跟的141是八进制数字，转为十进制是97。 2.字符串“ab\‘12\n”包含多少有效字符？ 6个 3....
Java面试题-1.基础
qq_42717823的博客
01-27 250
1.JVM、JRE 和 JDK 的关系 2.什么是跨平台性？原理是什么？ 3.&和&&的区别？ 4.用最有效率的方法计算 2 乘以 8 5.在没有使用临时变量的情况如何交换两个整数变量的值？ 6.short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗? 7.float f=3.4;是否正确？ 8.手动实现一下冒泡排序（快速排序） 9.实现打印指定行数的空心菱形的功能 10.题目：将一个正整数分解质因数。例如：输入

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

因人成事

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值