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

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

教材学习内容总结

第四章部分已在假期完成，详见博客：

• 《Java程序设计》第四章-认识对象

第五章部分

何谓封装

• 封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度,仅对外提供公共访问方式，隐藏对象细节,将对象当作黑箱进行操作。
• 书中介绍了一个银行钱款存取的例子，我觉得非常形象，将对象进行封装，其实是为了更好的利用对象。
• 你可以在你定义的类中，创建属性、方法，如果人家需要用到相应的功能，只需要拿着你的“类设计图”去设计一个“对象实例”，再根据你公开提供的方法，就可以使用相应的功能了。
• 封装对象，感觉有点像C语言中的模块化编程，不过C语言中一般将自定义函数和主函数放在一个程序中来调用，但Java中做到了一类一文件，而且在Java中更灵活方便。
• 我假设了一个情景，比如你和你的小伙伴要做一个大程序，不可能等着他编完他的部分了，你再去编写，这样效率极低。但是有了封装对象，你可以根据设计好的功能，先撰写相应的方法，最后直接调用就行，大大提高了编程的效率。
• 也可以像书中提到的，使用private对关键信息进行隐藏，设置访问数据的程度，防止用户的恶意使用。

类语法细节

• public

  • 用在类前，表示的这个类是公开类，这样就可以在其他包的类中使用。
  • 用在方法前，这样就表示其它包中的方法可以直接调用这个方法。这里需要注意的是，如果类上没有声明public关键字，类中的方法就算是public，也等于是包权限了，因为类本身是包权限，其它包就根本无法使用类，更别说当中定义的方法。
  • 用在函数前，这表示其它包中的类可以直接调用这个构造函数。
  • 用在成员变量前，表示这个成员变量是公开的，这样别人可以直接调取你类中的变量。

• private

  • 用在成员变量前，这是一种保护机制，不让自己这个类以外的方法去随便使用存取这个类的数据，可以保护私有数据，只能通过调用自己类的方法去操纵这些数据，这样会很安全。
  • private如果用在类或方法前，程序就会报错（我试着将类的前面写成private）。不过，其实也可以用在方法或构造函数声明上，私有方法或构造函数通常是类内部某个共享的演算流程，外借不用知道私有方法的存在。一般用在内部类声明中。

• public & private

  • 一般来说，我自己感觉public用在类、方法、函数前，private用在成员变量前，这样用户就可以通过你类中提供的方法和函数来进行操作，但是不会改变类中私有数据。这样，既能满足用户的使用，又能保护自己的数据不被随意更改。

• 方法重载（Overload）

  • 根据自己的理解，重载就好比是用相同的词表达多种不同的含义。
  • 只要参数类型和个数不同，就可以定义多个构造函数。这样程序设计人员不用苦恼方法名称的设计，可用一致的名称来调用类似功能的方法。
  • 与返回值无关，构造函数不一定关心它的返回值，可能只是想利用其中的某个功能。所以，如果像下面这样调用方法：f()；此时Java如何才能判断该调用哪一个f()呢？因此，根据方法的返回值来区分重载方法是行不通的。

• this与super

  • 除了被声明为static的地方外，this关键字可以出现在类中的任何地方，在对象建立后为“这个对象”的参考名称。
  • super一般用在父类中，指代父类对象的参考名称。
  • 如果定义一个新的类：A,这个A继承了类B,也就是说B是A的父类。那么如果A中 有个方法：aa();B中也有个方法： aa();那么在A 中用this.aa()调用的就是A中定义的方法，而super.aa()调用的就是A的父类B中定义的方法aa();。

• final

  • 用在类前，表明这个类不能被继承。也就是说，如果一个类你永远不会让他被继承，就可以用final进行修饰。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。在使用final修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承或者出于安全的考虑，尽量不要将类设计为final类。
  • 用在方法前，使用final方法的原因有两个：第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中，不需要使用final方法进行这些优化了。因此，如果只有在想明确禁止 该方法在子类中被覆盖的情况下才将方法设置为final的。注：类的private方法会隐式地被指定为final方法。
  • 用在成员变量前，修饰变量是final用得最多的地方，也是本文接下来要重点阐述的内容。首先了解一下final变量的基本语法：对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。

• static：所有对象公有的

  • static用于修饰成员变量和成员函数，被声明为static的成员，不会让个别对象拥有，而是属于类。
  • 由于static成员是属于类，而非个别对象，所以在static成员中使用this，会是一种语意上的错误。
  • 访问惯例：类名.static成员(一般不用参考名称)

• import static 的用法

  • 与import一样，这样做是为了偷懒，但要注意名称冲突的问题。

• 变长参数

  • 在调用方法时，如果自变量的个数事先无法决定，则可以在声明参数列时在关键字后加上...，实际上不定长度自变量是编译程序蜜糖。
    • 需要注意的是：函数如果有多个参数，变长参数必须是最后一个。

• 内部类

  • 可以在内中再定义类，内部类亦可以使用public、protected、private声明。
  • 一个被声明为static的内部类，通常是将外部类当作名称空间。例如：Some.Other o = new Some.Other();

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

  • 传值通过画图理解起来更容易（课本P148-P150），代码如下：

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

第四章部分已在假期完成，详见博客：

• 《Java程序设计》第四章-认识对象
• 关于课本P121页斐波那契数列，考虑到了递归函数的调用，写了一个新代码如下：

	import java.util.Scanner;

	public class Fibonacci{
		public static void main(String[] args){
			System.out.printf("求几个费氏数？");
			Scanner scanner = new Scanner(System.in);
			int n = scanner.nextInt();
			for(int i=0; i<n; i++)
				System.out.print(fib(i+1) + " ");
			System.out.println();
		}
		public static long fib(int x){
			if(x==1)
				return 0;
			else if(x==2)
				return 1;
			else
				return (fib(x-1) + fib(x-2));
		}
	}

• 分析：

  区别	寒假代码	上述代码
  数组元素的类型	int型（可计算到n=47）	long型（可计算到n=93）
  自定义函数	无	调用递归函数
  运行速度	一直都很快	n<35时速度比较快，当n>50时速度明显减慢

• 结论：运用递归速度变慢的原因是，没一个斐波那契数的生成都需要从fib(n)递归到fib(1)，大大影响了代码的运行效率；寒假的代码，则通过数组存储前面每一个值，在进行后续的运算时直接调用即可。所以，一个程序的编写会有多种不同的算法，只有自己试验后，才能判断出代码的好坏，好的保留，坏的改进。

第五章书中部分代码调试

• 封装部分代码：

	import java.util.Scanner;

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

			Scanner console = new Scanner(System.in);
			for(CashCard card : cards) {
				System.out.printf("为 (%s, %d, %d) 储值：", 
						card.number, card.balance, card.bonus);
				card.store(console.nextInt());
				System.out.printf("明细 (%s, %d, %d)%n",
						card.number, card.balance, card.bonus);
			}
		}
	}

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

效果截图：

• 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 console = new Scanner(in);
			out.print("请输入姓名：");
			out.printf("%s 你好！%n", console.nextLine());
		}
	}	

效果截图：

• 不定长度自变量

	public class MathTool {
	    public static int sum(int... numbers) {
	        int sum = 0;
	        for(int number : numbers) {
	            sum += number;
	        }
	        return sum;
	    }
	}

• 传值代码

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

效果截图：

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

• 这周最大的进步就是把书上的代码基本都敲了一遍，并且用git上传到了开源中国。
  

  

• 这两章的知识可能较前三章内容晦涩一些，毕竟有点深奥。说深奥其实也不算深奥，只是我以前可能没接触过对象这一知识，不能理解对象存在的价值。当看完这两章内容后，有了一个大致的了解。接下来就是对课本中的代码进行敲写一一体会，就能更加清楚书中所说含义。最后再看书上的代码时，头脑中就可以模拟当时编译运行的画面，对对象相关知识的理解更加透彻。学习Java肯定要靠大量的代码来加深印象巩固知识，只有坚持自主学习积极敲代码，才能更好地掌握这门奇妙的语言。

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第一周	200/200	1/6	20/20	学会MarkdownPad2
第二周	150/350	1/7	15/35	理解了补码机制
第三周	500/850	1/8	25/60	初步了解了对象

参考资料

• Java学习笔记(第8版)
• 《Java学习笔记(第8版)》学习指导
• 积极主动敲代码，使用JUnit学习Java
• 浅析Java中的final关键字