20155219 2016-2017-2 《Java程序设计》第3周学习总结

教材学习内容总结

数组问题

-Scanner实例,猜数字。

package src.week1;
import java.util.Scanner;
public class g {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);//建立scanner实例
        int num=(int)(Math.random()*10);
        int guess;
        do {
            System.out.print("猜数字(0-9):");
            guess=scanner.nextInt();
        }while (guess!=num);
        System.out.println("year!!");
    }
}

代码运行结果如下图所示image
Scanner的NextInt()方法会看看标准输入中有无输入下一个字符串,有的话将至剖析为int型。
-使用java.math.BigDecimal

package src.week1;
import java.math.BigDecimal;
public class h {
    public static void main(String[] args) {
        BigDecimal op1=new BigDecimal("0.1");
        BigDecimal op2=new BigDecimal("0.1");
        BigDecimal op3=new BigDecimal("0.1");
        BigDecimal result=new BigDecimal("0.8");
        if(op1.add(op2).add(op3).equals(result)) {
            System.out.printf("==0.3");
        }
        else
            System.out.println("!=0.3");
        }
    }

java遵守浮点数运算规范,对于0.1会无限循环下去,无法精确,故可以使用java.math.BigDecimal方法,在创建时会剖析传入字符串,以默认精度进行接下来的运算。

  • 增强式for循环
package src.week2;
public class g {
    public static void main(String[] args) {
        int[][] cords={
                {1,2,3},
                {4,5,6}
        };//数组初始化
        int[][] cords1=new int[][]
        {
                {1,2,3},
                {4,5,6}
        };//数组也可以这样初始化
        for(int x=0;x<cords.length;x++)//数组有几行
        {
            for(int y=0;y<cords[x].length;y++)//每行有几个元素
            {
                System.out.printf("%2d",cords[x][y]);
            }System.out.println();
        }
        for (int[] hang:cords)//数组有几行
        {
            for(int lie:hang)//每行有几个元素
                System.out.printf("%2d",lie);
        }
    }
}

结果如下图所示:image
上述代码中,hang参考到的对象就是一维数组对象,外层for循环就是循环取得cords参考对象的每个索引,将参考到的对象指定给int[]类型的hang名称。cords.length的值就是问cords参考对象索引0de参考对象的长度是什么,答案是3.

  • 关于Integer实例问题
    对于以下二维数组,其建立了几个Integer实例?答案不是6个,是0个。其中有3个Integer[]类型的索引,分别参考至长度为2的Integer一维数组对象。但每个Integer一维数组的索引都参考至null。故答案为0.
Integer[][] cords=new Integer[3][2];
  • 数组的复制
package src.week1;
import java.util.Arrays;
public class d {
    public static void main(String[] args) {
        int scores1[]={1,2,3,4,5,6,7,8,9};
        int scores2[]=Arrays.copyOf(scores1,scores1.length);
        for(int a:scores2)
        {
            System.out.printf("%3d",a);
        }
        System.out.println();
        scores2[0]=99;
        for (int x:scores1)
        {
            System.out.printf("%3d",x);
        }
    }
}

执行结果如下图所示:image

package src.week1;
class clothes{
    String color;
    char size;
    clothes(String color,char size)
    {
        this.color=color;
        this.size=size;
    }
}
public class d {
    public static void main(String[] args) {
      clothes[] c1={new clothes("red",'l'),new clothes("red",'l')};
      clothes[]c2=new clothes[c1.length];
      for(int i=0;i<c1.length;i++)
      {
          c2[i]=c1[i];
      }
      c1[0].color="yellow";
        System.out.println(c2[0].color);
    }
}
for(int i=0;i<c1.length;i++)
      {
          clothes c=new clothes(c1[i].color,c1[i].size);//自行复制元素
          c2[i]=c;
      }

结果同样也是“yellow”,但这种复制被叫做浅层复制,仅仅是将c1中的每个参考对象也给c2每个索引来参考。相当于c1,c2索引的对象都是同一个。而深层复制行为也就是说,将c1每个索引参考的对象被复制后分别指定给c2的每个索引,即索引的参考对象相同但不是同一个。

字符串的比较

package src.week2;
public class h {
    public static void main(String[] args) {
        String a1="hello";
        String a2="hello";
        String a3=new String("hello");
        String a4=new String("hello");
        System.out.println(a1==a2);
        System.out.println(a3==a2);
        System.out.println(a3==a4);
        System.out.println(a1.equals(a2));
        System.out.println(a2.equals(a3));
        System.out.println(a3.equals(a4));
    }
}

代码执行结果如下:image在java中,以“”包括的字符串,只要内容完全相同,无论其出现几次,JVM都只会建立一个String实例,并在字符串池中进行维护。“==”用于指向对象完全相同两个实例才会出现true。而在上述代码中,a3和a4分别参考至新建的String实例。故得到的结果是false。但使用equals(),就可以得到不同的答案,因为其强调的是比较对象内容是否相同。

字符串基础

package src.week2;
public class h {
    public static void main(String[] args) {
        String a="adfaads";
        System.out.println(a);
        System.out.println(a.length());//取得字符串长度
        System.out.println(a.charAt(2));//取得字符串中第2个字符
        System.out.println(a.toUpperCase());//将字符串中的所有字符大写
        char[] cs={'a','a','d','f'};
        String b=new String(cs);
        char[]cs2=a.toCharArray();//将字符串以数组形式返回
        System.out.println("你的名字:" +a);//
    }
}

执行结果如下image

方法 说明
Byte.parseByte(a); 将a剖析成byte整数
Short.parseShort(a); 将a剖析成Short整数
    Long.parseLong(a);|将a剖析long整数
    Integer.parseInt(a);|将a剖析成Integer整数
    Float.parseFloat(a);|将a剖析成float整数
    Double.parseDouble(a); | 将a剖析成double整数
  • 封装对象初始流程
package src.week2;

    class cashcard
    {
        String number;
        int balance;
        int bonus;
        cashcard(String number,int balance,int bonus)
        {
            this.number=number;
            this.balance=balance;
            this.bonus=bonus;
        }
    }public class h {
    public static void main(String[] args) {
        cashcard[] a = {
                new cashcard("444", 455, 1),
                new cashcard("434", 455, 1),
                new cashcard("424", 455, 1),
        };
        for (cashcard cash : a) {
            System.out.printf("(%s,%d,%d)%n", cash.number, cash.balance, cash.bonus);
        }
    }
}

用java的构造语法,实现了对向初始化的封装,

  • 封装对象的操作流程
package src.week2;
import java.util.Scanner;
class cashcard
{
    String number;
    int balance;
    int bounce;
    cashcard(String number,int balance,int bounce)
            {
              this.number=number;
              this.balance=balance;
              this.bounce=bounce;
            };
    void store (int money)
    {
        if(money>0)
        {
            this.number+=money;
            if(money>=1000)
            {
                this.bounce++;
            }

        }else
        {
            System.out.println("储值不能为负");
        }
    }
    void charge(int money)
    {if(money>0)
    {
        if(money <=this.balance)
        {
            this.balance-=money;
        }
        else System.out.printf("钱不够了");
    }
        else System.out.printf("取值不能为负");
    }
    int exchange(int bounce)
    {
        if(bounce>0){
            this.bounce-=bounce;
        }
        return bounce;
    }
}
    public class h {
    public static void main(String[] args) {
        Scanner a=new Scanner(System.in);
        int money,bounce;
        money=a.nextInt();
        bounce=a.nextInt();
        cashcard a1=new cashcard("a111",100,5);
        a1.store(money);
        cashcard a2=new cashcard("a111",100,5);
        a2.charge(money);
        cashcard a3=new cashcard("a111",100,5);
        a3.exchange(bounce);
        }
    }

如果不用返回值,方法名称前可以用void。建立cashcard的方法如下
1.

cashcard [] a=
                {
                        new cashcard("a44",12,2),
                        ....
                }
cashcard a1=new cashcard("a111",123,1);
cashcard a2=new cashcard("a111",123,1);
cashcard a3=new cashcard("a111",123,1);

二者的前提是:

class cashcard
{
    String number;
    int balance;
    int bounce;
    cashcard(String number,int balance,int bounce)
            {
              this.number=number;
              this.balance=balance;
              this.bounce=bounce;
            };
  • 封装对象内部数据
class cashcard2
{
    private String number;
    private int balance;
    private  int bounce;//使用private定义私有成员
    }
int getBalance()
    {
        return balance;
    }
    int getBounce()
    {
        return bounce;
    }
    String getNumber()
    {
        return  number;//提供取值方法成员;
    }

此时我们封装了类私有数据,让用户无法直接存取,必须通过我所提供的方法,即要想调用private定义过的值,必须使用同一个包内的方法,并且用户也不会知道对象的内部细节。取值方法,形如getBalance(),等取值方法。

public权限修饰

  • 在不同包的类程序代码中,想要直接存取,就会出现错误。如果想要在其他包类程序代码中存取某包的类或者对象,则该类成员必须是公开成员,在Java重要加以public加以声明。
package src.week2;
public class p {//这是一个公开类;
    public static void main(String[] args) {//main()方法
    }
    public p(String number, int balance, int bounce)//这是公用构造函数;
    {

    }
    public static void main(int money)//公开方法;
    {
    }
    public int charge()//公开方法;
    {
return 4;
    }
}

声明类加上public后表示它是个公开类,其他包可以直接使用,在构造函数上声明public,表示其他包的类可以直接调用这个构造函数。在方法中声明public,表示其他包的方法中可以直接调用这个方法。同样也可以在数据成员上声明public。

  • main()方法是java应用程序的入口方法,没有这个方法,java程序无法编译。这个方法必须是public static void类型的。方法必须接受一个字符串数组的参数等等。

构造函数

-构造函数是与类名称同名,无需声明返回类型的方法。创建对象时,数据成员会初始化,如果没有指定初始值,会使用默认值初始化,参考P133表5.1。如果定义类时没有撰写任何构造函数,会自动加入默认构造函数,所以在没有撰写任何构造函数时,也可以这样以无自变量方式构造函数:

Some a=new Some();

注意:自行撰写的无参数无内容的构造函数不能成为默认构造函数。

构造函数与方法重裁

可以定义多个构造函数,只要参数类型或者个数不同。可用意志的名称来调用类似功能的方法,方法重裁可根据传递自变量的类型不同,也可根据参数列个数的不同来设计方法重裁。注意:返回值类型不同不可作为方法重裁的依据。

package src.week2;
public class p {//这是一个公开类;
    public static void main(String[] args) {//main()方法

    }
public  int some(int i)
{
    return 0;
}
    public  int some(int i)
    {
        return 0.0;
    }

以上编译出现两个错误:1.重复定义 2.返回值类型出错。

this的使用

在对象建立后为“这个对象”的参考名称。在构造函数参数与对象数据同名时,可以用this加以区别。

package src.week2;
public class  p{
    public static void main(String[] args) {
        
    }
    private int a=10;
    private String text="n.a.";
    public p(int a)
    {
        if(a>0)
        {
            this.a=a;
        }
    }
    public p(int a,String text)
    {
        this(a);
        if(text!=null)
        {
            this.text=text;
        }
    }
}

this()代表了调用另一个构造函数,至于调用哪个构造函数,则视调用this()时给的自变量类型与个数而定,可以避免程序中出现重复的语句。同时可以使用可以使用this()来进行调用函数,至于调用的是哪个函数则视调用this()时给的自变量类型与个数而定。

  • final关键字
    如果局部变量声明了final,表示设置后就不能在变动,如果函数中没有明确使用=指定值,就会编译出错
package src.week2;
 public class  p {
 final int x;//编译出错
     public static void main(String[] args) {
     }
     p()
     {
         
     }//如果调用这个函数,x就没有被赋值。编译出错
     p(int c,int b)
     {
         this(10);//相当于引用了p(int 10)即下面这个函数对final对象成员x设值
     }
 p(int x){
     this.x=x;//对final对象成员x设值
 }
}

static类成员

  • 被声明为static的成员,是将类名称作为名称空间。如下代码:
class ball{
    double a;
    static final double PI=3.1459;
}

就可以这样取得圆周率:

System.out.println(ball.PI);

注意:遵守命名习惯;static方法或者区块中不能出现this关键字。因为static成员属于类,而不是个别对象。

package src.week2;
 class ball {
     double a;
     static void a()
     {
         double i = this.a;
     }
     void c()
     {
     }
     static void v()
     {
         c();//隐含使用了this.c()
     }
}

就会出现编译错误。

不定长度自变量

-注意:int...声明的变量实际上展开为数组;在使用不定长度自变量时,必须是参数列中的最后一个,使用两个以上不定长度自变量也是不合法的,使用对象的不定长度自变量不能和方法相同。

内部类

package src.week2;
public  class p{
    public static void main(String[] args) {
        some a=new some();
        some.other o=a.new other();
        o.doother();
    }
}
class some{
    static int x=10;
    int y=7;
     class other{
        void doother()
        {
            System.out.println(x);
            System.out.println(y);//出现错误,static内部类不可存取外部类非static成员。
        }
    }
}

内部类本身可以存取外部类的成员。虽然将外部类当作名称空间,但也算是个独立的类,它可以存取外部类static成员,但不可存取外部类非static成员。

教材学习中的问题和解决过程

  • 问题1:如下代码
package src.week2;
import java.math.BigDecimal;
public class k {
    public static void main(String[] args) {
        int x=100; int u=100;
        System.out.println(x==u);
        BigDecimal a=new BigDecimal(1);
        BigDecimal b=new BigDecimal(1);
        System.out.println(a==b);
    }
}

为什么结果是true,false。

  • 解决方案尝试了下述代码
Integer x=100; Integer u=new Integer(100);

得到的结果是false。书上只说了以“”包括的字符串,只要内容完全相同,无论其出现几次,JVM都只会建立一个String实例,并在字符串池中进行维护。“==”用于指向对象完全相同两个实例才会出现true。而int类型也是如此,只有 Integer u=new Integer(100);新建一个实例才会指向不同。

  • 问题2:P119页第三题在编程时出现编译失败。不清楚原因。
  • 解决方案书上P111页的例子是String类型的,上网百度后知道了equals函数只能用于String类的比较,并且其比较的是地址,而==比较的是内容;

代码调试中的问题和解决过程

  • xx1问题:System.out.printf不能得到正确的值。代码如‘封装对象的操作流程’下贴的代码。得到的错误结果如下图image
  • xx1解决方案:
    因为这个int exchange (int bounce)函数有返回值,书中并没有打印其返回值,我尝试将它打印出来。首先我在结尾处加上
a3.exchange(bounce);System.out.printf("%n%d", a3.exchange(bounce));

但发现得出的是奇怪的数字并不是正确结果。于是我开始调试代码,发现在函数末位的返回值是正确的,我又在函数末位加上

System.out.printf("%n%d", this.bounce);

发现结果是正确的。最后发现错误所在,上述代码输入有误,不应该是"%n%d", a3.exchange(bounce)而应该是"%n%d", a3.bounce。最后可以得到正确答案。

代码托管

  • 代码提交过程截图:
    • 运行 git log --pretty=format:"%h - %an, %cd : %s" 并截图imageimage
  • 代码量截图:
    • 运行 find src -name "*.java" | xargs cat | grep -v ^$ | wc -l 并截图
    • image

上周考试错题总结

  • 错题1.填空:Linux Bash中,查找当前目录中前天创建的Java文件的命令是(find . –name *.java -ctime 2)
  • 原因与理解:没有真正理解查找的含义,查找创建的java文件——(find xxx.java).
  • 错题2.填空:~0b1011的十进制值是(-12)
  • 理解:计算机的一个byte为8位,1011在计算机中存放即为00001011,取反后得11110100,因为最高位为1,所以该数为负数,因此该数各位取反,末位加一后得10001100,即-12.
  • 错题3.判断:教材P51,第8 题 ,执行命令 java –cp classes cc.openhome.Main 和cd classes; java cc.openhome.Main;cd .. 等价。(OK)

学习进度条

代码行数(新增/累积) 博客量(新增/累积) 学习时间(新增/累积) 重要成长
目标 5000行 30篇 400小时
第一周 120/120 1/1 16/16 开始了JAVA学习的第一步!
第二周 346/466 1/2 23/36 了解并学习了Java基础语法
第三周 364/830 1/3 21/57 进一步了解java设计语句

参考:软件工程软件的估计为什么这么难软件工程 估计方法

参考资料