20145227 《Java程序设计》第3周学习总结

20145227 《Java程序设计》第3周学习总结

教材学习内容总结

第四章 认识对象

4.1 类与对象

1、定义类：生活中描述事物无非就是描述事物的属性和行为。如：人有身高，体重等属性，有说话，打球等行为。Java中用类class来描述事物也是如此。

  • 属性：对应类中的成员变量。
  • 行为：对应类中的成员函数。
  • 定义类其实在定义类中的成员(成员变量和成员函数)。
  • 代码如下：
class Clothes 
{
String color;
char size;
}

public class Field
{
    public static void main(String[] args)
    {
Clothes sun = new Clothes();
Clothes spring = new 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);
}
}

  • 结果截图：

  • 构造函数中，由于参数与数据类型重名，需使用this将参数值指定给参数。定义构造函数代码如下。

class Clothes2
{
String color;
char size;
Clothes2(String color, char size)
{
this.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);
}
}
  • 结果截图：

2、使用标准类：

  • 使用java.util.Scanner
  • 代码如下：
import java.util.Scanner;

public class Guess
{
public static void main(String[] args)
{
Scanner scanner = new Scanner (System.in);
int number = (int) (Math.random() * 10);
int guess;

do
{
    System.out.printf("GUESS A NUMBER:");
    guess = scanner.nextInt();
}
while(guess != number);

System.out.println("YOU ARE RIGHT!");

}
}
  • 结果截图：

  • 使用java.math.BigDecimal
  • 代码如下：
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比较相等代码如下：
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");
}


}
}
  • 结果截图：

4.2 基本类型打包器

1、打包基本类型：基本类型long、int、double、float、boolean等，在J2SE5.0之前必须亲自使用Long、Integer、Double、Float、Boolean等类打包为对象，才能当做对象来操作。

  • 代码如下：
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));
}
}
  • 结果截图：

2、自动装箱、拆箱：

  • 自动装箱运用的方法可以如下：
int i=10;
Integer wrapper=i;
  • 可以用Number类来自动装箱：
Number number = 3.14f;
(3.14f会被先自动装箱为Float，然后再指定给number。)
  • 自动拆箱：即自动取出打包器中的基本形态信息。例如：
Integer wrapper = 10;    //自动装箱
int foo = wrapper;       //自动拆箱
（wrapper会参考至Integer，若被指定给int型的变量foo，则会自动取得打包的int类型再指定给foo。）

4.3 数组对象

1.数组基础

  • 声明数组来储存XY坐标位置要放的值代码如下：
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();
}
}
}
  • 结果截图：

2.操作数组对象：

  • 将每个学生成绩默认为60分起代码如下：
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);
    }
}
}
  • 结果截图：

3.数组复制：

  • 代码如下：
import java.util.Arrays;

public class Copy
{
    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;
        for(int score : scores1)
        {
            System.out.printf("%3d",score);
        }
    }   
}
  • 结果截图：

  • 深层复制代码如下：
class Clothes2
{
String color;
char size;
Clothes2(String color, char size)
{
    this.color=color;
    this.size=size;
}
}

public class DeepCopy
{
public static void main(String[] args)
{
        Clothes2[] c1 = {new Clothes2("red",'S'),new Clothes2("green",'M')};
    Clothes2[] c2 = new Clothes2[c1.length];
    for(int i = 0; i < c1.length; i++)
    {
        Clothes2 c = new Clothes2(c1[i].color, c1[i].size);
        c2[i] = c;
    }
    c1[0].color = "yellow";
    System.out.println(c2[0].color);
}
}
  • 结果截图：

4.4 字符串对象

1.字符串基础：由字符组成的文字符号称为字符串。

  • 用户输入整数，再输入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);
}
}
  • 结果截图：

2.字符串特性：

  • 字符串常量与字符串池：用“”写下的字符串称为字符串常量。

  • 不可变动字符串：在java中，字符串对象一旦建立，就无法更改对象中任何内容，对象上没有任何方法可以更改字符串内容。可以使用 + 连接字符串，改用StringBuilder来改善。

  • 代码如下：

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());
}
}
  • 结果截图：

4.5 查询API文档

  • 学习Java要学会使用Java API,在Windows下一定要下载CHM格式的Java API，这个版本具有检索功能，使用非常方便。

第五章 对象封装

5.1 何谓封装

  • 封装(Encapsulation)实际上是使用方法(Method)将类的数据隐藏起来，控制用户对类的修改和访问数据的程度,隐藏对象细节,将对象当作黑箱进行操作。
    1.通过构造方法（构造函数）封装初始化流程
  • 代码如下：
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 CardApp
{
public static void main(String[] args)
{
  CashCard[] cards={
        new CashCard("A001",500,0),
        new CashCard("A002",300,0),
        new CashCard("A003",1000,1),
        new CashCard("A004",2000,2),
        new CashCard("A005",3000,3)
};


for(CashCard card : cards) 
{
System.out.printf("(%s,%d,%d)%n",card.number,card.balance,card.bonus);
}
}
}

2.通过成员方法（函数）封装操作

  • 代码如下：
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);
}
}
}

3.通过成员变量封装数据

  • private关键字：是一个权限修饰符。用于修饰成员(成员变量和成员函数)。被私有化的成员只在本类中有效。 
  • 功能：将成员变量私有化，对外提供对应的set ，get 方法对其进行访问。可提高对数据访问的安全性。

5.2 类语法细节

1.public权限修饰

  • 如果没有声明权限修饰的成员，只有在相同包的类程序代码下才可以直接存取，也就是“包范围权限”。如果想在其他包的类程序代码中存取某包的类或对象成员，则该类或对象成员必须是公开成员，在java中要使用public加以声明。

2.关于构造函数

  • 特点：（1） 函数名与类名相同 ；（2）不用定义返回值类型； （3）不可以写return语句。
  • 作用： 给对象进行初始化。
  • 注意：（1） 默认构造函数的特点。（2） 多个构造函数是以重载的形式存在的。

3.方法重载

  • 代码如下：
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);
    }
}
  • 结果截图：

  • 如果想调用参数为Integer版本的方法则代码如下：
class Some
{
void someMethod(int i)
{
    System.out.println("int 版本被调用");
}
void someMethod(Integer integer)
{
    System.out.println("Integer 版本被调用");
}
}
public class Overload2
{
    public static void main(String[] args)
    {
        Some s = new Some();
        s.someMethod(new Integer(1));
    }
}
  • 结果截图：

3.this关键字

  • 特点：this代表其所在函数所属对象的引用。 换言之：this代表类对象的引用。
  • 什么时候使用this关键字呢？ 当在函数内需要用到调用该函数的对象时，就用this。
  • 代码如下：
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);
}
}
  • 结果截图：

4.static关键字

  • 用于修饰成员（成员变量和成员函数）
  • 被修饰后的成员具备以下特点：（1）随着类的加载而加载；（2）优先于对象存在；（3）被所有对象所共享；（4）可以直接被类名调用；
  • 使用注意：（1）静态方法只能访问静态成员；（2）静态方法中不可以写this，super关键字；（3）主函数是静态的。
  • import static语法代码如下：
  • 代码如下：
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());
}
}
  • 结果截图：

  • 代码托管截图

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

这次的内容相对前两周来说增加了很多，教材有些地方也晦涩难懂。不过通过看视频以及问问题，很多地方也明白了，不过还有很多地方都需要多看、多练习。

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

通过构造方法（构造函数）封装初始化流程时，教材上说构造函数是与类名称同名的方法，不用声明返回类型，但是编译时一直显示“方法声明无效，需要返回类型”。如下图所示：

解决途径：尚未解决。

其他（感悟、思考等，可选）

学习java已经三个星期了，这周学习了java第四章第五章的内容。这周编写的代码比上周多很多，感觉也更加熟练了。而且这周学会了托管代码。一开始托管代码不成功，后面根据同学博客上的步骤一步一步去做，最后终于成功托管了代码。过程很繁琐，但所幸努力有了回报，现在已经会托管代码了。

学习进度条

代码行数（新增/累积） 博客量（新增/累积） 学习时间（新增/累积） 重要成长
目标 5000行 30篇 400小时
第一周 200/200 2/2 20/20
第二周 200/400 1/3 20/40
第三周 500/900 1/4 30/70

参考资料

posted @ 2016-03-19 19:55  20145227鄢曼君  阅读(479)  评论(10)  编辑  收藏  举报