程序语言与编程实践5-> Java实操2 | 第二周作业及思路讲解 | 基础知识强化考察

是这样的，Java这门课没有给线上实验评测平台（我还专门上平台上看了看），第一周作业出得挺好，也就算了，第二周作业形式差别有点大，全是基本概念题，确实有些东西听课看书不怎么注意。既然给的是这种形式，我尽量锻炼自己不开编译器、人脑编译的能力。

一个挺好的地方：浙大的PTA测试平台

0322补充，语法确实有一些还不熟练的地方..后面的编程题挺好..

00 运行结果题

第1道

import java.io.*;
public class abc {
    public static void main(String args [ ])
    {
         AB s = new AB(\"Hello!\",\"I love JA V A.\");
 	 System.out.println(s.toString());
    }
}
class AB {
    String s1;
    String s2;
    public AB(String str1, String str2)
    {
        s1 = str1; s2 = str2;
    }
    public String toString( )
    {
        return s1+s2;
    }
}

预期输出结果应该为：

Hello!I love JA V A.

考察的是java类、字符串的拼接、toString()函数。

第2道

import java.io.* ;
public class abc {
    public static void main(String args[ ])
    {
        int i, s = 0 ;
        int a[ ] = { 10 , 20 , 30 , 40 , 50 , 60 , 70 , 80 , 90 };
        for ( i = 0 ; i < a.length ; i ++ )
            if ( a[i]%3 == 0 ) s += a[i] ;
 	    System.out.println(\"s=\"+s);
    }
}

预期结果：

s=180

考察循环与拼接符。

第3道

import java.util.Scanner;
public class abc {
    public static void main(String args[ ])
    {
        Scanner in =new Scanner(System.in);
        int a = in.nextInt();
        int b = in.nextInt();
        System.out.println(\"a=\"+a+\"\\nb=\"+b);
	}
}

这道题有问题，应该输入a和b的。

预期结果：

//输入
4 5 
//输出
a=4
b=5

考察拼接符吧。

第4道

public class Test {
    public static void main(String[] args)
    {
         int percent = 10;
         tripleValue(percent);
 	 System.out.println(percent);
    }
    public static void tripleValue(int x)
    {
        x = 3 * x;
    }
}

预期结果;

10

考察，java函数的内存情况，引用传参和形式传参，这道题函数调用了，但是没有返回值。

第5道

假设类 A 有构造函数 A(int a)，在类 A 的其他构造函数中调用该构造函数用语句为 ( this(x) )

原因解释：书上有例子：

public Employee(String name, int age, double salary){
    this.name = name;
    this.age = age;
    this.salary = salary;
}
public employee(){
    this(\"刘明\",25,3000);
}
//如果是其他构造函数调用构造函数，这个this语句必须是函数里的第一行；

第6道⭐

public class Test {
    public static void main(String[] args)
    {
        new Test();
    }
    static int num = 4;
    {
        num += 3;
        System.out.println(\"b\");
    }
    int a = 5;
    { // 成员变量第三个
        System.out.println(\"c\");
    }
    Test() {
        System.out.println(\"d\");
    }
    static {
        System.out.println(\"a\");
    }
    static void run() {
        System.out.println(\"e\");
    }
}

预期结果：

a
b
c
d

0322，这个没怎么看明白。

0323，看了看网上有关static执行次序的讲解1 / 讲解2 / 讲解3，类中执行顺序的优先级为：静态代码块>main>普通代码块>构造方法，静态代码块在文件被执行时，首先类就被初始化，这时候静态代码块就被执行，输出a b，newTest没有输出值，所以继续普通代码块和构造方法。

虚拟机对Java类进行首次加载时，会对静态代码块，静态成员变量，静态方法进行一次初始化加载。

•  三者的执行顺序是：静态成员变量，静态代码块，最后执行静态方法。为什么呢？方法肯定是被调用才执行，这个好说。变量和代码块呢？举例，假如代码块中用到了变量怎么办呢？所以肯定先加载成员变量。
  

• 调用new方法才会创建类的实例
• 类实例创建过程中，按照父子关系进行初始化。首先是初始化父类静态代码块，然后子类静态代码块。然后依次是

•  父类的初始化代码块，父类构造方法，子类初始化代码块，子类构造方法
  

• 类实例销毁的时候也是先销毁子类，然后是父类

1. 所以我大胆推测，如果把new Test()去掉，那么就只有a输出
2. 如果main函数里改为只有Test.run()，那么只有a e 输出
3. 扔进编译器结果都对。＜（＾－＾）＞！

第 7 题

public class x {
    private static int a;
	public static void main(String[] args)
    {
        modify(a);
        System.out.println(a);
    }
    public static void modify(int a) 
    {
        a++;
    }
}

预期结果：

0

0322：这个似懂非懂。

0323：从第 6 题，第 7 题页很好理解，modify函数被调用了，但是没有输出a，a此时只是形参，函数结束后a++的临时结果随着函数销毁而销毁了，没有传回main函数，所以main函数里的a还是0。

01 程序设计题

第一题

题目

请写一个程序, 类名叫 HelloWorld，类里面有一个成员方法 sayHello()，这个方法能向控制台输出 HelloWorld。

代码

package homework_week2;
/**
 *
 * @author zzrs123
 */
public class Homework_week2 {
    public static void main(String args[]){
        Helloword test = new Helloword();
       // System.out.println(test);
    }

    private static class Helloword {

        public Helloword() {
            SayHello();
        }
        void SayHello(){
            System.out.println(\"Helloworld\");
        }
    }

输出结果正常。但感觉很怪，倒不是因为输出不在main函数，而是因为刚构造完对象，就结束了...

第二题

这道题有点意思。

题目

声明并测试一个复数类，其方法包括 toString() 以及复数的加减乘除运算。

代码

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package homework_week2_1;
import java.util.Scanner;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import static java.lang.String.valueOf;

/**
 *
 * @author zzrs123
 */
public class Complex {
    /**
     * @param args the command line arguments
     */
 
    public double real;
    public double imagine;
    //构造函数,后来发现必须需要一个无参构造函数
    public Complex(){
        this.real = 0;
        this.imagine = 0;
    }
    public Complex(double real,double imagine){
        this.real = real;
        this.imagine = imagine;
    }
    public Complex addtwocomplex(Complex x, Complex y){
        Complex sum = new Complex(x.real+y.real,x.imagine+y.imagine);
        return sum;
    }
    public Complex subtwocomplex(Complex x,Complex y){
        Complex sub = new Complex(x.real-y.real,x.imagine-y.imagine);
        return  sub;
    }
    public Complex muxtwocomplex(Complex x,Complex y){
        Complex mux = new Complex(x.real*y.real-x.imagine*y.imagine, x.real*y.imagine+x.imagine*y.real);
        return mux;
    }
    //突发奇想想算出来模平方和共轭，再来算除法
//    public double squcomplex(Complex x){
//        return Math.pow(x.real,2)+Math.pow(x.imagine, 2);
//    }
//    public Complex adjcomplex(Complex x){
//        return new Complex(x.real,-x.imagine);
//    }
    //然后发现更麻烦了，下面的报错是因为复数类和double不能相除。要实现还得另外写函数定义这种运算
//    public Complex exctwocomplex(Complex x,Complex y){
//        Complex exc = muxtwocomplex(x,adjcomplex(y))/squcomplex(y);
    public Complex divtwocomplex(Complex x,Complex y){
          //除数不能为0
        if(y.real==0&&y.imagine==0){
            System.out.println(\"除数为0，错误\");
            System.exit(0);
        }
        else{
            double real1 = x.real*y.real-x.imagine*y.imagine;
            double imagine1 = x.real*y.imagine+x.imagine*y.real;
            double squre = Math.pow(y.real, 2)+Math.pow(y.imagine, 2);
            return new Complex(real1/squre,imagine1/squre);
        }
        return null;
    }
    public String toString(){//一定记得这里是无参的，否则复写失败
        //第一次写的时候没有考虑负数以及两个都为0的情况
        //想让输出的标准一点情况还挺多的
        if(this.real==0.0 && this.imagine==0.0){
            return valueOf(0.0);
        }
        else if(this.real==0.0){
            return this.imagine+\"i\";
        }
        else if(this.imagine==0.0){
            return valueOf(this.real);
        }
        else if(this.imagine < 0){
            return this.real+\"\"+this.imagine+\"i\";
        }
        else{
            return this.real+\"+\"+this.imagine+\"i\";
        }
        //return this.real+\"+\"+this.imagine+\"i\";
    }    
      
    public static void main(String args[]) throws IOException{
        double a1, b1;
        double a2, b2;
        Scanner in = new Scanner(System.in);
        a1 = in.nextDouble();
        b1 = in.nextDouble();
        a2 = in.nextDouble();
        b2 = in.nextDouble();
        Complex com1 = new Complex(a1,b1);
        Complex com2 = new Complex(a2,b2);
        
        System.out.println(\"你输入的两个复数是：\");
        System.out.println(com1.toString());
        System.out.println(com2.toString());
        
        System.out.println(\"两复数之和为：\");
        Complex add = new Complex();
        add = com1.addtwocomplex(com1,com2);
        System.out.println(add.toString());
        
        System.out.println(\"两复数之差为： \");
        Complex sub = new Complex();
        sub = com1.subtwocomplex(com1, com2);
        System.out.println(sub.toString());
        
        System.out.println(\"两复数之积为： \");
        Complex mux = new Complex();
        mux = com1.muxtwocomplex(com1, com2);
        System.out.println(mux.toString());
        
        System.out.println(\"两复数之商为： \");
        Complex div = new Complex();
        div = com1.divtwocomplex(com1, com2);
        System.out.println(div.toString());
    }
}

02 问答题

题目

“static”关键字是什么意思？java 中是否可以覆盖(override)一个 private 或者是 static 的方法？

解答

“static”关键字修饰的成员变量或者成员方法可以直接通过类名访问。

方法重载Overloading和方法覆盖Overriding的区别：

• Overloading：两个方法的方法名相同，参数表不一样；
• Overriding：在子类中定义一个方法，正好跟父类中的一个方法一模一样（返回类型、参数表、名字），那么子类优先使用子类中的这个方法，这时候就发生了覆盖Overriding。

解答在教材《Java语言程序设计》的P129页。

父类中的static可以被继承，但不能被覆盖，如果子类定义了跟父类一模一样的方法，那么父类的static方法被隐藏。

private方法不可以覆盖，因为private修饰的变量和方法只能在当前类中使用，不能被继承和被其他的类访问。

来源：https://www.cnblogs.com/Roboduster/p/16046917.html
本站部分图文来源于网络，如有侵权请联系删除。