JAVA编程：Java进修条记

先谈谈我对java的一些认识。我选择java，是因为他语法简单，功能强大，从web，到桌面，到嵌入式，无所不能。但当我进一步了解了java后，感叹，java原来也有许多缺点。条记本条记是在看浙年夜翁恺先生的视频教授教养时所做，但愿对Java初学者有匡助！
1、Java基本
1、准确熟悉Java
（1）Java是一种有临盆力的OOP言语，C++能做的Java都能做
（2）Java与收集干系不年夜，更不是用来做网页的
（3）Java是UNIX天下的产品，具有UNIX的头脑
（4）Java在外洋普遍的被用来做各类使用
2、Java汗青
（1）Brithday：May23，1995
（2）1991：Set-Topbox：JameGosling
（3）1994：OAKandFirstPerson
（4）1995：JavaandHotJava-Internetplay
3、Java情况
编译实行
Java源程序------>字节码文件----->Java假造机---->Linux、Windows、Mac
4、Java平台
（1）TheJavaVirtualMachine（JavaVM）
（2）TheJavaApplicationProgrammingInterface（JavaAPI）
5、Java特性
（1）CrossPlatform/Portable
Portable：thedreamfromUNIXandCtoJava
1)JVM
2)Uniquedatatype
Int:32-bit
Char:16-bit,Unicode
（2）Capacity：highorlow?
Low:
1)Interpreted
2)Codecheck
3)Stackmachine
High
1)JIT
2)Mutil-thread
3)Bytecodesimpledesign
（3）Stableandsecure
1)Nopoint
2)Indexcheck
3)Automemorymanagement
（4）Simple：KISS
1)C++like
2)Nopoint
3)Automemorycheck
（5）PureOOP
Java=C++--
1)Mutil-inheritance
2)Virtualinheritance
3)Template
4)Operatoroverloading
（6）Dynamic
1)Java没有传统的程序的观点
2)Java以为全球的类和对象是一个空间
3)Java你写的程序的编译了局是这个空间的一部分
4)Java所谓的运转程序就是从空间中某类的某个特别的办法开式启动
（7）Storageofobjects
1)ForC,efficiencyisthemostimportant,soprogrammerscanmakedecisionbytheirown.
2)ForJava,allobjectsshouldbeconstructedinruntimeandbestoredinheap.
（8）Createanddestroyobjects
1)Youmustcreateyourobjects
2)Butcannotdestroythembyyourself
3)Thereisarecyclemechanismtohelpcleanupobjectsthatwillneverbeusedagain.
（9）Container
Isanobjecttoholdotherobjects
1)vector
2)stack
3)queue
（10）Root
1)EveryclassinJavaisadescendantofoneclass：Object
2)SoallobjectsinJavaisobjectsoftheclassObject.
3)Inthisway,containerisanobjectthatcanholdobjects.
（11）handle
1)Youcannotholdtheobjectitself,instead,youcanhaveahandlethatrefertoit.
Strings;
2)Heresisonlyahandlethatrefertonothing.
（12）new
Strings=newString("aString");
1)AnobjectofStringiscreated
2)Theobjectisinitializedw/"astring"
3)AvariableashandletoStringiscreated
4)Thevalueofthehandlevariableisassigntotheobject
（13）Primitivetypes
boolean1-bittruefalse
char16-bitUnicode
byte8-bit-127~128
short16-bit-32767~32768
int32-bit
long64-bit
float32-bit
double32-bit
（14）FirstJavaProgram
classHelloWorld
{
publicstaticvoidmain(String[]args)
{
System.out.print("HelloWorld!");
}
}

2、深切进修Java
1、创建新的数据范例：class
classATypeName{
/*classbodygoeshere*/
}
2、办法、参数和前往值
returnTypemethodName(/*argumentlist*/)
{
/*Methodbody*/
}
Java中的办法只能作为类的一部分创立
3、赋值
1)当"fromoneobjecttoanother"赋值，实践上是将句柄从一个中央赋值到另外一个中央
-Case:Assignment.java
//:Assignment.java
//Assignmentwithobjectsisabittricky
classNumber{
inti;
}

publicclassAssignment{
publicstaticvoidmain(String[]args){
Numbern1=newNumber();
Numbern2=newNumber();
n1.i=9;
n2.i=47;
System.out.println("1:n1.i:"+n1.i+",n2.i:"+n2.i);
n1=n2;
System.out.println("2:n1.i:"+n1.i+",n2.i:"+n2.i);
n1.i=27;
System.out.println("3:n1.i:"+n1.i+",n2.i:"+n2.i);
}
}
2)将一个对象传送到办法外部时，也是赋值
-Case:PassObject.java
//:PassObject.java
//Passingobjectstomethodscanbeabittricky
classLetter{
charc;
}

publicclassPassObject{
staticvoidf(Lettery){
y.c=z;
}

publicstaticvoidmain(String[]args){
Letterx=newLetter();
x.c=a;
System.out.println("1:x.c:"+x.c);
f(x);
System.out.println("2:x.c:"+x.c);
}
}
4、干系运算符
干系运算符==和!=页能对任何对象举行，可是它们的寄义经常令人利诱
-Case:Equivalence.java
//:Equivalence.java
publicclassEquivalence{
publicstaticvoidmain(String[]args){
Integern1=newInteger(47);
Integern2=newInteger(47);
System.out.println(n1==n2);
System.out.println(n1!=n2);
}
}
5、String运算符+
+运算符能够用来毗连字符串
intx=0,y=1,z=2;
StringsString="x,y,z";
System.out.println(sString+x+y+z);
System.out.println(y+z+sString);
6、Break和continue
1)Aplaincontinuegoestothetopoftheinnermostloopandcontinues.
2)Alabeledcontinuegoestothelabelandre-entersthelooprightafterthatlabel.
3)Abreak"dropsoutofthebottom"oftheloop.
4)Alabeledbreakdropsoutofthebottomoftheendoftheloopdenotedbythelabel.
-Case:LabeledFor.java
//:LabeledFor.java
//Java"labeledforloop"
publicclassLabeledFor{
publicstaticvoidmain(String[]args){
inti=0;
outer://Canthavestatementshere
for(;true;){//infiniteloop
inner://Canthavestatementshere
for(;i<10;i++){
prt("i="+i);
if(i==2){
prt("continue");
continue;
}
if(i==3){
prt("break");
i++;//Otherwiseinever
//getsincremented
}
if(i==7){
prt("continueouter");
i++;//Ohterwiseinever
//getsincremented
continueouter;
}
if(i==8){
prt("breakouter");
breakouter;
}
for(intk=0;k<5;k++){
prt("k="+k);
if(k==2){
prt("continue");
continue;
}
if(k==4){
prt("breakinner");
k++;//Otherwiseknever
//getsincremented
continueinner;
}
}
}
}
}
staticvoidprt(Strings)
{
System.out.println(s);
}
}
7、初始化和扫除
Asthecomputerrevolutiionprogresses,"unsafe"programminghasbecomeoneofthemajorculpritsthatmakesprogrammingexpensive.
1)初始化和扫除事程序计划平安性的两个最主要的成绩
2)C++为我们引进了机关函数的观点，Java也相沿了这个观点，但新增了本人的渣滓搜集器
8、用机关函数主动初始化
假如某个类有一个机关函数，那末在创立对象的时分，Java会主动挪用谁人机关函数，机关函数的名字和类的名字不异
-Case:SimpleConstructor.java
//:SimpleConstructor.java
//Demonstrationofasimpleconstructor
classRock{
Rock(){//Thisistheconstructor
System.out.println("CreatingRock");
}
}

publicclassSimpleConstructor{
publicstaticvoidmain(String[]args){
for(inti=0;i<10;i++)
newRock();
}
}
9、Methodsoverloading
Oneoftheimportantfeaturesinanyprogramminglanguageistheuseofnames.
我们用名字援用或形貌一切对象与办法。在一样平常生存中，我们用不异的词表达多种分歧的寄义，即词的“重载”
年夜多半程序计划言语请求我们为每一个函数都设定一个举世无双的标识符。可是机关函数的呈现请求函数名也可以“重载”
Often,thesamewordexpressesanumberofdifferentmeanings--itsoverloaded.
-Case:Overloading.java
//:Overloading.java
//Demonstrationofbothconstructorandordinarymethodoverloading
importjava.util.*;

classTree{
intheight;
Tree(){
prt("Plantingaseedling");
height=0;
}
Tree(inti){
prt("CreatingnewTreethatis"+i+"feettall");
height=i;
}
voidinfo(){
prt("Treeis"+height+"feettall");
}
voidinfo(Strings){
prt(s+":Treeis"+height+"feettall");
}
staticvoidprt(Strings){
System.out.println(s);
}
}

publicclassOverloading{
publicstaticvoidmain(String[]args){
for(inti=0;i<5;i++){
Treet=newTree(i);
t.info();
t.info("overloadedmethod");
}
//Overloadedconstructor:
newTree();
}
}
10、辨别重载办法
1)每一个重载的办法都必需接纳举世无双的自变量范例列表
2)前往范例重载？？
11、缺省机关函数
1)假如一个类没有界说机关函数，则编译程序会帮我们主动创立一个缺省机关函数
2)但是一旦界说了一个机关函数，就不会帮我们主动天生一个
12、this
1)this关头字能够为已挪用了其办法的谁人对象天生响应的句柄
-Case:Leaf.java
//:Leaf.java
//Simpleuseofthe"this"keyword
publicclassLeaf{
privateinti=0;
Leafincrement(){
i++;
returnthis;
}
voidprint(){
System.out.println("i="+i);
}
publicstaticvoidmain(String[]args){
Leafx=newLeaf();
x.increment().increment().increment().print();
}
}
2)在一个机关函数中挪用另外一个机关函数时，用this关头字
-Case:Flower.java
//:Flower.java
//Callingconstructorswith"this"
publicclassFlower{
privateintpetalCount=0;
privateStrings=newString("null");
Flower(intpetals){
petalCount=petals;
System.out.println("Constructorw/intargonly,pet"+petalCount);
}
Flower(Stringss){
System.out.println("constructorw/Stringargonly,pet");
s=ss;
}
Flower(Strings,intpetals){
this(petals);
//!this(s);//Cantcalltwo!
this.s=s;//Anotheruseof"this"
System.out.println("String&intargs");
}
}
机关函数挪用必需是机关函数的第一条语句，而且不克不及在一个机关函数挪用两个以上的机关函数
13、扫除：扫尾和渣滓搜集
1)渣滓搜集机制只晓得如何开释由new分派的内存，一切它不晓得怎样开释对象的“特别”内存。一旦渣滓搜集机制筹办好开释对象占用的存储空间，它起首挪用finalize()。
2)可是finalize()和C++的系构函数一模一样
渣滓搜集不即是析构
对象大概不会被当作渣滓被搜集失落
渣滓搜集只跟内存有关
14、成员初始化
Javagoesoutofitswaytoguaranteethatanyvariableisproperlyinitializedbeforeitisused.
因为任何办法都能够初始化或利用谁人数据，以是在正式利用数据前，若另有强制程序员将其逐一初始化成一个得当的值，便可能不敷实践。因而，一个类的一切primitive数据成员城市包管取得一个缺省值。固然，句柄会取得null值。
15、界说初始化
一个间接的做法是在界说数据成员的同时也为其赋值
classMeasurement{
booleanb=true;
charc=x;
inti=47;
}
也能够用不异的办法初始化对象
classMeasurement{
Deptho=newDepth();
}
16、能够挪用一个办法举行初始化
clasClnit{
inti=f();//...
}
固然这个办法也能够利用参数
classClnit{
inti=f();intk=g(i);//...
}
可是那些参数不克不及是还没有初始化的别的数据成员
classClnitWrong{
intj=g(i);inti=f();//...
}
17、初始化按次
在一个类里，初始化的按次是由变量在类内的界说按次决意的。即便变量界说大批遍及于办法界说的两头，那些变量仍旧会在挪用任何办法只前失掉初始化－－固然在机关函数之前
-Case:OrderOfInitialization.java
//:OrderOfInitialization.java
//Demonstratesinitializationorder.
//Whentheconstructoriscalled,tocreateaTagobject,youllseeamessage:
classTag{
Tag(intmarker){
System.out.println("Tag("+marker+")");
}
}

classCard{
Tagt1=newTag(1);//Beforeconstructor

Card(){
//Indicatewereintheconstructor:
System.out.println("Card()");
t3=newTag(33);//Re-initializet3
}

Tagt2=newTag(2);//Afterconstructor

voidf(){
System.out.println("f()");
}

Tagt3=newTag(3);//Atend
}
18、静态数据初始化
1)静态的工具属于类
2)类Class与类对象
3)静态数据成员是在这个类的第一个对象要创立的时分初始化
-Case:StaticInitialization.java
//:StaticInitialization.java
//Specifyinginitialvaluesinaclassdefinition
classBowl{
bowl(intmarker){
System.out.println("Bowl("+marker+")");
}

voidf(intmarker){
System.out.println("f("+marker+")");
}
}

classTable{
staticBowlb1=newbowl(1);

Table(){
System.out.println("Table()");
b2.f(1);
}

voidf2(intmarker){
System.out.println("f2("+marker+")");
}

staticBowlb2=newBowl(2);
}

classCupboard{
Bowlb3=newBowl(3);
staticBowlb4=newBowl(4);

Cupboard(){
System.out.println("Cupboard()");
b4.f(2);
}

voidf3(intmarker){
System.out.println("f3("+marker+")");
}

staticBowlb5=newBowl(5);
}

publicclasStaticInitialization{
publicstaticvoidmain(String[]args){
System.out.println("CreatingnewCupboard()inmain");
newCupboard();
System.out.println("CreatingnewCupboard()inmain"):
newCupboard();
t2.f2(1);
t3.f3(1);
}

staticTablet2=newTable();
staticCupboardt3=newCupboard();
}
19、初始化按次
1)范例为Dog的一个对象初次创立时，大概Dog类的静态办法/数据初次会见时，Java注释器必需找到Dog.class
2)找到Dog.class后，它的一切的静态初始化模块城市运转。因而，静态初始化仅产生一次
3)创立一个newDog()时，new语句起首会在堆里分派一个充足的空间
4)这个空间将会被扫除为零，因而Dog中一切的数据成员都失掉了缺省值
5)实行界说初始化
6)实行机关函数
20、显式初始化
1)Java同意我们将别的静态初始化事情分别到类内一个特别的“静态机关从句”（又叫“静态块”）里
-Case:ExplicitStatic.java
//:ExplicitStatic.java
//Explicitstaticinitializationwiththe"static"clause.
classCup{
Cup(intmarker){
System.out.println("Cup("+marker+")");
}
voidf(intmarker){
System.out.println("f("+marker+")");
}
}

classCups{
staticCupc1;
staticCupc2;

static{
c1=newCup(1);
c2=newCup(2);
}

Cups(){
System.out.println("Cups()");
}
}
2)Java1.1能够用相似的办法初始化非静态数据成员
-Case:Mugs.java
//:Mugs.java
//Java1.1"InstanceInitialization"
classMug{
Mug(intmarker){
System.out.println("Mug("+marker+")");
}
voidf(intmarker){
System.out.println("f("+marker+")");
}
}

publicclassMugs{
Mugc1;
Mugc2;
{
c1=newMug(1);
c2=newMug(2);
System.out.println("c1&c2initialized");
}

Mugs(){

}
}
21、数组
1)数组代表一系列对象大概基础数据范例的对象都封装在一同－－接纳一个一致的标识符称号
2)数组的界说和利用是经由过程索引运算符举行的
int[]a;inta[];
3)Java不同意我们在数组界说时指定一个数组有多年夜
4)数组变量实践上是一个指向数组的句柄
-Case:Arrays.java
//:Arrays.java
//Arraysofprimitives.
publicclassArrays{
publicstaticvoidmain(String[]args){
int[]a1={1,2,3,4,5};
int[]a2;
a2=a1;
for(inti=0;i<a2.length;i++)
a2[i]++;
for(inti=0;i<a1.length;i++)
prt("a1["+i+"]="+a1[i]);
}
staticvoidprt(Strings){
System.out.println(s);
}
}
22、对象数组
1)关于对象数组，数组的成员实践上是句柄
-Case:ArrayClassObj.java
//:ArrayClassObj.java
//Creatinganarrayofnon-primitiveobjects.
importjava.util.*;
publicclassArrayClassObj{
staticRandomrand=newRandom();
staticintpRand(intmod){
returnMath.abs(rand.nextInt())%mod;
}
publicstaticvoidmain(String[]args){
Integer[]a=newInteger[pRand(20)];
prt("lengthofa="+a.length);
for(inti=0;i<a.length;i++){
a[i]=newInteger(pRand(500));
prt("a["+i+"]="+a[i]);
}
}
staticvoidprt(Strings){
System.out.println(s);
}
}
2)对象数组也能够界说初始化
-Case:ArrayInit.java
-Case:VarArgs.java
23、埋没实行历程－－会见把持
Aprimaryconsiderationinobject-orieenteddesignis"separationthethingsthatchangefromthethingsthatstaythesame."
1)每一个库的用户(clientprogrammer)必需能依附本人利用的库，并晓得一旦新版本的库推出，本人不必要改写代码
2)库创立者回声明哪些是客户程序员可使用的，哪些是不成以利用的
24、包：库单位
1)用import来援用包或包里的成员
importjava.util.*;
importjava.util.Vector;
2)之以是要如许的引进，是为了供应一种特别的机制，来完成定名空间的办理
25、编译单位
1)每一个编译单位必需是以.java开头的文件称号，在一个编译单位里，能够有一个public的类，这个类的名字必需与文件的名字不异，在一个单位内，只能有一个public的类
2)编译一个.java文件时，对应于文件中的每个类，会失掉一个.class文件，文件名和类名字不异。一个程序是一堆.class文件
26、界说包
1)一个库是一堆如许的.class文件。它们被界说为一个包，可是其实不真实的兼并在一个文件中
packagemypackage;
publicclassMyClass;
2)如今，假如客户程序员想要利用MyClass，就要用import来引进mypackage包，大概是利用MyClass的全名
importmypackage;
MyClassm=newMyClass();
mypackage.MyClassm=newmypackage.MyClass();
27、CLASSPATH
1)将某个特定包利用的一切.class文件都放在一个目次下
2)CLASSPATH包括一个或多个目次，它们作为一种特别的根利用，从这里睁开对.class文件的搜刮
－主动编译
－抵触
－Classpath的圈套
－用import来改动举动
28、类成员的会见属性
针对类内的每一个成员的每一个界说，Java会见属性public，protected和private都放在它们的后面－－不管是数据成员仍是办法
－“Friendly”（缺省包）
－public：界面会见（accessor/mutator）
－private：不克不及打仗！
－protected：“某种友爱”
29、类的会见把持
1)一个编译单位（文件）中只能有一个public的类。因而一个编译单位只要一个独一的大众界面，其他的类都是“friendly”的。public类的名字必需和文件的名字一样
2)能够，只管很少见，一个编译单位没有一个public类，一切的类都是“friendly”的，那末文件名能够恣意起
-Case:Lunch.java
//:Lunch.java
//Demonstratesclassaccessspecifiers.
//Makeaclasseffectivelyprivatewithprivateconstructors:
classSoup{
privateSoup(){}

//(1)Allowcreationviastaticmethod:
publicstaticSoupmakeSoup(){
returnnewSoup();
}

//(2)Createastaticobjectandreturnareferenceuponrequest.
//(The"Singleton"pattern):

}

ruby里有这些工具吗？又要简单多少？我没有用过这两门语言，我估计在这些语言力没有很统一的这种标准，或者根本就没有提供。

仓酷云

科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。

设计模式是高级程序员真正掌握面向对象核心思想的必修课。设计模式并不是一种具体"技术",它讲述的是思想，它不仅仅展示了接口或抽象类在实际案例中的灵活应用和智慧

任职于太阳微系统的詹姆斯·高斯林等人于1990年代初开发Java语言的雏形，最初被命名为Oak，目标设置在家用电器等小型系统的程序语言

你可以去承接一些项目做了，一开始可能有些困难，可是你有技术积累，又考虑周全，接下项目来可以迅速作完，相信大家以后都会来找你的，所以Money就哗啦啦的。。。。。。

一般学编程语言都是从C语开始学的，我也不例外，但还是可能不学过程语言而直接学面向对象语言的，你是刚接触语言，还是从C开始学比较好，基础会很深点，如果你直接学习JAVA也能上手，一般大家在学语言的时候都记一些语言的关键词，常有的包和接口等。再去做逻辑代码的编写，以后的学习过程都是从逻辑代码编写中提升的，所以这方面都是经验积累的。你要开始学习就从

吧，现在很流行的Structs就是它的一种实现方式，不过Structs用起来实在是很繁，我们只要学习其精髓即可，我们完全可以设计自己的MVC结构。然后你再研究一下软件Refactoring (重构)和极限XP编程，相信你又会上一个台阶。 做完这些，你不如整理一下你的Java代码，把那些经典的程序和常见的应用整理出来，再精心打造一番，提高其重用性和可扩展性。你再找几个志同道合的朋友成立一个工作室吧

[url]http://www.jdon.com/[/url]去下载，或到同济技术论坛的服务器[url]ftp://nro.shtdu.edu.cn[/url]去下，安装上有什么问题，可以到论坛上去提问。

那么我书也看了，程序也做了，别人问我的问题我都能解决了，是不是就成为高手了呢？当然没那么简单，这只是万里长征走完了第一步。不信？那你出去接一个项目，你知道怎么下手吗，你知道怎么设计吗，你知道怎么组织人员进行开发吗？你现在脑子里除了一些散乱的代码之外，可能再没有别的东西了吧！

不过，每次的执行编译后的字节码需要消耗一定的时间，这同时也在一定程度上降低了 Java 程序的运行效率。

有时间再研究一下MVC结构（把Model-View-Control分离开的设计思想）

如果要向java web方向发展也要吧看看《Java web从入门到精通》学完再到《Struts2.0入门到精通》这样你差不多就把代码给学完了。有兴趣可以看一些设计模块和框架的包等等。

你快去找一份Java的编程工作来做吧（如果是在校学生可以去做兼职啊），在实践中提高自己，那才是最快的。不过你得祈祷在公司里碰到一个高手，而且他 还愿意不厌其烦地教你，这样好象有点难哦！还有一个办法就是读开放源码的程序了。我们知道开放源码大都出自高手，他们设计合理，考虑周到，再加上有广大的程序员参与，代码的价值自然是字字珠叽，铿锵有力（对不起，偶最近《金装四大才子》看多了）。

是一种突破用户端机器环境和CPU

是一种将安全性(Security)列为第一优先考虑的语言

你现在最缺的是实际的工作经验，而不是书本上那些凭空想出来的程序。

接着就是EJB了，EJB就是Enterprise JavaBean, 看名字好象它是Javabean，可是它和Javabean还是有区别的。它是一个体系结构，你可以搭建更安全、更稳定的企业应用。它的大量代码已由中间件（也就是我们常听到的 Weblogic,Websphere这些J2EE服务器）完成了，所以我们要做的程序代码量很少，大部分工作都在设计和配置中间件上。

Java是一个纯的面向对象的程序设计语言，它继承了 C++语言面向对象技术的核心。Java舍弃了C ++语言中容易引起错误的指针（以引用取代）、运算符重载（operator overloading）

是一种将安全性(Security)列为第一优先考虑的语言

J2SE开发桌面应用软件比起 VC,VB,DEPHI这些传统开发语言来说，优势好象并不明显。J2ME对于初学者来说，好象又有点深奥，而且一般开发者很难有开发环境。