Java编程思想(第4版)4——5章节小结 - Angel's Blog.

ing
 
 
软件开发,程序设计,前端设计
 
 
首页 > code > Java编程思想(第4版)4——5章节小结

Java编程思想(第4版)4——5章节小结

 

这两天又要开始做java的oop小程序,是老白给我们布置的task,嘿嘿;昨天下午就看了Java编程思想(thinking in java 4rd)的第四章和第五章的内容,收获很多的说,越来越爱看这本经典的书了;不过为了完成老白布置的任务,先暂时搁浅两天咯,嘿嘿:)

先更新一下我从第四章和第五章有用的内容(内容比较多,看客可能会眼花,不喜勿看,呵呵,我一向很民主的。):

1)控制流中的true和false:

在java中,不允许非boolean类型的内容作为boolean值使用(譬如以前我学过的c语言、javascript,在条件中允许使用0或者非0的任意数字来表示true或者false)。所以,只能通过 == 或者!=来进行比较,比较后产生一个boolean值(true或者false)。

2)while和do-while的区别:

do-while至少被执行一次,无论第一次的条件表达式成立否;

while则先判断条件表达式的成立性,然后才可以执行语句中的内容,否则不执行。

3)for循环:

 

for (初始化变量类型i; 关于i的条件; 对i的操作迭代)
{
}

注意:这里的i的作用域只针对整个for循环,也就是局部的。

for循环的控制表达式中,可以通过英文逗号分隔多个变量,但是要确保他们的类型一致。

demo:

	public static void main(String[] args)
	{
		PrintNo pn = new PrintNo();
		pn.Sum(200);//扔个参数
		for (int i = 1 , j = i + 10; i < 5; i++ , j = i * 2)
		{
			System.out.println("i = " + i + "nj = " + j);
		}
	}

用for循环写一个计算Fibonacci数(demo1):

demo1:

public class Fibonacci
{
	public static void main(String[] args)
	{
		int num1 = 1;//第一个Fibonacci数为1
		int num2 = 1;//第二个Fibonacci数为1
		int num3;//临时工,天朝愚民都懂得。
		//for循环
		Scanner input = new Scanner(System.in);
		System.out.println("请输入数字,然后会产生一个Fibonacci数字:");
		int counts = input.nextInt();
		for (int i = 2; i < counts; i++)
		{
			num3 = num1;
			num1 = num2;
			num2 = num3 + num2;
		}
		System.out.println("数字为"+counts+";n得到的Fibonacci为:" + num2+";");
	}
}

4)Java中的foreach遍历数组元素:

与c#相比,java中没有foreach关键字,不过还好,java中的遍历和c#使用方法差不多。

一个简单的demo2:

demo2:

public class ForeachTest
{
	public static void main(String[] args)
	{
		int[] i = {1 , 2 , 3 , 4 , 5};
		for (int x:i)//遍历数组i中的元素
		{
			System.out.println(x);
		}

		//将字符串中的元素转换成字符Char,然后再将遍历到的元素存放到数组中。
		for (char y : "Hi , I'm a Angel!!".toCharArray())
		{
			System.out.print(y+" ");//注意这里
		}
	}
}

二维数组的foreach遍历(demo3):

demo3:

 

public class ForeachNew
{
	public static void main(String[] args)
	{
		int[][] a = { {1 , 2 , 3 , 4} , {33 , 34} };

		for (int[] groups : a)
		{
			for (int elements : groups)
			{
				System.out.print(elements+" ");
			}
			System.out.println("");
		}
		System.out.println("**************************");
		//或者使用下面的也同样达到目的.
		for (int[] groups : a)
		{
			for (int elements = 0; elements < groups.length;elements++)
			{
				System.out.print(groups[elements]+" ");
			}
			System.out.println("");
		}
	}
}

5)关于return关键字:

1)指定给某个方法返回具体什么值(有返回类型的具体值)。

2)退出当前的方法(具体看当前的方法是否有返回值,如果有,则return的同时返回当前方法类型对应的一个值,否则直接return退出)。

也就是说,在return之前被执行的方法体中的内容会被执行,return之后的代码则不会被执行。

同样地,虽然void()方法没有返回类型,但是void方法体中就含有了隐式的return。

6)关于关键字break和continue:

break用来强行退出循环,不执行循环中剩余的语句;

continue用来停止执行当前的爹带,然后退回到循环的起始位置,等待下一次的迭代。

7)关于goto:

#好了,可以无视它了。

8)关于switch分支:

一个简单的demo:

demoSwitch:

import java.util.Scanner;
public class SwitchPrint
{
	public static void main(String[] args)
	{
		int statement = 0;
		Scanner input = new Scanner(System.in);
		System.out.println("请输入一个数字:");
		statement = input.nextInt();
			switch (statement)//如果将switch中的(statement)换成(1+2)?看是什么效果
			{
				case 1:
					System.out.println("输入的数字为1");
					break;//break不能少.
				case 2:
					System.out.println("输入的数字为2");
					break;//break不能少.
				case 3:
					System.out.println("输入的数字为3");
					break;//break不能少.
				default:
					System.out.println("egg ache , yes?");
					break;//没有必要强加一个break,因为default执行语句就自动跳出.
			}
	}
}

9)用构造器来初始化:

java中的这个构造器,我认为就是创建对象的时候使用的构造方法(也可以称为构造函数,但是我更喜欢将函数称为方法);

构造器(构造方法)的方法名必须和类名相同,而且不能有返回类型和返回值。

创建新的对象的时候,会给对象分配存储空间,且默认调用这个构造器(默认的无参构造方法)。

*需要注意:如果类中定义了一个有参数的构造方法,在创建对象的时候没有传入参数,这个时候会报错,这里需要也必须要显式的写出默认的无参构造方法,确保创建对象的时候不会出错。

demo4:

//定义的时候就被初始化
public class AlreadyInitClass
{
	public String a = "Angel";
	public static void main(String[] args)
	{
		AlreadyInitClass aric = new AlreadyInitClass();
//		aric.a = "ddd";
		System.out.println(aric.a);
		NonInitClass nic = new NonInitClass("玩");
//		NonInitClass nc = new NonInitClass();//这样创建无参对象会报错
		System.out.println(nic.b);
	}
}

//没有先进行初始化
class NonInitClass
{
	//仅仅只有带参的构造方法
	public NonInitClass(String message)
	{
		this.b = message;
	}
	public String b;
}

展示一个没有被初始化的String引用(demo5):

demo5:

public class InitString
{
	public String s;
	public static void main(String[] args)
	{
		InitString initS = new InitString();//创建对象的同时调用默认构造方法进行初始化。
		System.out.println(initS.s);//引用被初始化过了,null.
	}
}

10)关于方法重载:

方法的传入的不同参数个数,或者相同的参数个数但类型不同。其中,构造方法可以重载。

11)关于基本类型的重载:

基本类型的重载,将一个相对小的类型自动提升到相对大的类型。也就是说,写某一个方法,这个方法接受相对较小的基本类型作为参数。但是,如果传入的参数较大,需要强制转换成较小的类型(有损),否则没有强制转换直接传入肯定会报错。

一个简单的方法重载(demo6):

demo6:

public class Dogs
{
	public void bark()
	{
		System.out.println("barking..");
	}
	public void bark(String voice , int counts)
	{
		System.out.println(voice + " , " + counts + "times");
	}
	public void bark(int counts , String voice)//被视为重载+1
	{
		System.out.println(voice + " , "+ counts + "times");
	}
	public static void main(String[] args)
	{
		Dogs dogs = new Dogs();
		dogs.bark();
		System.out.println("+=============");
		dogs.bark("howling..." , 3);
		System.out.println("==============");
		dogs.bark(20, "wangwang");
	}
}

12)关于this关键字:

this关键字只允许在方法的内部使用(方法体),用来表示调用方法的那个对象的引用。

还是一个很蛋疼的demo7:

demo7:

public class TwoMethods
{
	public void method1()
	{
		// TODO Auto-generated method stub
		method2();
		this.method2();//同一类中没有必要使用this.访问方法,直接调用方法即可。
	}
	public void method2()
	{
		// TODO Auto-generated method stub
		System.out.println("print method2");
	}
	public static void main(String[] args)
	{
		TwoMethods tm = new TwoMethods();
		tm.method1();
	}
}

13)构造方法中调用构造方法(demo8):

demo8:

public class TwoLoad
{
	public TwoLoad()
	{
		this("哈哈");
		System.out.println("I'm the 1st method");
//		this("哈哈");//在方法体内必须第一个执行,使用this,否则报错.
	}
	public TwoLoad(String msg)
	{
		System.out.println("I'm the 2nd method , " + msg);
	}
	public static void main(String[] args) {
		TwoLoad tl = new TwoLoad();
	}
}

14)static更深刻的理解:

用static关键字修饰的方法中,调用的方法必须都是静态的,所以也就不存在this。。

关于终结处理和垃圾回收:

这个不多说,还是用java好哇。

显示的静态初始化:

直接把例子的代码transplant下来了(demo9):

demo9:

public class Door
{
	public Door(int marker)
	{
		System.out.println("DOor" +marker);
	}
	public void f(int marker)
	{
		System.out.println("final" + marker);
	}
	//直接在这里写一个main方法测试
	public static void main(String[] args)
	{
		System.out.println("在main方法里测试。。。");
		Doors.door1.f(100);//(1)
	}
//	static Doors doors1 = new Doors();//(2)
//	static Doors doors2 = new Doors();//(2)
}

class Doors
{
	public Doors()
	{
		System.out.println("DOors...");
	}
	static Door door1;
	static Door door2;
	static{door1 = new Door(1);door2 = new Door(2);}//静态初始化实例对象

}

在这里,可以直接运行此代码,或者将//(1)处注释,//(2)处解除注释,同样会达到静态初始化的工作。

15)非静态实例初始化:

和显示的静态初始化相对应,非静态实例初始化少了static关键字,其余的几乎是一样的,但这个是支持匿名内部类。

16)数组的初始化:

需要注意:数组也是引用类型,支持数组对象的赋值,这样便引入了同一对象。

引入同一对象(demo10):

demo10:

public class ArrayOfPrimit
{
	public static void main(String[] args)
	{
		int[] a = {1 ,2 ,3 ,4 , 5};
		int[] b;
		b = a;
		for (int i = 0; i < b.length; i++)
		{
//			a[i] += 1;
//			a[i] = a[i] + 1;
//			b[i] = b[i] + 1;
			b[i] += 1;
//			b.length = 1;//final cannont be..
			System.out.print(a[i] + " ");
		}
	}

另一个demo(Integer作为demo):

demo11:

public class ArrayClassObj
{
	public static void main(String[] args)
	{
		Random random = new Random(88);
		Integer[] a = new Integer[random.nextInt(20)];
		System.out.println("数组的长度为:" + a.length);
		for (int i = 0; i < a.length; i++)//将遍历到的random.nextInt()方法中的元素存到数组里
		{
			a[i] = random.nextInt(666);
		}
		System.out.println(Arrays.toString(a));
	}
}

数组中可以用大括号内括起来的列表初始化对象数组:

demo12:

public class ArrayInit
{
	public static void main(String[] args)
	{
		Integer[] x = {new Integer(1) , new Integer(2) , 3 , };//style(1)
		Integer[] y = new Integer[] {new Integer(1) , new Integer(2) , 3 , };
		//style(2)Mark+
		System.out.println(Arrays.toString(x));
		System.out.println(Arrays.toString(y));
	}
}

在这里,数组初始化列表最后一个逗号可以省略(可写可不写)。其中,在main()中的“style(2)”处的代码,和c中的可变参数列表相似。

17)关于可变参数列表(以Object基类为demo13):

demo13:

 

public class VarArgs
{
	static void printArray(Object [] args)
	{
		// TODO Auto-generated method stub
		for (Object obj :args)
		{
			System.out.print(obj + " " + "(" + obj.getClass() + ")" + " ");

		}
		System.out.println();
	}
	public static void main(String[] args)
	{
		printArray(new Object[]{new Integer(52) , new Float(9.98) , new Double(2.00)});
		printArray(new Object[]{"star" , "moon" , "sun"});
		printArray(new Object[]{40 , 2.86f , 2.0d});
		printArray((Object[])new Integer[]{1 , 2 , 3 , 4});
//		printArray(new Integer[]{1 , 2 , 3 , 4});
	}
}
//看看打印的结果是否和预期的一样呢?

可变参数列表和自动包装混合使用在一起的情况(demo14):

demo14:

 

public class NewDemo
{
	static void myInteger(Integer... args)
	{
		for (Integer i : args)
		{
			System.out.print(i + " ");
		}
		System.out.println();
	}
	public static void main(String[] args)
	{
		myInteger(new Integer(1) , new Integer(2));
		myInteger(3 , 4 , 5);
		myInteger(new Integer(6) , 7 , new Integer(8));
	}
}
//打印看看效果,是否和预期的一样?

可变参数列表和重载混合的使用(demo15):

 

 

demo15:

 

public class OverloadAndArgs
{
	public static void main(String[] args)
	{
		functions('A', 'B');
		functions(1 , 2);
		functions(3);
		functions("Angel" , "34455" , "870805");
	}
	static void functions(Integer...args)
	{
		for (Integer i : args)
		{
			System.out.print(i + " " + "(" + i.getClass() + ") ");
		}
		System.out.println();
	}

	/**
	 * Okay ,overload function.
	 */
	static void functions(String... args)
	{
		// TODO Auto-generated method stub
		for (String s : args)
		{
			System.out.print(s + " " + "(" + s.getClass() + ") ");
		}
		System.out.println();
	}
	static void functions(Character... args)
	{
		// TODO Auto-generated method stub
		for (Character c : args)
		{
			System.out.print(c + " " + "(" + c.getClass() + ") ");
		}
		System.out.println();
	}
	//好了,返回main()去看测试效果吧。
}

应该注意到…和[]

18)java中的枚举enum:

很明显嘛,java中的enum不如 c#用着方便。。不过java 中的enum,可以用c#的方式进行揣摩。

好了,写一个demo吧(以性别为例,demo16)。

demo16:

 

public class MyEnum
{
	public MyEnum(String nickName , Gender genders)
	{
		setNickName(nickName);
		setGenders(genders);
	}
	private String nickName;
	public String getNickName() {
		return nickName;
	}
	public void setNickName(String nickName) {
		this.nickName = nickName;
	}
	/*
	 * 只关心enum就ok了。
	 */
	public enum Gender
	{
		Male , Female;
	}
	private Gender genders;
	public Gender getGenders() {
		return genders;
	}
	public void setGenders(Gender genders) {
		this.genders = genders;
	}
	public void MyInfo(String hobby)
	{
		System.out.println("我的名字:" + nickName + "n性别:" + genders
				+ "n爱好:" + hobby);
	}
	/*
	 * 写一个main方法
	 */
	public static void main(String[] args)
	{
		MyEnum me = new MyEnum("Angel", Gender.Male);
		me.MyInfo("技术");
	}
}
//打印一下看看是什么?。

附加一个Enum的例子(demo17):

demo17:

 

public class Weather
{
	public static void main(String[] args)
	{
//		MySpiciness howHot = MySpiciness.Cold;
//		System.out.println(howHot);
//		System.out.println(howHot.ordinal());
		for (CityWeather c : CityWeather.values())
		{
			System.out.print(c + " " + "(index:" + c.ordinal() + ") ");
		}
	}
}
enum CityWeather
{
	Hot , Cold , Cloud , Rain , Snow
}

enum和switch分支的结合(demo18):

demo18:

 

public class MyStatus
{
	/*
	 * 创建main()测试吧。
	 */
	public static void main(String[] args)
	{
		MyStatus ms = new MyStatus(Status.Best);
		ms.myInfo();
	}
	public MyStatus(Status s)
	{
		// TODO Auto-generated constructor stub
		this.s = s;
	}
	Status s;
	private void myInfo()
	{
		// TODO Auto-generated method stub
		System.out.print("我的当前心情:");
		switch (s)
		{
			case Good:
				System.out.print("很好n");
				break;
			case Better:
				System.out.println("还好吧n");
				break;
			case Best:
				System.out.println("非常棒!n");
				break;
			case Normal:
				System.out.println("一般化n");
				break;
			default:
//				break;
		}
	}
}
//介个enum不多说。。
enum Status
{
	Good , Better , Best , Normal
}

好了,就先写这么多吧,还要继续做java oop的小项目;欢迎看客和java达人们从中指出错误,我好学习学习。

或者通过RSS 关注本站的更新 ^ O ^ 。” —  by  转载请注明:来自 Angel's Blog.
本文永久链接: http://www.0ee.com/2010/12/29/summary-thinking-in-java-4-5-chapter.html
 
分类: code标签: ,
 
  • QQ书签
  • Del.icio.us
  • 百度收藏
  • Google
  • 饭否
  • FriendFeed
 

 
评论 (18) Trackbacks (0)
发表评论 Trackback
 
18 Comments Contributed by Visitors
  1.     学夫子 2010年12月30日14:56 11#

    能从这里面总结出思想,是相当的有意思的

  2.     Angel 2010年12月31日13:29 12#

    @学夫子
    嗯,嘿嘿,重要的是能学到以前没学过的东西,总结下来作为学习参考。

  3.     Angel 2011年1月1日02:47 13#

    @vastar
    新年快乐 ok 嘿嘿,以后专注java,不过未来的未来还不知道,可能是python吧。

  4.     云在天边 2010年12月31日16:06 14#

    2011元旦好哦!

  5.     Angel 2011年1月1日02:46 15#

    @云在天边
    才发现你的email换了 ok
    嘿嘿,大家好才是真的好。

  6.     Mucid 2011年1月1日10:33 16#

    我经常用while代替for循环,foreach就是for循环嘛,前世不写void……基本不用goto……

  7.     Code之行人 2011年1月2日15:25 17#

    娃,可真的好长啊,辛苦啊 呵呵, 善于积累

  8.     Angel 2011年1月3日05:35 18#

    @Code之行人
    恩,嘿嘿,学习就是积累下来的。
    (Via wap blog)

Leave Comments Here...

:) :-D :( :-o 8-O :-? 8) lol :-x :-P oops cry evil twisted wink ? idea :-| arrow mrgreen roll !

(required)

(required)

网址随您("http://"可以省略)

(Ctrl+Enter)

  • 本站不会泄露您的 Email 地址, 敬请放心.
  • 本站已开启缓存, 请不要重复提交评论.
  • 请注意: 带有 《广告(链)、不健康、或者 产品名字》 的评论一律视为spam.
  • 支持常用 HTML 标签调用, 插入 HTML 标签需注意: < == &lt;> == &gt;.
  • 仅当某人针对您的评论做出回应时, 您才会收到由本站发出的邮件通知.
  • 如您希望以相同方式通知某位网友, 请点击  按钮进行回复.
  • 允许在评论中使用如下代码: 
    <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> 
    <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong> 
    .
  • 鼠标悬浮到评论中的 @someone 区域即可自动显示 someone 的评论内容.
 
 
  • 正在加载...