20145236 冯佳 《Java程序设计》第3周学习总结
2016-03-20 15:52
465 查看
20145236 《Java程序设计》第3周学习总结
教材学习内容总结
第四章 认识对象
一、面向对象和面向过程
•面向对象是相对面向过程而言 •面向对象和面向过程都是一种思想 •面向过程强调的是功能行为 •面向对象将功能封装进对象,强调具备了功能的对象。 •面向对象是基于面向过程的。 •面向对象的特征:封装 继承 多态
创建对象,使用对象
class Car//对Car这类事物进行描述 { String color = "red"; int num = 4; void show() { System.out.println("color="+color+"..num="+num); } } class CarDemo { public static void main(String[] args) { Car c = new Car();//建立对象 c.color = "black";//对对象的属性进行修改 c.show();//使用对象的功能。 } }
二、对象指定与相等性(“=” 和 “==”)
“=”用于基本类型时,是将值复制给变量,“==”用于基本类型时,是比较两个变量储存的值是否相同,如下面的程序:int a = 10; int b = 10; int c = a; System.out.println(a == b); //显示true System.out.println(a == c); //显示true
• ==操作比较的是两个变量的值是否相等,对于引用型变量表示的是两个变量在堆中存储的地址是否相同,即栈中的内容是否相同。
equals操作表示的两个变量是否是对同一个对象的引用,即堆中的内容是否相同。
==比较的是两个对象的地址,而equals比较的是两个对象的内容。
三、基本类型打包器
Java中有两个类型系统,即基本类型与类类型,使用基本类型目的在于效率,然而更多时候,会使用类建立实例,因为对象本身可以携带更多信息,如果要让基本类型像对象一样操作,可以使用Long、Integer、Double、Float、Boolean、Byte等类来打包(Wrap)基本类型。public class IntegerDemo { public static void main(String[] args) { int data1 = 10; int data2 = 10; Integer wrapper1 = new Integer(data1); //打包基本类型 Integer wrapper2 = new Integer(data2); System.out.println(data1 / 3); //基本类型运算 System.out.println(wrapper1.doubleValue() / 3); //操作打包器方法 System.out.println(wrapper1.compareTo(wrapper2)); } } output: 3 3.3333333333333335 0
基本类型打包器都是归类于java.lang包中,如果要使用Integer打包int类型数据,方法之一是用new创建Integer实例时,传入int类型数据。除了使用new创建基本类型打包器之外,从J2SE 5.0之后提供了自动装箱功能和自动拆箱功能。自动装箱与拆箱的功能事实上是编译程序蜜糖。
四、数组
数组在Java中就是对象。1.数组的创建:
元素类型[] 数组名= new 元素类型[]{元素,元素,……}; int[] arr = new int[]{3,5,1,7}; int[] arr = {3,5,1,7};
2.使用for循环,通过使用length属性获取数组长度:
int[] scores = { 88, 81, 74, 68, 78, 76, 77, 85, 95, 93}; for (int i = 0; i < scores.length; i++) { System.out.printf("学生分数:%d %n",scores[i]); }
3.使用增强式for循环:
for(int score:scores){ System.out.printf("学生分数:%d %n",score); }
五、字符串
字符串本质是打包字符数组的对象,是java.lang.String类的实例。字符串对象一旦建立,就无法更改对象中的任何内容,对象上没有任何方法可以更改字符串内容。输入整数,再输入0后会计算所有整数总和代码如下:
import java.util.Scanner; public class Sum { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); long sum = 0; long number = 0; do { System.out.print("输入数字:"); number = Long.parseLong(scanner.nextLine()); sum += number; } while(number != 0); System.out.println("总和为:"+sum); } }
运行结果:
•课后操作题3
下面是一个数组,请使用程序使其中元素排序为由小到大: int[] number = {70, 80, 31, 37, 10, 1, 48, 60, 33, 80}
package cc.openhome; class Number { public static void main(String[] args) { int[]arr=new int[]{70,80,31,37,10,1,48,60,33,80}; for (int c=0;c<arr.length ;c++ ) { for (int b=c+1;b<arr.length;b++ ) { if(arr[c]>arr[b]) { int tep=arr[c];//实现两个变量的值互换,由此可以排列出数组从小到大 arr[c]=arr[b]; arr[b]=tep; } } System.out.print(arr[c]+" ");//第一次跳出内循环:arr{9,12,56,45,10}第二次跳出:arr{9,10,56,45,12} } } }
运行结果:
第五章 对象封装
一、Java封装概念
在面向对象程式设计方法中,封装(英语:Encapsulation)是指,一种将抽象性函式接口的实作细节部份包装、隐藏起来的方法。 封装可以被认为是一个保护屏障,防止该类的代码和数据被外部类定义的代码随机访问。 要访问该类的代码和数据,必须通过严格的接口控制。 封装最主要的功能在于我们能修改自己的实现代码,而不用修改那些调用我们代码的程序片段。 适当的封装可以让程式码更容易理解与维护,也加强了程式码的安全性。
二、构造函数与方法重载
如果定义类时,没有撰写任何构造函数,编译程序会自动加入一个无参数、内容为空的构造函数,称为默认构造函数。可以定义多个构造函数,只要参数类型或个数不同,这称为重载构造函数。方法重载让程序设计人员不用苦恼方法名称的设计,可用一致的名称来调用类似功能的方法,方法重载可根据传递自变量的类型不同,也可根据参数列个数的不同来设计方法重载。
eg:
public class SomeClass { public void someMethod(){ } public void someMethod(int i){ } public void someMethod(float f){ } public void someMethod(int i,float f){ } }
编译程序在处理重载函数时,会依以下顺序来处理:
(1)还没有装箱动作前可符合自变量个数与类型的方法
(2)装箱动作后可符合自变量个数与类型的方法
(3)尝试有不定长度自变量并可符合自变量类型的方法
(4)找不到合适的方法,编译错误
三、static和final
•final定义的变量可以看做一个常量,不能被改变; •final定义的方法不能被覆盖; •final定义的类不能被继承。 •final static 就是再加上static的特性就可以了 •static和final是没有直接关系的 •static 是在内存中分配一块区域,供整个类通用,所有的类的对象都享有它的共同的值
教材学习中的问题和解决过程
在学习Java这么久了,我一直都不知道类到底是什么,只知道用class就能产生一个类,但是学了第四章,我才差不多明白,要产生对象必须先定义类,类是对象的设计图,对象是类的实例。类定义时使用class关键词,建立实例要使用new关键词。在对Java了解不多的时候只觉得这个东西很抽象,但是随着不断地敲书上的代码练习,现在已经能理解类的大概含义了。然而接下来就是数组了,虽然以前学C语言的时候接触过数组,但是对于数组还并不能熟练地掌握和运用,比如数组的复制,操作数组对象,必须要跟着书上的内容来编写数组代码验证结果。至于第五章的内容则是更加的抽象,因为我不明白为什么要封装,要怎样才叫封装?封装的意义是什么?还有什么是构造函数和方法重载?带着这些疑问,我将教材上的内容仔细的看了好几遍,努力的去理解,认真的去实践书上的程序,所以最终可能开窍了一点儿了。封装的目的主要就是隐藏对象细节,将对象当做黑箱进行操作。而对于static和final的区别:final可修饰类、域(变量和常量)、方法 ,而static不修饰类,static和final是没有直接关系的。
Java封装类实例:
public class EncapTest{ private String name; private String idNum; private int age; public int getAge(){ return age; } public String getName(){ return name; } public String getIdNum(){ return idNum; } public void setAge( int newAge){ age = newAge; } public void setName(String newName){ name = newName; } public void setIdNum( String newId){ idNum = newId; } }
代码调试中的问题和解决过程
•定义类。只要有一个类定义,编译程序机会产生一个.class文档。在Clothes类中,定义了color和size两个变量。•ClassObject Field.java
package cc.openhome; class Clothes //定义Clothes类 { String color; char size; } public class Field { public static void main(String[] args) { Clothes sun = new Clothes();//建立Clothes实例 Clothes spring = new Clothes();//建立Clothes实例 sun.color = "red"; sun.size = 'S'; spring.color = "green"; spring.size = 'M'; System.out.printf("sun(%s,%c)%n",sun.color,sun.size);//显示个别对象的数据成员值 System.out.printf("spring(%s,%c)%n",spring.color,spring.size);//显示个别对象的数据成员值 } }
运行结果:
•构造函数
•ClassObject Field2.java
package cc.openhome; class Clothes2 { String color; char size; Clothes2(String color, char size)//定义构造函数 { this.color=color;//color参数的值指定给这个对象的color成员 this.size=size; } } public class Field2 { public static void main(String[] args) { Clothes2 sun = new Clothes2("red",'S');//使用指定构造函数建立对象 Clothes2 spring = new Clothes2("green",'M'); System.out.printf("sun(%s,%c)%n",sun.color,sun.size); System.out.printf("spring(%s,%c)%n",spring.color,spring.size); } }
运行结果:
•使用标准类:使用java.util.Scanner
•ClassObject Guess.java
package cc.openhome; import java.util.Scanner;//告诉编译程序接下来想偷懒 public class Guess { public static void main(String[] args) { Scanner scanner = new Scanner (System.in);//建立Scanner实例 int number = (int) (Math.random() * 10); int guess; do { System.out.printf("猜数字(0—9):"); guess = scanner.nextInt();//取得下一个整数 } while(guess != number); System.out.println("猜中了...XD"); } }
运行结果:
•使用java.math.BigDecimal
•ClassObject DecimalDemo.java
import java.math.BigDecimal; public class DecimalDemo { public static void main(String[] args) { BigDecimal operand1 = new BigDecimal ("1.0"); BigDecimal operand2 = new BigDecimal ("0.8"); BigDecimal result = operand1.subtract(operand2); System.out.println(result); } }
运行结果:
•用BigDecimal比较相等
•ClassObject DecimalDemo2.java
package cc.openhome; import java.math.BigDecimal; public class DecimalDemo2 { public static void main(String[] args) { BigDecimal o1 = new BigDecimal ("0.1"); BigDecimal o2 = new BigDecimal ("0.1"); BigDecimal o3 = new BigDecimal ("0.1"); BigDecimal result = new BigDecimal("0.3"); if(o1.add(o2).add(o3).equals(result)) { System.out.println("等于0.3"); } else { System.out.println("不等于0.3"); } } }
运行结果:
•基本类型打包器
•Wrapper IntegerDemo.java
package cc.openhome; public class IntegerDemo { public static void main(String[] args) { int data1 = 10; int data2 = 20; Integer wrapper1 = new Integer(data1); //打包基本类型 Integer wrapper2 = new Integer(data2); System.out.println(data1/3); //基本类型运算 System.out.println(wrapper1.doubleValue()/3); //操作打包器方法 System.out.println(wrapper1.compareTo(w2)); } }
运行结果:
•声明数组来储存XY坐标位置要放的值
•Array XY.java
package cc.openhome; public class XY { public static void main(String[] args) { int[][] cords={ {1,2,3}, {4,5,6} }; for(int[] row : cords) { for(int value : row) { System.out.printf("%2d",value); } System.out.println(); } } }
运行结果:
•操作数组对象
•将每个学生成绩默认为60分起
•Array Score2.java
package cc.openhome; import java.util.Arrays; public class Score2 { public static void main(String[] args) { int[] scores = new int[10]; for(int score : scores) { System.out.printf("%2d",score); } System.out.println(); Arrays.fill(scores,60); for(int score : scores) { System.out.printf("%3d",score); } } }
运行结果:
•数组复制
•Array CopyArray.java
package cc.openhome; import java.util.Arrays; public class CopyArray { public static void main(String[] args) { int[] scores1 = {88,81,74,68,78,76,77,85,95,93}; int[] scores2 = Arrays.copyOf(scores1,scores1.length); for(int score : scores2) { System.out.printf("%3d",score); } System.out.println(); scores2[0] = 99;//不影响scorel参考的数组对象 for(int score : scores1) { System.out.printf("%3d",score); } } }
运行结果:
•字符串特性
•String Oneto100.java
package cc.openhome; public class One { public static void main(String[] args) { StringBuilder builder = new StringBuilder(); for(int i = 1; i < 100; i++) { builder.append(i).append('+'); } System.out.println(builder.append(100).toString()); } }
运行结果:
•通过成员方法(函数)封装操作
•Encapsulation2 CashAPP.java
package cc.openhome; import java.util.Scanner; public class CashApp { public static void main(String[] args) { CashCard[] cards={ new CashCard("A001",500,0), new CashCard("A002",300,0), new CashCard("A003",1000,1) }; Scanner scanner = new Scanner(System.in); for(CashCard card : cards) { System.out.printf("为(%s,%d,%d)储值:",card.number,card.balance,card.bonus); card.store(scanner.nextInt()); System.out.printf("明细(%s,%d,%d)%n",card.number,card.balance,card.bonus); } } }
运行结果:
这个程序不知道是哪里出了问题,应该是CashCard的问题,但是目前还没有解决。
•构造函数与方法重载
•Class OverloadBoxing.java
class Some { void someMethod(int i) { System.out.println("int 版本被调用"); } void someMethod(Integer integer) { System.out.println("Integer 版本被调用"); } } public class Overload { public static void main(String[] args) { Some s = new Some(); s.someMethod(1); } }
运行结果:
•使用this
•Class ObjectlnitialBlock.java
package cc.openhome; class Other{ { System.out.println("对象初始区块"); } Other() { System.out.println("Other() 构造函数"); } Other(int o ) { this(); System.out.println("Other(int o ) 构造函数"); } } public class ObjectInitialBlock { public static void main(String[] args) { new Other(1); } }
运行结果:
•static类成员
•Class ImportStatic.java
package cc.openhome; import java.util.Scanner; import static java.lang.System.in; import static java.lang.System.out; public class ImportStatic { public static void main(String[] args) { Scanner scanner = new Scanner(in); out.print("请输入姓名:"); out.printf("%s 你好!%n",scanner.nextLine()); } }
运行结果:
•不定长度自变量
•Class MathTool.java
package cc.openhome; public class Main{ public static int sum(int... numbers){ int sum = 0; for(int number:numbers){ sum+=number; } return sum; } }
•传值调用
•Class CallByValue
public class CallByValue { public static void main(String[] args) { Customer c1 = new Customer("Justin"); some(c1); System.out.println(c1.name); Customer c2 = new Customer("Justin"); other(c2); System.out.println(c2.name); } static void some(Customer c) { c.name = "John"; } static void other(Customer c) { c = new Customer("Bill"); } } class Customer { String name; Customer(String name) { this.name = name; } }
运行结果:
•代码托管
其他(感悟、思考等,可选)
我觉得通过这两章内容的自学,自己又掌握了很多知识,对于自己的Java程序设计又达到了一个新的突破,虽然书上的概念性的知识好多还是没有;理解,但是我按照老师布置的学习任务去做,把书上的代码挨着敲了一遍,当然,虽然是原搬的,但是发现还是遇到了错误的地方,很多还是自己粗心输错了,或者少输了,就导致代码编译不通过。所编代码一定要认真认真再认真,因为有可能少输一个分号就可能使代码运行不成功。但是通过敲这些代码,从中我也掌握了很多技巧性的东西,所以 这周的学习让我收获颇丰。但是有一个最大的问题!代码托管不会弄,研究了一下午都没托管上去,简直爆炸!!!但是后来通过咨询同学,看了好多相关的博客,终于成功的将代码都推送上去了。学习进度条
代码行数(新增/累积) | 博客量(新增/累积) | 学习时间(新增/累积) | 重要成长 | |
---|---|---|---|---|
目标 | 5000行 | 30篇 | 400小时 | |
第一周 | 200/200 | 2/2 | 20/20 | |
第二周 | 300/500 | 2/4 | 18/38 | |
第三周 | 500/1000 | 1/5 | 40/78 |
参考资料
Java学习笔记(第8版)《Java学习笔记(第8版)》学习指导
...
相关文章推荐
- Java自动装箱和拆箱定义
- struts2中的constant配置
- 关于 Java 中 正则表达式的 MULTILINE 标志
- Spark读取Hbase中的数据
- JAVA多线程之(CountDownLatch)
- JS基本类型与Java的区别复习
- Leetcode: 125. Valid Palindrome(JAVA)
- Eclipse调试常用技巧
- java安全(三)摘要算法MD5
- java大数计算
- Spring自定义属性编辑器及原理解释.md
- Java初始化顺序
- 设计模式--策略模式
- Eclipse调试常用技巧
- spring4配置jackson报错解决
- Java经典设计模式详解
- 教你如何使用泛型(二)
- PyDev for Eclipse
- LeetCode--Substring with Concatenation of All Words(java)
- java集合框架——List