java学习笔记【范本模板】

合集下载

Java学习笔记(必看经典).pdf

Java学习笔记(必看经典).pdf
对于对象的要求:高内聚、低耦合,这样容易拼装成为一个系统。 实现高内聚就是要最大限度低提高复用性(复用性好是因为高内聚 )。 可复用性是 OOP 的基础。
比较面向过程的思想和面向对象的思想: 面向过程的思想:由过程、步骤、函数组成,以过程为核心; 面向对象的思想:以对象为中心,先开发类,得到对象,通过对象之间相互通信实现功能。 面向过程是先有算法,后有数据结构。 面向对象是先有数据结构,然后再有算法。
关系运算符:instanceof a instanceof Animal;(这个式子的结果是一个布尔表达式) a 为对象变量,Animal 是类名。 上面语句是判定 a 是否可以贴 Animal 标签。如果可以贴则返回 true,否则返回 false。
在上面的题目中: a instanceof Animal 返回 True, a instanceof Dog 也返回 True,
This 表示当前对象。
Public void printNum(){ Int number=40; System.out.println(this.number);
} 此时打印的是实例变量,而非局部变量,即定义在类中而非方法中的变量。
This.number 表示实例变量。 谁调用 this.number 那么谁即为当前(this)对象的 number 方法。
可以构造多个构造方法,但多个构造方法的参数表一定不同,参数顺序不同即属于不同的构造方法: public student(string name,int a){ } public student(int a,string name){ } 为两个不同的构造方法。 如果我们未给系统提供一个构造方法,那么系统会自动提供一个为空的构造方法。 练习:写一个类,定义一个对象,定义两个构造方法:一个有参,一个无参。 (编写一个程序验证对象的传递的值为地址) 注意下面这种形式: static void changename(student stu){stu.setName “LUCY”} 注意生成新的对象与旧对象指向无关,生成新对象生命消亡与旧对象无关。

Java笔记

Java笔记

看前说明:我总结的笔记是从第4章开始写起的。

书中前3章是编程语法的基础。

还不懂的话得把以前的C++好好的回顾以下!堆栈和抛出异常2章我要在星期5的时候才能更新给大家。

这些可以仅当参考….继承就是子类继承父类,可以扩展已有类的功能子类继承后父类后,可以把子类中的内容拿过来在子类继续使用。

Extends关键字,称为扩展,子类扩展一个类,子类有时候也称为派生类。

继承的限制单继承:一个孩子只能有一个亲爸java里的继承不能多重继承,但是允许多层继承例如:class A{};class B extends A{};class C extends B{};子类的实例化过程:在使用继承的时候也应注意的是:子类是不能直接访问父类中的私有成员的,但是子类可以调用父类中的非私有方法,但是不能直接调用父类中的私有成员。

-------------------------------------------在继承的操作,实例化子类之前必须先调用父类中的构造方法之后再调用子类自己的构造方法。

方法的覆写:在继承的关系中也存在着方法覆写的概念,所谓的方法覆写就是指子类定义了与父类同名的方法,但是在方法覆写时候必须考虑到权限,即:被子类覆写的方法不能拥有比父类方法更加严格的访问权限。

Private< default< public所以,如果在父类中使用public定义的方法,子类的访问权限必须是public,否则程序会无法编译继承的访问限制private:本类protected:本类,同包的子类和其他类,不同包的子类默认:本类,同包的子类和其他类Public:最大super关键字,称为超类,也就是所谓的父类在子类的构造方法中,隐藏了一个"super"的语句,所以在实例化子类的时候会先调用父类的构造方法。

(子类调用实例化的时候会默认调用父类中的无参构造)在类中没有标明方法类型时默认是default的,在子类声明的方法里想调用的父类中的方法的话,得看父类声明的方法是什么访问权限的。

(完整word版)Java学习笔记(必看经典)

(完整word版)Java学习笔记(必看经典)

诚信、创新、开放、合作JAVA的面向对象编程--------课堂笔记面向对象主要针对面向过程。

面向过程的基本单元是函数。

什么是对象:EVERYTHING IS OBJECT(万物皆对象)所有的事物都有两个方面:有什么(属性):用来描述对象。

能够做什么(方法):告诉外界对象有那些功能。

后者以前者为基础。

大的对象的属性也可以是一个对象。

为什么要使用面向对象:首先,面向对象符合人类看待事物的一般规律。

对象的方法的实现细节是屏蔽的,只有对象方法的实现者了解细节。

方法的定义非常重要。

方法有参数,也可能有返回值。

注意区分:对象(本身)、对象的实现者、对象的调用者。

分析对象主要从方法开始。

我们通过类来看待对象,类是对象的抽象。

其次,采用面向对象方法可以使系统各部分各司其职、各尽所能。

对象之间的耦合性一定要低(比如不同硬盘和不同主板之间的关系)。

这样才能使每个对象本身做成最好的。

对于对象的要求:高内聚、低耦合,这样容易拼装成为一个系统。

实现高内聚就是要最大限度低提高复用性(复用性好是因为高内聚)。

可复用性是OOP的基础。

比较面向过程的思想和面向对象的思想:面向过程的思想:由过程、步骤、函数组成,以过程为核心;面向对象的思想:以对象为中心,先开发类,得到对象,通过对象之间相互通信实现功能。

面向过程是先有算法,后有数据结构。

面向对象是先有数据结构,然后再有算法。

在用面向对象思想开发的过程中,可以复用对象就进行复用,如无法进行复用则开发新的对象。

开发过程是用对个简单的对象的多个简单的方法,来实现复杂的功能。

从语法上来看,一个类是一个新的数据类型。

在面向对象编程中,除了简单数据类型,就是对象类型。

定义类的格式:class Student{代码}注意类名中单词的首字母大写。

实例变量:定义在类中但在任何方法之外。

(New出来的均有初值)局部变量:定义在方法之中的变量。

局部变量要先赋值,再进行运算,而实例变量均已经赋初值。

这是局部变量和实例变量的一大区别。

课堂笔记学习JAVA

课堂笔记学习JAVA

public class Hello{public static void main(S tring args[]){System.out. println("你好,很高兴学习Java");}}保存为Hello.java(注意保存的名字必须是和主类的名字一样(包括大小写),所谓主类就是包含main方法的类)(b).按住"窗口+R"组合键打开运行窗口输入cmd进入dos界面转换盘符到刚刚java文件保存路径(例如保存在D盘,输入D:回车)然有执行命令javac Hello.java回车.这时会发现在和Hello.java同一个文件夹下生成了Hello.class字节码文件,因为上面是一个应用程序的格式所以可以通过java解释器来生成应用程序.继续输入java Hello回车.屏幕会显示"你好,很高兴学习Java"b.小应用程序(a)打开记事本输入程序代码:import java.applet.*;import java.awt.*;public class Boy extends Apple t//entends代表Boy继承了小应用程序Applet类{public void paint(Graphics g){g.setColor(Color. red);g.drawString("我一边喝着咖啡,一边学Java呢",5,30);g.setColor(Colo r.blue);g.drawString("我学得很认真",10,50);逻辑类型:boolean用ture(真)和false(假)来赋值,没有赋值默认情况时表示false整数类型:(1)int型变量,内存分配4个字节的空间,即32位的空间,所以可以表示-2^31到2^31-1的整数,例如int x=10;(2)byte型变量,内存分配1个字节的空间,范围从-2^7到2^7-1,例如byte x=127(3)short型变量,内存分配2个字节的空间,范围从-2^15到2^15-1,例如short x=1000(4)long型变量,内存分配8个字节的空间,范围从-2^63到2^63-1,例如long x=700000;字符类型:(1)常量:java使用unicode字符集,所以字符表中的每个字符都是一个字符常量,用单引号括上,例如'A','你','あ'注意有些字符不能通过键盘直接输入到字符串中或程序中,这时就需要转意字符常量,例如: '\n'(换行),'\b'(退格),'\''(单引号)等等.(2)变量:通过关键字char来定义字符变量char型变量,内存分配2个字节的空间,因为是字符不存在负数的概念,所以范围从0到2^16-1(即65535),例如char name='刘',grade='A'如果要查一个字符在unicode字符集里的顺序位置,必须使用int类型转换,如(int) 'A',但不可以用short型转换(范围只有一半);同样道理如果想得到一个在0到655 35之间的数字在unicode字符集中所对应的字符必须使用char型转换,如(char)30 000.具体含义理解如下面代码程序代码:public class Sign_Num{public static void main(String args[]){char chinaWord='你',japanWord='ぁ';int p1=36328,p2=38358;System.out.println("汉字\'你\'在unicode表中的顺序位置:"+(int)china Word);System.out.println("日语\'ぁ\'在unicode表中的顺序位置:"+(int)japan Word);System.out.println("unicode表中第20328位置上的字符是:"+(char)p1);System.out.println("unicode表中第12358位置上的字符是:"+(char)p2);}}除了char以外还要稍微介绍一下String,在C或C++中,String是一个以空为终结的字符数组,而在java中它是ng包中的String类来创建一个字符串变量,因此字符串变量是一个对象.String的具体介绍在后面会学习到.浮点类型:(1)float型内存分配4个字节,占32位,范围从10^-38到10^38和-10^38到-10^-38例float x=123.456f,y=2e20f;注意float型定义的数据末尾必须有"f",为了和double区别(2)double型内存分配8个字节,范围从10^-308到10^308和-10^-308到-10^-308例double x=1234567.98,y=8980.09d;末尾可以有"d"也可以不写基本数据类型转换:类型按精度从低到高:byte short int long float double(1)当把级别低的变量赋值给级别高的变量时,系统自动完成数据类型的转换,例int x=100;float y;y=x;结果y的值应该是100.0(2)当把级别高的变量赋值给级别低的变量时,必须使用显示类型转换运算,格式为:(类型名)要转换的值;例int x=(int)23.89f;结果x的值为23所以强制转换运算可能导致精度的损失(3)当把一个整数赋值给一个byte,short,int或long型变量时,不可以超出这些变量的取值范围,否则必须进行类型转换运算,例byte a=(byte)128;byte b=(byte)-129;//超出范围结果a值为128,b值为127用下面的代码来复习下:程序代码:public class Example2_2{public static void main(String args[]){int c=2200;总结:本节课把编程语言中的基础-关键字,数据类型等概念复习一遍,尤其是在java中的用法,为以后在使用变量的学习中做基础.return distance;}void g(){inty;y=a;//非法,a是局部变量,不在find()中就会失效}}注意:成员变量在它在类中书写的先后位置无关.但不提倡把成员变量的定义分散的写在方法之间或类体的后面.b.成员变量又分为实例成员变量(实例变量)和类成员变量(类变量)类变量是指变量类型前加关键字static的成员变量,也称为静态变量.例:程序代码:class Sun{float x;//实例变量static int y;//类变量}c.当局部变量与成员变量名字相同时,则成员变量被隐藏,即这个成员变量在这个方法内暂时失效,例:程序代码:class Tom{int x=90,y;void f(){int x=3;y=x;//y得到的值应是3,因为成员变量x=90与y在此方法体里失效}}但如果想在方法体内使用成员变量则通过关键字this来实现,例:程序代码:class三角形{float sideA,sideB,sideC,lengthSum;void setside(float sideA,float sideB,float sideC)载的.用法:一般用类创建对象时,使用构在方法,后面会有详细说明.程序代码:class梯形{float上底,下底,高;梯形(){上底=60;下底=100;高=20}梯形(float x,float y,float z){上底=x;下底=y;高=z;}}2.对象类是创建对象的模板.当使用一个类创建了一个对象时,也就是说给出了这个类的一个实例.(1)对象的创建:包括对象的声明和为对象分配内存空间声明格式:类的名字对象的名字;分配内存空间格式;类的名字对象的名字=new类的名字();例:程序代码:class XiyoujiRenwu{float height,weight;String head,ear,hand,foot,mouth;void speak(String s){System.out.println(s);}}class A{public static void main(String args[]){XiyoujiRenwu zhubajie;//声明对象zhubajie=new XiyoujiRenwu();//为对象分配内存,使用new运算符和默认的构造方法class XiyoujiRenwu{float height,weight;String head,ear,hand,foot,mouth;void speak(String s){head="歪着头";System.out.println(s);}}class Example4_3{public static void main(String args[]){XiyoujiRenwu zhubajie,sunwukong;//声明对象zhubajie=new XiyoujiRenwu();//为对象分配内存sunwukong=new XiyoujiRenwu();zhubajie.height=1.80f;//对象给自己的变量赋值zhubajie.head="大头";zhubajie.ear="一双大耳朵";sunwukong.height=1.62f;//对象给自己的变量赋值sunwukong.weight=1000f;sunwukong.head="绣发飘飘";System.out.println("zhubajie的身高:"+zhubajie.height);System.out.println("zhubajie的头:"+zhubajie.head);System.out.println("sunwukong的重量:"+sunwukong.weight);System.out.println("sunwukong的头:"+sunwukong.head);zhubajie.speak("俺老猪我想娶媳妇");//对象调用方法System.out.println("zhubajie现在的头:"+zhubajie.head);sunwukong.speak("老孙我重1000斤,我想骗八戒背我");//对象调用方法System.out.println("sunwukong现在的头:"+sunwukong.head);}}程序代码:class梯形{float上底,下底,高,面积;梯形(float x,float y,float h){上底=x;下底=y;高=h;}float计算面积(){面积=(上底+下底)*高/2.0f;return面积;程序代码:class Takecare{static int x;int y;}class A{Takecare A1=now Takecare();Takecare A2=now Takecare();//在此代码中如果给x赋值那么,A1.x和A2.x指的是同一个内存空间,无论那个对象修改都是对一个x进行操作}当java程序执行时,类的字节码文件被加载到内存,如果该类没有创建对象,类的实例成员变量不会被分配内存.但是类中的类变量被加载到内存时,会被分配相应的内存空间.简单的说就是,没创建对象当类加载到内存时候,只有类变量(static)会被分配内存空间,只有创建对象时候实例变量才会被分配空间的.像上面的例子里,在没有创建Takecare的对象时候,Takecare::x是有空间的即此时可以访问的,当且仅当Takecare A1=now Takecare()时A1.y才会有内存空间.通过下面的例子体会一下,不同的对象会共享一个底程序代码:class梯形{float上底,高;static float下底;梯形(float x,float y,float h){上底=x;下底=y;高=h;}float获取下底(){return下底;}void修改下底(float b){下底=b;}}class Example4_7{public static void main(String args[]){梯形laderOne=new梯形(3.0f,10.0f,20),laderTwo=new梯形(2.0f,3.0f,10);梯形.下底=200;//通过类名操作类变量System.out.println("laderOne的下底:"+laderOne.获取下底());System.out.println("laderTwo的下底:"+laderTwo.获取下底());laderTwo.修改下底(60);//通过对象操作类变量System.out.println("laderOne的下底:"+laderOne.获取下底());System.out.println("laderTwo的下底:"+laderTwo.获取下底());}}2.实例方法和类方法和实例变量和类变量的描述时是一样,当类的字节码加载到内存是类方法的入口地址就会被加载到相应的内存空间,即此时可以访问;而当且只有创建对象之后,实例方法的入口地址才会被加载到内存中,这是才可以调用.既然知道了实例方法和类方法开始生效的时间,可以知道他们可以调用何种类的成员变量:1)类方法因为是在创建对象之前就已经生效了,这时候实例变量还没有被分配内存空间,只有类变量被分配了内存空间,所以类方法只能调用被分配内存空间的变量即类变量;2)实例方法是在创建对象之后才开始生效的,这是无论是类变量还是实例变量都已经被分配了内存空间,所以实例方法生效后可以调用类变量和实例变量.程序代码:class Fibi{public static long fibinacii(int n){long c=0;if(n==1||n==2)c=1;elsec=fibinacii(n-1)+fibinacii(n-2);return c;}}public class Example4_8{public static void main(String args[]){System.out.println(Fibi.fibinacii(7));//可见还没哟创建Fibi的对象时就可以调用fibinacii()方法,因为属于static修饰的类变量}}包包是java中有效的管理类的一个机制,包有类似于目录结构的层次结构.通过import关键字可以在程序中使用包语法格式:import<包名>.*;//包含包中的所有类import<包名><类名>//包含包中的指定类例如:import java.awt.*;//包含java.awt包中的所有类import java.awt.JButton;//包含java.awt包中的JButton类既然知道了怎么使用,那如何制作包呢,可以通过关键字package声明包语句.package语句作为java源文件的一个条语句,指明该源文件定义的类的所在包.语法格式:package包名;如果源文件中省略了package语句,那么源文件中定义命名的类将被隐含的认为是无名包的一部分,即源文件中定义命名的类在同一个包中,但该报没有名字而已.包还可以是一个合法的表示符,也可以是若干个标识符加"."分割而成,如package sunrise;package 程序如果使用了包的语句,如package desney.tom;那么目录必须包含有如下结构,如C:\cartoon\desney\tom并且要将源文件保存在目录C:\cartoon\desney\tom中,才能使用这个包,然后编译源文件: C:\cartoon\desney\tom\javac源文件.java或jacac C:\cartoon\desney\tom\源文件.java从一个例子体会此过程:程序代码:package desney.tom;public class PrimNumber{public void getPrimnumber(int n){int sum=0,i,j;for(i=1;i<=n;i++){for(j=2;j<=i/2;j++){if(i%j==0)break;}if(j>i/2)System.out.print(""+i);}}public static void main(String args[]){PrimNumber p=new PrimNumber();p.getPrimnumber(20);}}保存上述源文件到C:\cartoon\desney\tom下,然后编译C:\cartoon\desney\tom\javac PrimNumber.java运行程序时必须到desney\tom的上一层目录cartoon中来运行,如C:\cartoon\java desney.tom.PrimNumber因为起了报名,类PrimNumber的全名应该为desney.tom.PrimNumber导入这个包时也要注意名称程序代码:import desney.tom.PrimNumber;所以用package可以把认可类都打包然后在其他程序中使用,于c或c++中的头文件有着相似的效果,差别就是java中的包里只能是类注意:使用import可以导入包中的类.在编写源文件时,除了自己编写的类外,经常需要使用java提供的去多类,这些类可能不在一个包中.在学习java时,使用已经存在的类,避免一切从头做起,这是面向对象编程的一个重要方面.总结:具体的把static修饰的变量和方法的使用方法做了介绍;对java中包有了初步认识。

java课堂笔记(全部基础知识)

java课堂笔记(全部基础知识)

Java_U1课堂笔记(一)初识Java一、配置Java环境变量:1、复制JDK安装路径,如:C:\Program Files (x86)\Java\jdk1.7.0_51\bin2、粘贴到我的电脑->属性->高级系统设置->环境变量->Path3、加上英文的分号4、验证是否配置正确:dos-->java -version进入DOS窗口的方法:运行(或快捷键windows键+r)二、Java程序编写三步骤:编写 .java编译:javac **.java运行java **三、使用jad反编译工具:DOS中切换至jad安装目录,如:C:\jad1.5.8g.win输入命令:jad -s java D:\t01\HelloWorld.class四、变量的使用:页脚内容1变量取名,命名规则类型数值:int、double、float(f)非数值:char、String类型名字= 值;int age=10;五、上机验证:System.out.println(5+3);System.out.println("5"+3);六、Scanner的使用,接收用户键盘输入Scannerimport java.util.Scanner;Scanner input=new Scanner(System.in);input.next();(相关方法,nextDouble()、nextFloat()、nextInt(等)bin:exejre页脚内容2libsrc.zip(二)数据类型一、数据类型转换自动类型转换:int num=100;double b=num;强制类型转换double num=100.9;int b=(int)num;二、运算符赋值运算符=算数运算符+ - * / % ++ --+= -= *= /= %=关系运算符> < >= <= == !=逻辑运算符&& || !页脚内容3条件运算符?:了解优先级即可三、流程控制1、if:基本ifif-else多重if嵌套if注意:条件是boolean值常见错误:if(num=5){}else{}大括号不省略多重if顺序问题注意:页脚内容4流程图的使用和问题的分析解决过程2、switch等值比较注意:(1)语法上的常见错误(2)和多重if的异同循环结构:解决重复性的操作简介高效(三)循环结构一:循环:(1)while循环while(条件){操作循环变量迭代}注意:页脚内容5代码缩进循环能否正常退出(2)do-while循环do{循环}while(条件);注意:代码缩进循环能否正常退出和while的区别:语法上、执行上(至少执行一次)(3)for循环for(变量初始化;条件;变量迭代){循环操作}页脚内容6注意:代码缩进循环能否正常退出执行顺序循环变量可以有多个二、双重循环双重循环的特点:外层循环进入一次,内层循环就要完整的执行一遍特点:外执行一次内执行一轮双重循环次数:外层循环次数*内层循环的次数实现的重点:页脚内容7(1)确定谁做外层循环,确定谁做内层循环(2)两层循环变量有没有规律性的关系1、打印图形:找规律矩形行i外层星星j内层1 52 53 54 55 5平行四边形行i外层内层:空格星星1 4=5-i 52 3=5-i 53 2=5-i 5页脚内容84 1=5-i 55 0=5-i 5等腰三角形行i外层内层:空格星星1 4=5-i 1=2*i-12 3=5-i 3=2*i-13 2=5-i 5=2*i-14 1=5-i 7=2*i-15 0=5-i 9=2*i-12、打印九九乘法表行i(1-9)第一个操作数i 第二个操作数(从1到i)三:循环应用1、分析需求:重复做一件事情前提条件(循环进入的条件)做什么事情(循环操作)页脚内容92、用代码解释选择一种合适的循环结构whiledo-whilefor根据所选择的结构套用语法while(条件){}do{}while(条件);for(循环变量初始化;条件;迭代){}3、容易出错的点(1)变量在何处声明例1:计算5门课平均成绩页脚内容10例2:for(int i=0;i<=6;i++){System.out.println(i);}int j=i;System.out.println(j);(2)没有适当的(合适的)跳出循环根本跳不出来根本进不去循环多或少循环了一次四、循环的跳转break:跳出整个循环continue:跳出本次循环,进入下次循环return:结束方法(了解即可)五、程序调试页脚内容11设置断点Debug->单步运行F5 F6观察变量(三)数组一、数组1、数组的基本使用(1)数组的作用一组相同数据类型的数数组也是变量,内存中一串连续的空间(2)数组的几个基本概念标识符(数组名字)元素下标:从0开始数据类型数组的长度(数组名字.length)(3)数组使用步骤声明数组页脚内容12int[] num;int num[];分配空间num=new int[8];赋值处理数据int[] num={5,8,7};int[] num=new int[]{5,8,7};(4)循环和数组结合的使用下标(0-数组.length-1)遍历时两种方法:方法一:传统for方法二://增强型for(foreach)for(int score:scores){sum+=score;页脚内容13}二、回顾数组变量,内存中一串连续的空间相同数据类型的一组数据数组的基本概念元素数据类型(数组类型)下标(0,数组.length-1)数组的长度:数组.length数组的基本使用声明数组(类型[] 数组名称或类型数组名称[])分配空间(数组名称= new 数据类型[5];)赋值(num[0]= ;)处理数据变量:基本数据类型页脚内容14int、double、float、char、boolean引用数据类型String、数组内存分布不同使用上不同.三、数组的典型使用1、求最大值、最小值(打擂台)2、插入算法(找位置)3、冒泡排序数组存储5个数字下标:0 1 2 3 4外层循环内层循环i:0第一轮+ j比较次数:4 =4:length-1页脚内容15i:1第二轮+ j比较次数:3=4:length-1i:2第三轮+ j比较次数:2 =4:length-1i:3第四轮+ j比较次数:1=4:length-1i+j=数组.length-1j=数组.length-1-i共比较几次?5个数字:4+3+2+1=106个数字:5+4+3+2+1=157个数字:6+5+4+3+2+1=21n个数字:(n-1)+(n-2)+(n-3)+.....+1=n*(n-1)/24、Arrays类的使用常用方法:页脚内容16sort().....记得查API帮助文档(帮助文档已经在网盘中提供了,如果大家在Oracle官网中没有下载,可以找中心的技术顾问老师提供网盘用户名和密码,登录后拿到帮助文档)数据类型基本数据类型int double char boolean 。

JAVA学习完整版详细笔记

JAVA学习完整版详细笔记

Java基础知识总结Java基础知识总结写代码:1,明确需求。

我要做什么?2,分析思路。

我要怎么做?1,2,3。

3,确定步骤。

每一个思路部分用到哪些语句,方法,和对象。

4,代码实现。

用具体的java语言代码把思路体现出来。

学习新技术的四点:1,该技术是什么?2,该技术有什么特点(使用注意):3,该技术怎么使用。

demo4,该技术什么时候用?test。

-----------------------------------------------------------------------------------------------一:java概述:1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言,希望用于控制嵌入在有线电视交换盒、PDA等的微处理器;1994年将Oak语言更名为Java;Java的三种技术架构:JAVAEE:Java Platform Enterprise Edition,开发企业环境下的应用程序,主要针对web程序开发;JAVASE:Java Platform Standard Edition,完成桌面应用程序的开发,是其它两者的基础;JAVAME:Java Platform Micro Edition,开发电子消费产品和嵌入式设备,如手机中的程序;1,JDK:Java Development Kit,java的开发和运行环境,java的开发工具和jre。

2,JRE:Java Runtime Environment,java程序的运行环境,java运行的所需的类库+JVM(java虚拟机)。

3,配置环境变量:让java jdk\bin目录下的工具,可以在任意目录下运行,原因是,将该工具所在目录告诉了系统,当使用该工具时,由系统帮我们去找指定的目录。

环境变量的配置:1):永久配置方式:JAVA_HOME=%安装路径%\Java\jdkpath=%JAVA_HOME%\bin2):临时配置方式:set path=%path%;C:\Program Files\Java\jdk\bin特点:系统默认先去当前路径下找要执行的程序,如果没有,再去path中设置的路径下找。

JAVA笔记完整版

JAVA笔记完整版

1. BasicLinux 操作1)Linux 是模仿UNIX的操作系统,是山寨版的Unix2)Linux 命令pwd 打印当前工作目录cd 改变工作目录ls 显示目录的内容,默认显示当前目录内容mkdir 创建目录rmcpcatmv 源文件目标文件改名或者移动文件、文件夹1)目标文件如果是新文件/文件夹就进行改名操作2)如果目标是已经存在的文件夹,就发送移动操作3)源文件必须存在,否则有错误!more 分屏显示结果grep 根据条件(正则表达式)在结果中过滤telnet 远程登录命令telnet 192.168.0.20user: openlabpwd: open123bash 切换Shell 为ba Shellexit 离开命令/sbin/ifconfig 查看当前电脑的IP地址ssh username@ipssh soft01@192.168.23.124 登录到另外一台电脑192.168.23.124 echo| 管道符合,作用:将第一个命令的输出,作为第二个命令的输入如:ls /etc|morels /etc|grep pass在第一个命令结果中匹配,包含pass的行留下来Java 应用开发1)编写Java 源文件(文本文件)(记事本,Eclipse)2)编译为.class 字节码文件3)使用Java 虚拟机执行.class字节码文件计算机只能处理2进制的数据和指令java源文件是人能够看懂的程序脚本经过变编译器编译为计算机能够处理的2进制数据和指令在进一步有计算机执行和处理!计算机只能处理数据!任何软件的功能最终都要转换为数据计算!JDK (文件夹/opt/jdk 也可能是/opt/jdk1.6.0_01)|-- bin (java javac jar rmic jps native2ascii 等命令)| 开发工具命令|-- lib (tools.jar) 是开发工具命令的实际实现|-- jre java 运行环境|-- bin java_vm java 的虚拟机|-- lib|-- rt.jar 是Java系统API库、系统类库|-- java.util.Scannerecho 命令: 回显如:echo abc 就会在屏幕上显示abcPA TH 是Linux操作系统的环境变量$PA TH 是读取变量的值echo $PA TH 命令就是将$PA TH 取回的变量值显示到屏幕简单说就是看看PA TH变量的值PA TH 变量的作用: 操作系统可执行命令的搜索路径,操作系统在执行命令时候,逐一搜索PATH指定的路径,找到命令执行如果找不到就报错误:command not foundexport 导出命令,可以用来修改环境变量export PA TH=/bin在终端窗口中的环境变量设置,只在当前窗口中生效。

Java总结笔记

Java总结笔记

======================================================== ===============学习Java总结笔记======================================================== ===============1.关于动态加载机制??学习Java比C++更容易理解OOP的思想,毕竟C++还混合了不少面向过程的成分。

很多人都能背出来Java语言的特点,所谓的动态加载机制等等。

当然概念往往是先记住而后消化的,可有多少人真正去体会过动态加载的机制,试图去寻找过其中的细节呢?提供大家一个方法:在命令行窗口运行Java程序的时候,加上这个很有用的参数:java ?verbose *.class (这句有错)这样会清晰的打印出被加载的类文件,大部分是jdk自身运行需要的,最后几行会明显的看到自己用到的那几个类文件被加载进来的顺序。

即使你声明了一个类对象,不实例化也不会加载,说明只有真正用到那个类的实例即对象的时候,才会执行加载。

这样是不是大家稍微能明白一点动态加载了呢?^_^2.关于寻找class文件原理??建议大家在入门的时候在命令行窗口编译和运行,不要借助JCreator或者Eclipse等IDE去帮助做那些事情。

尝试自己这样做:javac -classpath yourpath *.javajava -classpath yourpath *.class也许很多人都能看懂,设置classpath的目的就是告诉编译器去哪里寻找你的class文件. 不过至少笔者今日才弄懂JVM去查询类的原理,编译器加载类要依靠classloader,而classloader有3个级别,从高到低分别是BootClassLoader(名字可能不准确), ExtClassLoader, AppClassLoader.这3个加载器分别对应着编译器去寻找类文件的优先级别和不同的路径:BootClassLoader对应jre/classes路径,是编译器最优先寻找class的地方ExtClassLoader对应jre/lib/ext路径,是编译器次优先寻找class的地方AppClassLoader对应当前路径,所以也是编译器默认找class的地方其实大家可以自己写个程序简单的测试,对任何class,例如A,调用new A().getClass().getClassLoader().toString() 打印出来就可以看到,把class文件放在不同的路径下再次执行,就会看到区别。

传智播客刘意老师JAVA全面学习笔记(word文档良心出品)

传智播客刘意老师JAVA全面学习笔记(word文档良心出品)

JAVA 学习路线第一天1:计算机概述(了解)22:键盘功能键的认识和快捷键(掌握)2 3:常见的DOS命令(掌握)34:Java语言概述(了解)35:JDK,JRE,JVM的作用及关系(掌握) 3 6:JDK的下载,安装,卸载(掌握)47:第一个程序:HelloWorld案例(掌握)4 8:常见的问题(掌握)59:path环境变量(掌握)510:classpath环境变量(理解)5第二天1:关键字(掌握)62:标识符(掌握)63:注释(掌握)74:常量(掌握)75:进制转换(了解)76:变量(掌握)87:数据类型(掌握)88:数据类型转换(掌握)8第三天1:运算符(掌握)102:键盘录入(掌握)113:流程控制语句124:if语句(掌握)12第四天1:switch语句(掌握)142:循环语句(掌握)153:控制跳转语句(掌握)17第五天1:方法(掌握)182:数组(掌握)19第六天1:二维数组(理解)232:两个思考题(理解)233:面向对象(掌握)23第七天1:成员变量和局部变量的区别(理解)252:类作为形式参数的问题?(理解)253:匿名对象(理解)254:封装(理解)255:private关键字(掌握)256:this关键字(掌握)267:构造方法(掌握)268:代码:Student s = new Student();做了哪些事情?(理解)27 9:面向对象的练习题(掌握)27第八天1:如何制作帮助文档(了解)282:通过JDK提供的API学习了Math类(掌握)283:代码块(理解)284:继承(掌握)28第九天1:final关键字(掌握)302:多态(掌握)303:抽象类(掌握)324:接口(掌握)33第十天1:形式参数和返回值的问题(理解)352:包(理解)353:导包(掌握)354:权限修饰符(掌握)365:常见的修饰符(理解)366:内部类(理解)37第十一天1:Eclipse的概述使用(掌握)402:API的概述(了解)403:Object类(掌握)40第十二天1:Scanner的使用(了解)412:String类的概述和使用(掌握)41第十三天1:StringBuffer(掌握)442:数组高级以及Arrays(掌握)443:Integer(掌握)464:Character(了解)47第十四天1:正则表达式(理解)472:Math(掌握)493:Random(理解)494:System(掌握)495:BigInteger(理解)506:BigDecimal(理解)507:Date/DateFormat(掌握)508:Calendar(掌握)51第十五天1:对象数组(掌握)522:集合(Collection)(掌握)523:集合(List)(掌握)55第十六天1:List的子类(掌握)572:泛型(掌握)583:增强for循环(掌握)584:静态导入(了解)585:可变参数(掌握)596:练习(掌握)597:要掌握的代码59第十七天1:登录注册案例(理解)602:Set集合(理解)603:Collection集合总结(掌握)604:针对Collection集合我们到底使用谁呢?(掌握)61 5:在集合中常见的数据结构(掌握)61第十八天1:Map(掌握)622:Collections(理解)63第十九天1:异常(理解)642:File(掌握)65第二十天1:递归(理解)662:IO流(掌握)663:自学字符流第二十一天1:字符流(掌握)69第二十一天1:字符流(掌握)692:IO流小结(掌握)703:案例(理解练习一遍)71第二十二天1:登录注册IO版本案例(掌握)722:数据操作流(操作基本类型数据的流)(理解)72 3:内存操作流(理解)724:打印流(掌握)725:标准输入输出流(理解)736:随机访问流(理解)737:合并流(理解)738:序列化流(理解)739:Properties(理解)7410:NIO(了解)74第二十三天1:多线程(理解)75第二十四天1:多线程(理解)772:设计模式(理解)77第二十五天1:如何让Netbeans的东西Eclipse能访问79 2:GUI(了解)79第二十六天1:网络编程(理解)80第二十七天1:反射(理解)822:设计模式823:JDK新特性82JA V A学习总结姓名:陈鑫第一天1:计算机概述(了解)(1)计算机(2)计算机硬件(3)计算机软件系统软件:window,linux,mac应用软件:qq,yy,飞秋(4)软件开发(理解)软件:是由数据和指令组成的。

java笔记

java笔记

Java学习笔记五年了。

你知道我是怎么在这五年里来到这里的吗?五年前,我还是一个年轻无知的大学生。

带着对社会的美好憧憬,我走进了职场。

那一刻,我欣喜若狂,终于不用每天早起,在衣架的监督下上学、做作业。

当我不在的时候,我自己挣钱。

想吃就吃几桶方便面,想买就买奥特曼玩具,然后再买一盒辣条,每天都吃。

不管怎么说,没有人会照顾我。

但好景不长。

后来,我因腹泻住院...。

出院后,我发现母亲不让我吃辣条是对的。

于是,我辞去了辣条的工作,开始专心工作。

我的实习是在一家小型互联网公司做JAVA开发,我的工作性质和我的大学老师之前说的完全一样,就是在网上复制一些代码,粘贴,修改一些数据,把格式调整得整整齐齐。

做完,下班,然后离开。

在这样的循环中编程并不难!不久之后,公司倒闭了,我也丢掉了工作。

我开始投递简历和面试工作。

在这个时候,我不能再伪装成实习生了。

在一家公司面试时,面试官问我:“你实习时最大的收获是什么?”我一本正经地回答说:“我可以很快在网上找到我需要的业务代码的demo。

”接下来,我在家里等了一个月的录用通知,结果发现面试官对我撒了谎。

他亲自告诉我,叫我回家等通知.。

我情不自禁。

我得出去找份工作。

最后,上帝给了我回报,我找到了我的第一份正式工作,并明确表示编程不像复制和粘贴那么简单。

后来,在网上找到的学习资料开始深入研究Spring、Struts和Hibernate这三个框架,以后的工作就变得容易了。

随着工作强度的不断增加,工作压力也随之而来。

事实证明,成年人的世界并不那么容易。

长时间加班导致每天的睡眠时间比高中少,在技术上的学习不亚于高考前的学习冲刺。

因为决心在下班后的这一小段时间里开始学习,我的电脑桌面上有很多笔记,都是用来做学习笔记的。

学习JVM从它的起源开始,包括JVM的内存区、虚拟机中的对象、对象的内存布局、对象的访问定位、堆内存空间结构等。

java成长笔记

java成长笔记

java成长笔记Java是一门强大而广泛应用的编程语言,它在软件开发领域扮演着重要的角色。

我的Java 成长之路始于对编程的热爱和对技术的好奇心。

通过不断学习和实践,我积累了一些宝贵的经验和教训,愿意与大家分享我的Java 成长笔记。

1. 初识JavaJava是一门面向对象的、跨平台的编程语言。

初学者应该先了解基本语法、数据类型、控制流程等基础知识。

在这个阶段,我学到了:面向对象思想:Java是一门面向对象的语言,深入理解类、对象、封装、继承和多态等概念对于正确使用Java至关重要。

基本语法:学会如何声明变量、编写条件语句、循环语句,以及使用数组等基础语法。

2. 深入学习核心概念Java中有一些核心概念,包括异常处理、多线程、IO操作等。

深入了解这些概念对于编写高质量、健壮的应用程序至关重要。

异常处理:学会使用try-catch块来处理异常,理解受检异常和运行时异常的区别,提高代码的稳定性。

多线程:Java是一门支持多线程的语言,但多线程编程需要小心谨慎。

学会使用线程池、同步机制,避免死锁和竞态条件。

3. 设计模式设计模式是解决特定问题的经验总结,学习并掌握设计模式有助于写出更灵活、可维护的代码。

常见设计模式:学习单例模式、工厂模式、观察者模式等,理解它们的用途和实现方式。

适度使用设计模式:设计模式不是越多越好,要根据实际需要来灵活运用。

4. 框架和开发工具学会使用一些流行的Java框架和开发工具,能够提高开发效率,更好地组织和管理项目。

Spring框架:了解IoC(控制反转)和AOP(面向切面编程)的概念,学习Spring Boot简化开发流程。

Maven或Gradle:学会使用构建工具来管理项目的依赖和构建过程。

5. 单元测试和调试编写高质量的代码不仅需要良好的设计,还需要充分的测试和调试。

JUnit或TestNG:学习单元测试框架,编写测试用例,保证代码的可靠性。

调试技巧:熟练使用IDE提供的调试工具,快速定位和解决问题。

java笔记

java笔记

Java学习笔记(讲师:韩顺平)整理:reamd1、先建一个工程——>包——>类2、java中类名首字母大写方法名的首字母是小写的①匈牙利法:myCode②下划线法:my_code3.先设计类 然后根据类创建对象实例化一个开辟一个内存设计类的过程class 类名{};设计类的属性时,尽量带着private的控制访问符号,如需要访问类私有的属性,可通过构造一个公共的方法去给予外界一定的访问权。

(1)构造方法,在建立一个新的对象时会自动调用构造方法初始化成员属性。

(注:若类的形式为:class Clerk{int age;};则构造函数的形式为public Clerk(int age){ this.age=age;};)(2)类方法:public static int total() {方法语句;}4. this指向一个对象,而不是类this只能在类定义中用5.(1)static int a;a称为静态变量或类变量,因此其可以被任何一个变量访问;因此它不是任何一个实例所共有的6.java面向对象语言的三大特征:封装、继承、多态。

(可附加:抽象)(1)封装:访问控制符Public 对外公开Protected 对子类和同一个包公开默认向同一个包公开private 只有类本身才可以访问(2)能够继承的访问控制为:Public protected 默认(3)方法的重载方法的名称相同、方法的参数不同。

方法的覆盖:方法的名称相同就把父类覆盖了。

不能把父类方法的访问权限缩小。

(4)多态大类下创建实例,能够自动识别。

7.抽象类,接口,final(1)抽象类:用abstract关键字来修饰一个类,抽象方法不能有主体。

(2)接口:interface 接口名class 类名implements 接口名Implement实现原则:当一个接口实现了,就要求实现接口中的所有方法。

原则:接口不能被实例化;接口中的所有方法不能有主体,(3)final 修饰不希望被他人修改的父类的属性和方法。

Java学习笔记整理(细节)

Java学习笔记整理(细节)

Java学习笔记整理本文档是我个人整理的,首先是想通过完成本文档更加扎实自己的基础加强对java语言的理解,然后就是想给入了门的同志们做下贡献。

当然,本文档主要是对java语言基础(当然还有很多基础没有涉及到)的进行较全面的理解已经整理,只要充分掌握了基础知识,学习高级部分的知识才会事半功倍犹如轻车熟路一般容易上手。

正文:CLASSPATH的设置:我们知道运行java必须要设置CLASSPATH环境变量,但是sun java 1.4之后改进了设计,JRE会自动搜索当前路径下的类文件,而且使用java的编译和运行工具时,系统会自动加载dt.jar和tools.jar文件中的类,因此不再需要设置该环境变量。

当然,如果你设置了CLASSPATH环境变量就必须设置全,比如包含当前路径,否则将会出现找不到类的问题。

Java程序的源文件必须与public类的类(接口)名相同,如果源文件所有类都没有使用public修饰,则文件名可以是任意合法的文件名,因此,一个Java源文件里最多自能定义一个public类(接口)。

运算符的结合性和优先级只有单目运算符,赋值运算符和三目运算符是从右向左结合的,其余全是左结合的。

运算符优先级运算符说明java运算符分隔符. [] () {} , ;单目运算符++ -- ~ !强制类型转换运算符(type)四则运算符和求余运算移位运算符<<>>>>>关系运算符<<= >>= instanceof等价运算符== !=按位与&按位异或^按位或|条件与&&条件或||三目运算符?:赋值运算符= += -= /= *= &= |= ^\ <<= >>= >>>= %=break continue 后跟标签,可以直接结束其外层循环。

return 用于结束整个方法。

java guide 自己的笔记

java guide 自己的笔记

java guide 自己的笔记这只是一个基本的大纲,涵盖了Java编程的一些核心概念。

**Java编程指南笔记****1. 基础语法*** **变量与数据类型**: 基本的数据类型(如int, double, char等)和变量的声明与初始化。

* **运算符**: 基本的算术运算符(如+,-,*,/),比较运算符和逻辑运算符。

* **控制结构**: if-else语句,switch语句,循环(for,while)。

* **函数/方法**: 函数的定义,参数传递(按值传递和按引用传递),返回值。

**2. 面向对象编程*** **类与对象**: 类的定义,对象的创建。

* **封装**: 属性和方法的封装。

* **继承**: 类的继承,继承的方法和属性。

* **多态**: 方法的重载和方法的重写。

* **抽象类与接口**: 抽象类的定义,接口的定义和实现。

**3. 异常处理*** **异常的分类**: Checked异常和Unchecked异常。

* **try-catch块**: 异常的捕获和处理。

* **finally块**: 无论是否发生异常都会执行的代码块。

* **throw与throws关键字**: 抛出异常和声明可能抛出的异常。

**4. 集合框架*** **数组**: 数组的定义与使用。

* **List, Set, Map**: 常用集合接口及其实现类(如ArrayList, HashSet, HashMap)。

* **泛型**: 集合中的元素可以有相同的类型。

* **迭代器**: 遍历集合的方法。

**5. 多线程编程*** **线程的生命周期**: 新建线程,启动线程,等待线程,唤醒线程,终止线程。

* **线程同步**: 防止多个线程同时访问某一共享资源造成的数据不一致。

* **线程间通信**: 使用wait()和notify()方法实现线程间通信。

**6. 网络编程*** **Socket编程**: 建立Socket连接,发送和接收数据。

java 笔记

java 笔记

"Java 笔记"通常意味着你在记下有关Java编程语言的信息或笔记。

如果你需要一个Java编程的笔记模板,我可以为你提供一个。

以下是一个简单的Java编程笔记模板:**Java编程笔记****1. Java语言基础*** Java是一种面向对象的、类基础的编程语言。

* Java程序由类和对象组成。

* Java使用分号(;)来结束语句。

* Java使用大括号({})来定义代码块。

* Java的关键字都是小写的。

**2. 数据类型*** 基本数据类型:int, char, float, double, boolean等。

* 引用数据类型:类、数组。

**3. 变量和常量*** 变量:有名称、有值、可改变。

* 常量:有名称、有值、不可改变。

**4. 运算符*** 算术运算符:+,-,*,/,%等。

* 比较运算符:==,!=,>,>=,<,<=等。

* 逻辑运算符:&&(与),||(或),!(非)。

* 位运算符:&(与),|(或),^(异或),~(非),<<(左移),>>(右移)。

**5. 控制结构*** if语句* switch语句* for循环* while循环* do-while循环**6. 函数和方法*** 定义函数/方法:返回类型函数名(参数列表) { }* 调用函数/方法:函数名(参数列表)**7. 类和对象*** 类是一个定义了对象的属性和方法的模板。

* 对象是类的实例。

* new关键字用于创建对象。

**8. 继承和多态*** 继承:子类继承父类的属性和方法。

* 多态:同一个方法在子类中可以有不同的实现。

**9. 接口和抽象类*** 接口:定义了一个类应该有的方法,但不提供实现。

* 抽象类:包含抽象方法的类,不能被实例化。

**10. 异常处理*** try-catch语句用于捕获和处理异常。

* try块包含可能会抛出异常的代码,catch块包含处理异常的代码。

java个人笔记

java个人笔记

吴开放普科学习每天总结 (4)1第一天(20130121) (4)*1 1、java语言中的注释是指什么? (4)2第二天(20130122) (5)*1符号常量的使用 (5)*2赋值运算符 (5)*3关系和逻辑运算符 (6)*4条件运算符 (6)*5 位运算符和补充的课外知识 (7)*6什么是原码、反码和补码? (8)*7 10、位运算符的处理 (8)3第三天:(20130123): (10)*1数据类型自动转换和强制类型转换的操作。

(10)*2字符串的使用 (11)4.第四天(20130124)字符串的讲解 (15)*1、java语言中的字符串。

(15)*2字符串的判断 (16)5.第五天(20130125)三大循环的讲解 (16)* 1java语言专家提供了一个数学类: Math类。

(16)*2 循环语句的介绍 (17)*3、直到循环: do --while循环的格式与规则 (17)*4 else的使用规范 (17)6第六天(20130126)for循环break.continue,标签的运用 switch (18)*1 for循环的格式: (18)*2java语言中的break语句的应用。

(18)*3break标签在java语言,带标签的break语句的应用。

(18)*4java语言中的continue语句的应用。

(19)*5带标签的continue语句的应用。

(19)*6switch语句多分支选择结构语句: switch语句(也称之为开关语句) (19)*7键盘输入和格式化输出 (20)*8 java语言中的格式化输出的应用。

(20)8.第八天(20130128~20130129)面向对象程序设计的讲解 (20)*1什么是对象 (20)*2什么是封装性?封装性体现了什么优越性 (21)*3 方法的结构如何或者说方法的组成如何? (21)*4方法的访问权限 (21)*5 形参和实参 (22)*6面向对象的程序设计的封装性如何体现? (22)*7类的构造 (22)*8this关键字的讲解 (22)9 第九天(20130130)final 与静态变量的讲解 (23)*1什么是最终的实例变量? (23)*2什么是静态变量? (23)*3什么是静态方法? (23)*4在什么情况下将方法编写为静态的? (23)10第十天(20130131)初始化块与静态初始化块的讲解 (24)*1什么是初始化块? (24)*2什么是静态初始化块? (24)*3包的设计 (24)11第十一天(20130201)JAVA常用类 (25)*1基本类型的封装类有哪些? (25)*2String类的补充方法 (26)*3java语言中的可变字符串 (26)*4通过DateFormat类来实现日期与时间的格式化。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

Java学习笔记Java概述java语言是解释执行,java源码是通过编译生成一种特殊的.class的中间字解码文件,然后再有JVM进行解释执行。

java语言对指针进行了上层的封装,它保证能够通过这个指针(引用)来访问有效的内存单元.java语言不允许多继承,使继承关系成树装图,每个类都只能由一个父类。

java语言的开发效率高,但执行效率低。

(相当于c++的55%)java的垃圾回收机制,在java中new的对象不需要向c++一样进行delete操作,JVM会根据情况回收垃圾对象。

(懒汉机制,等待资源没有的时候才回收)我们只能够建议JVM进行垃圾回收,例如(System.gc() RunTime。

gc()这两个方法就是建议JVM进行垃圾回收的方法)JDK,java开发工具包(类库和运行命令),JRE,java运行环境,JVM,java虚拟机(解释执行的核心,对字节码进行翻译成运行环境的机器码,它可以屏蔽平台差异。

JVM是不跨平台的。

)JAVA_HOME,指明JDK安装的位置,CLASSPATH,指明类文件的位置,PATH,指明命令的可执行文件的位置。

java源文件的文件名必须和文件中定义public class的类名(大小写页要相同)相同。

java源代码中的main方法的定义写法。

main方法是程序的入口.public static void main(String[] args){System.out。

println("Hello world");}java源文件也要先编译,使用javac xxx。

java格式的命令得来编译,使用java xxx来运行。

定义包结构要放在有效代码的第一行,package xxx。

xxx,包的定义在一个程序中只能由一个,在加上包定义之后编译可以使用javac —d 路径 xxxx.java,这个-d这个命令行的参数可以指定包结构的位置“."代表当前目录.在运行时要使用类的全名java xxx.xxx。

xxxx用包名以点分隔。

运行时要在包结构的上一层目录来运行。

java中的注释单行注释 //.....。

多行注释 /*。

.。

.。

*/文档注释/** ..。

..。

<p>(换行标签)*/,用javadoc命令可以根据原码中的文档注释生成注释文档(html格式).文档注释中可以使用html标签。

javadoc —d 路径(指定注释文档的保存路径)文档注释一般写在类定义之前,方法之前,属性之前。

在文档注释中可以用@author 表示程序的作者,@version 表示程序的版本,前两个注释符号要写在类定义之前,用于方法的注释@param 对参数进行注释,@return 对返回值进行注释@throws对抛出异常的注释.jar命令用于打一个xxx.jar文件用法:jar {ctxu}[vfm0Mi][jar-文件] [manifest-文件] [—C 目录] 文件名。

..选项:-c 创建新的存档—t 列出存档内容的列表-x 展开存档中的命名的(或所有的〕文件-u 更新已存在的存档-v 生成详细输出到标准输出上—f 指定存档文件名-m 包含来自标明文件的标明信息-0 只存储方式;未用ZIP压缩格式—M 不产生所有项的清单(manifest〕文件—i 为指定的jar文件产生索引信息—C 改变到指定的目录,并且包含下列文件:如果一个文件名是一个目录,它将被递归处理.清单(manifest〕文件名和存档文件名都需要被指定,按'm’和 'f'标志指定的相同顺序示例1:将两个class文件存档到一个名为 'classes。

jar' 的存档文件中:jar cvf classes.jar Foo.class Bar。

class示例2:用一个存在的清单(manifest)文件’mymanifest' 将 foo/ 目录下的所有文件存档到一个名为’classes。

jar' 的存档文件中:jar cvfm classes。

jar mymanifest —C foo/ 。

一般在使用使用jar cvf 文件名。

jar 文件所在路径(xxx/xxx/xxx.class)也可以压缩一个目录,只要在制定路径是指定为文件夹,jar命令的命令行参数在使用时可以以“—"开头,也可以不用。

java程序的运行过程,首先是启动java虚拟机,然后就是去找。

class文件,先是从系统的类库中找(系统之会在跟目录下查找,所以需要完整类名),如果找不到的话会去CLASSPATH所设置的目录去找。

然后加载到java虚拟机中。

系统会在每个java程序中隐含导入了ng这个包,import 包名,导入包中的类文件。

ng包,这是一个基础包。

java.util包,这个包是工具类的包.java.io包,这个包是用于输入输出操作的包,这个包是用于网络编程。

java。

awt,java。

swing,javax.swing,java.event等包用于图形编程用的包。

applaction java的应用程序,java应用程序中必须有一个main()方法.标识符和关键字Java代码中的“;”、“{}”、“ "Java语句以分号分隔,Java代码块包含在大括号内,忽略空格.标识符1) 用以命名类、方法和变量、以及包遵守JAVA的命名规范类以每个单词都以大写字母开头。

方法和变量第一个字母不大写,其他照旧。

2)只能以字符、“_”或“$”开头;3)无长度限制。

java中的关键字goto和const在java中虽然不再使用但是还作为关键字存在java中没有sizeof这个关键字了,java中的boolean类型的值只能用true和false,且这两值也是关键字。

java语言中没有无符号这个关键字(unsigned)java中的数据类型1)整型byte 1字节 8位 -128到127short 2字节16位 -2^15到2^15—1int 4字节32位—2^31到2^31—1long 8字节64位 -2^63到2^63-12) 浮点类型float 4字节32位double 8字节64位3) 字符类型char 2字节16位4)布尔型boolean false/true注:1) char是无符号的16位整数,字面值必须用单引号括起来; ‘a’2) String 是类,非原始数据类型;3) 长整型数字有一个后缀为“L"或“l”,八进制前缀为“0”,十六进制前缀为“0x”; 4)黙认浮点类型为double;5) float数据类型有一个后缀为“f”或“F”,Double数据类型后可跟后缀“D"或“d“ 6)char类型也可以用通用转译字符,但是不能用ASCII码.可以用“\u0000”这种格式,因为char型中使用的是unicode编码方式。

注:整型值存放,正数存放原码(二进制码),负数则存放补码(原码按位取反末位加一)。

注:实型值在存储时会损失精度,所以不要直接比较两个实型值。

系统默认的实型都是double型,要使用时要在数据后加个f,或者强行转换.强转(占字节数大的类型转到占字节数小的类型)时会放弃高位值只取低位值。

java中的数字数据类型减灾由占字节数小的类型到占字节数大的类型的可以有自动转换,反之则需要强行转换,char型和int型之间可以相互转换。

char和short不能像户转换.注意:隐式类型转换;a 运算符b ,如果a,b中有任意一个是double型,前面运算的结果就是double型,如果a,b中有任意一个是float型,前面运算的结果就是float型,如果a,b中有任意一个是long型,前面运算的结果就是long型,如果a,b中没有double、float、long型,那么其结果就为int型。

所有基本数据类型在使用时会事先分配空间,只本身就存在空间中,在传递时,就是值传递,不是引用传递。

在类中定义的方法在返回值前加上static修饰符就可以在main方法中调用了。

如果不用static那就需要在main方法中创建对象,使用对象来调用对象的方法。

public class Test{public static void main(String[] args){Test t=new Test();int b=1;int c=2;int[] a=new int[10];t。

sqort(a);add(b,c)}public int[] sqort(int[] a){.......}static int add(b,c){...。

.。

}}java中的运算符(java的运算符的优先级和结合性和c++相同)System。

out。

println(3/2) 按整型计算得11)〉>= 前面是零补零,前面是一补一;2) >>>= 无符号右移(强制右移都会移进一),>>=和〉>〉=对于负数不一样正数:右移n位等于除以2的n次方负数:变成正数。

3) &&短路与,前面为假,表达式为假,后面的操作不会进行,&会对所有条件进行判断。

4) ||短路或,前面为真,表达式为真,后面的操作不会进行,|会对所有条件进行判断。

例:if(a<3&(b=a)==0) b赋值if(a<3&&(b=a)==0) b不赋值5)instanceof,是用于判断一个对象是否属于某个类型6)java中的求余运算符“%"可以对两个实型变量求余注:按位与是为了让某些位置一,按位或是令某些位置零,按位异或是令某些位取反.注:使用左右位移和无符号右移运算符的使用方法是变量名〈<=位移位数 ,变量名>〉=位移位数 (前两个运算符是不会忽略整形符号位,也称逻辑位移),变量名〉>〉=位移位数注意:左右位移和无符号右移运算符只能用于整形及其兼容类型(byte,int,short,long)注意:java程序的运行过程,首先是启动java虚拟机,然后就是去找。

class文件,先是从系统的类库中找(系统之会在跟目录下查找,所以需要完整类名),如果找不到的话会去CLASSPATH所设置的目录去找.然后加载到java虚拟机中。

如果要使用到其他的在JAVA_HOME 中没有的类或者是其他公司提供的第三方的。

jar(jar包)文件时,要把它的路径及文件名加到CLASSPATH中。

java的流程控制控制流if()if()…。

elseif()…。

.else if()….else注意:else只是和其上面的同层的最近的if()来配对。

switch(){case 'a':……。

相关文档
最新文档