20155219 2016-2017-2 《Java程序设计》第3周学习总结
2017-03-12 19:35
701 查看
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!!"); } }
代码运行结果如下图所示
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); } } }
结果如下图所示:
上述代码中,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); } } }
执行结果如下图所示:
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)); } }
代码执行结果如下:
在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);// } }
执行结果如下
方法 | 说明 |
---|---|
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的方法如下
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不能得到正确的值。代码如‘封装对象的操作流程’下贴的代码。得到的错误结果如下图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" 并截图
代码量截图:
运行 find src -name "*.java" | xargs cat | grep -v ^$ | wc -l 并截图
上周考试错题总结
错题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设计语句 |
计划学习时间:18小时
实际学习时间:21小时
改进情况:可以不参照书本打出想要的代码了,虽然有时还是会编译出错,但相较于上一周已经有了很大的进步。
有空多看看现代软件工程 课件 软件工程师能力自我评价表
参考资料
Java学习笔记(第8版)《Java学习笔记(第8版)》学习指导
...
相关文章推荐
- 20155226 2016-2017-2 《Java程序设计》第3周学习总结
- 20155324 2016-2017-2 《Java程序设计》第3周学习总结
- 20155215 2016-2017-2 《Java程序设计》第3周学习总结
- 20155231 2016-2017-2 《Java程序设计》第3周学习总结
- 20155301 2016-2017-2 《Java程序设计》第3周学习总结
- 20155208徐子涵 2016-2017-2 《Java程序设计》第3周学习总结
- 20155212 2016-2017-2 《Java程序设计》第3周学习总结
- 20155325 2016-2017-2 《Java程序设计》第3周学习总结
- 20155222 2016-2017-2 《Java程序设计》第3周学习总结
- #20155319 2016-2017-2 《Java程序设计》第3周学习总结
- 20155205 2016-2017-2 《Java程序设计》第3周学习总结
- 20155237 2016-2017-2 《Java程序设计》第3周学习总结
- 20155232 2016-2017-3 《Java程序设计》第3周学习总结
- 2016-2017-2 《Java程序设计》第3周学习总结
- 20155210 潘滢昊 2016-2017-2 《Java程序设计》第3周学习总结
- 20155211 2016-2017-2 《Java程序设计》第3周学习总结
- 20155316 2016-2017-2 《Java程序设计》第3周学习总结
- 20155219 2016-2017-2 《Java程序设计》第2周学习总结
- 20155224 2016-2017-2 《Java程序设计》第3周学习总结
- 20155338 2016-2017-2 《Java程序设计》第3周学习总结