20145330《Java程序设计》第三周学习总结

20145330 《Java程序设计》第三周学习总结

第三周知识的难度已经逐步上升，并且一周学习两章学习压力也逐渐加大，需要更高效率的来完成学习内容，合理安排时间。

类与对象##

• 对象（Object):存在的具体实体，具有明确的状态和行为

• 类（Class):具有相同属性和行为的一组对象的集合，用于组合各个对象所共有操作和属性的一种机制

• 类是对象的设计图，对象是类的实例，生成对象要先定义类

• Clothes c1=new Clothes();

• c1是引用，在栈上

• new Clothes()在堆上生成对象

• 一个类xxx写成一个xxxx.java的习惯

• public class xxxx{}

• 尽量不要在一个类中写多个class，如果有多个class，也只能有一个类前面加public

• 一个xxxx.java要有一个包含main函数的xxxxTester.java的测试类

• 构造方法决定类生成对象的方式

  • this
    

  • new
    

• java.util.Scanner与java.math.BigDecimal

• ==与equals的区别

  - equals是逻辑上相等
  - ==是用在比较两个参考名称是否参考同一对象
  

• 以下是几个典型例子：

-ClassObject

package cc.openhome;
class Clothes{
String color;
char size;
}

   public class ClassObjectField {
    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);

    }
   }

-ClassObject DecimalDemo2

    import java.math.BigDecimal;

    public class ClassObjectDecimalDemo2 {

    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.3");
        if(op1.add(op2).add(op3).equals(result)){
            System.out.println("等于0.3");
        }
        else{
            System.out.println("不等于0.3");
        }
    }

    }

-Wrapper IntegerDemo

       public class WrapperIntegerDemo {
		 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(wrapper2));
   			 }
		}

-Array Score

		public class ArrayScore {
    	public static void main(String[] args) {
        int[] scores={88,81,74,68,77,67,89,98,89,80,};
        for(int i=0;i<scores.length;i++){
            System.out.printf("学生分数：%d%n",scores[i]);
        		}
    		}
		}

-Array XY

	public class ArrayXY {
   		public static void main(String[] args) {
        int[] [] cords={
                {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();
                }
    }

	}

对象封装##

• 封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度，隐藏对象细节，将对象当做黑箱进行操作

  • 通过构造函数封装初始化流程
  • 通过成员方法封装操作
  • 通过成员变量封装数据

• 封装与SRP原则

• 封装的好处

  • 模块化
    • Source code indefendence
    • Object Passing
  • 隐藏信息
    • 对象内部的状态被保护起来了，不会被与该对象沟通的对象直接修改
    • 对象内部特征的变化不会改变与其他对象沟通的方式

• 语法类细节

  • public
    • 用在类前
    • 用在方法前
    • 用在成员变量前
  • private
  • 方法重载（Overload）
    • 参数类型和个数不同
    • 与返回值无关

• this与super

• final

  • 用在类前
  • 用在方法前
  • 用在成员变量前

• static：所有对象公有的

  • 用在类前
  • 用在方法前
  • 用在成员变量前
  • 访问惯例：类名.static成员
  • 与c语言中static区分

• 变长参数

• 内部类

• Java中方法都是传值（Pass By Value)

  • 传值（Pass By Value,Call by value)
  • 传引用（Pass By Reference)

-Cash App

		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),
                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);
        }
       }
     }

-封装构造过程

-OverLoad Boxing

		class some{
   	 		void someMethod(int i){

       		 System.out.println("int版本被调用");
   	 	}
    	 void someMethod(Integer integer){
       	 System.out.println("Integer 版本被调用");
   		 		}
			}

		public class OverloadBoxing {
    	public static void main(String[] args) {
       	 some s=new some();
      	  s.someMethod(1);
   		 }
	}

问题与思考##

• 由于浮点数误差的关系，类似0.1+0.1不等于0.2。结论就是，如果要求精确度，那就要小心使用浮点数，而且别用==直接比较浮点数运算结果。
• ==是在比较两个名牌是否绑到同一对象上，equal是比较对象内容是否相同。
• 要多做课后练习多思考，这样才更有利于对知识的理解和吸收，有些知识当时理解了之后可能会忘掉，所以要及时整理以便之后的复习。

代码托管截图###

学习进度条##

	代码行数（新增/累积	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	3000行	30篇	400小时
第一周	50/ 50	2/2	20/20
第二周	100/150	2/4	18/38
第三周	200/400	1/5	22/60