Java知识总结--CoreJava

合集下载

JAVA目前所学知识总结

JAVA目前所学知识总结

1、关键字:其实就是某种语言赋予了特殊含义的单词。 保留字: 其实就是还没有赋予特殊含义,但是准备日后要使用过的单词。 2、标示符:其实就是在程序中自定义的名词。比如类名,变量名,函数名。 包含 0-9、 a-z、$、_ ; 3、常量:是在程序中的不会变化的数据。 4、变量:其实就是内存中的一个存储空间,用于存储常量数据。 作用:方便于运算。因为有些数据不确定。所以确定该数据的名词和存 储空间。 特点:变量空间可以重复使用。 什么时候定义变量?只要是数据不确定的时候,就定义变量。 5、java 的命名规范: a:变量只能包含数字,字母,下划线与$ b:不能以数字开头 c:不能是 java 关键字 d:最好是有意义的英文单词,首字母小写 变量的申明:数据类型 变量名称 = 变量的值(即变量空间的开辟需要 的要素) 房间类型 房间号码 = 房间住的人 6、变量的作用域和生存期: 变量的作用域:作用域从变量定义的位置开始,到该变量所在的那对大 括号结束; 生命周期:变量从定义的位置开始就在内存中活了; 变量到达它所在的作用域的时候就在内存中消失了; ★7、数据类型: 1、基本数据类型:byte、short、int、long、float、double、char、boolean 2、引用数据类型: 数组、类、接口。 级别从低到高为: byte,char,short(这三个平级)-->int-->float-->long-->double 自动类型转换(隐式转换):从低级别到高级别,系统自动转的,安全。 强制类型转换(显式转换):把一个高级别的数赋给一个比该数的 级别低的变量,不安全。 3、运算符号: 1、算术运算符 二元:+ - * / % 2、变量操作符:一元,++,-++在前是先自身加 1 再拿结果去计算 ++在后是先拿自身去计算,然后在自身+1 3、赋值运算符:一元,= += -= *= /= %= 4、 比较运算符:>,>=,<,<=,==,!=比较运算符得到的结果是 boolean 5、逻辑运算符:& | ^ ! && || &:位与==》只有同为 1 才为 1,其他都是 0

java全技术总结

java全技术总结

注意:
package
import
class
这三个顺序是不可改变的
பைடு நூலகம்
习惯上:加包,加注释,换行,缩进
7、注释
单行注释://
多行注释:/*.....*/
/**.....*/ 这个也是多行注释,但编译时会把这种注释抽出来放在html中做成帮助文档
char c='\u0061' -----unicode码值(16进制) 1个16进制表示2个字节
对象类型
字符串:String str="abc";
a+b 若有一方为字符串,则为字符串连接
"1"+2+3 结果是"123"
1+2+"3" 结果是"33"
byte a=1;byte b=2; byte c=a+b; //error!!! 因为a+b后自动把类型提升为int,把4个字节的赋给低
正确写法: byte c=(byte)a+b;
short 2B -32768~32767
int 4B -2147483648~2147483647
数组元素有默认值:默认值是各式各样的0
数组元素默认值规则:
int 0
long 0l
float 0f
double 0d
boolean false
对象数组 null(空指针)
export JAVA_HOME CLASSSPATH
windows下:我的电脑--->属性---->高级----->环境变量

CoreJava笔记之JavaBean、静态方法static和final

CoreJava笔记之JavaBean、静态方法static和final

CoreJava笔记之JavaBean、静态⽅法static和final记住两句话:1.属性是静态绑定到变量类型;2.⽅法是动态绑定,由最终对象的⽅法决定===============================关于JavaBean:1、不是语法规则,是习惯性编程规范,⽤这个规范写的类使⽤⽅便;2、规范:a、必须有包;b、是⼀个java类,具有⽆参数构造器;c、有⽤getXxx() 和setXxx()声明的Bean属性。

如:getName()和setName(String n)声明的Bean属性为:name,与是否有实例变量name⽆关。

boolean类型的get⽅法可以有两种形式:getMarried()或者isMarried()d、必须实现序列化接⼝(在学习IO的时候具体学习)e、JDK提供的类⼏乎都符合JavaBean规范,如String3、JavaBean最⼤的好处:“使⽤⽅便”===============================实例变量:对象的属性,每个对象都不同,如:矩形的宽度static 修饰词(关键字),⽤来修饰类的成员的1、静态修饰的成员变量,是属于类级别的变量,是在类的加载期间分配的,所有类和类的实例共享的⼀个变量,相当于全局变量。

⼀般使⽤类名访问静态属性,Koo.x = 3;2、静态的⽅法。

是属于类的⽅法,可以通过类名访问。

是全体类公有的⼯具⽅法。

静态⽅法和类的实例⽆关。

注:静态⽅法中不可以⽅位“this”,或者说:静态⽅法访问静态成员。

3、静态代码块,是在类加载期间运⾏的代码块,由于类只加载⼀次,所以静态代码块只执⾏⼀次!⽤途不是很常见,⼀般⽤来在类加载以后初始化⼀些静态资源时使⽤,如:加载配置⽂件。

4、静态内部类(参见以后的内部类笔记)===========================1、final修饰的类,不能再被继承java的string就是final类,不能被继承!在实际开发中,原则上不允许使⽤final类!2、final修饰的⽅式,不能再被覆盖3、final修饰的变量,初始化以后不允许在修改了final局部变量、⽅法参数、成员变量4、final static -- java使⽤final static 修饰的变量作为常量,⼀般要求常量名都有⼤写字母。

CoreJava总结

CoreJava总结

CoreJava总结第一篇:CoreJava总结Java概述一、JDK/JRE/JVMJDK:JAVA开发工具包,比JRE多了一些开发和调试的命令,比如javac、java等等。

JRE:JAVA运行环境JVM:JAVA虚拟机包含关系:JDK包含JRE,JRE包含JVM三、配置环境变量JAVA_HOME:JDK的安装路径CLASSPATH:类的搜索路径PATH:命令的搜索路径--右键我的计算机-->高级-->环境变量-->在系统变量或者用户变量上配置-->JAVA_HOME:当前机器上JDK的文件目录“C:Program FilesJavajdk1.6.0_05”CLASSPATH:类的搜索路径“.”当前目录Path:命令的搜索路径...;%JAVA_HOME%bin--开始-->运行-->cmd-->java验证是否配置成功二、注释三种:1、单行注释: //...2、多行注释: /*...*/3、文檔注释: /**......*/ 另一种多行注释,但是这种注释可以生成API文檔(HTML格式的)提取API文檔的命令:javadocjavadoc应用,提取说明文件javadoc XX.java-d 生成文文件路径比如:javadoc String.java-d.stringdoc在String.java所在的檔夹中便会生成一个stringdoc檔夹,里面是html格式的解释文檔顺便教下学生看API文檔三、标识符只能以字母,“_”,“$”符号开头,不能以数位开头支持汉字四、良好的编码习惯1、类的首字母要大写,如果有多个单词,每个单词首字母都要大写比如:HelloWorld2、接口名命名与类名一样3、方法名第一个单词小写,以后每个单词的首字母都大写比如:getName4、变量名的命名习惯和方法名的相同5、常量(不可改变的)的名字所有字母都大写,单词与单词之间用“_”连接比如:DRIVER_NAME6、包名所有字母都小写三、关键词(50个)自己命名变量名或者其它名字不能和关键词的一样true,false,null不是关键词,是字面值,同样不能把这些单词作为名字goto和const是保留字,并不应用于java开发,也不能作为其它名字使用其它语言中goto语句的用法(无条件跳转)java中的代替goto的是break loop;loop是个标号,标记一个循环,break loop就结束了这个循环数据类型和控制结构一、数据类型boolean 两个值true或者false,占8个二进制位byte8位整数short16位整数char16位的Unicode编码,有足够的空间保存非英文字符--'A':65,'a':97,'0':48int32位整数long64位整数float32位浮点型double 64位浮点型二、String类型:是一个类,而不是基本类型赋值的话就用双引号引起来,比如String a=“abc”;三、整型数据整型变数赋值int ia=0x55;//这种赋值是可以的,赋值为了一个16进制资料byte bb=0x771;//0x771已经超出了byte的取值范围,所以编译这句话会出错byte ba=(byte)0x771;//把0x771强制转换成bytelong la=1234567L;//给long类型的变量赋值四、浮点型数据1、赋值float fa=123.4F//后面加个Fdouble d=123.456D//后面的D跟不跟都可以类型转换:自动类型转换小范围---◊大范围Byte-◊ short-◊ int-◊ long-◊ float-◊ doubleChar-◊ int在表数范围内的常数可以自动转换强制类型转换五、垃圾回收1、如果某一个对象没有引用指向它了,那么这个对象就是个垃圾对象比如String s=new String(“...”);s=null;那被new出来的String对象就是一个垃圾数据了2、垃圾回收机制对于没有被引用的对象,java JVM会自动回收System.gc()提醒虚拟机进行垃圾回收,但只是提醒建议break和continue后面可以加下标,跳出循环和继续循环。

CoreJava笔记—基础部分

CoreJava笔记—基础部分

2010-7-23猛哥推荐技术网站CSDN IBM中国 J道 javaBBSJava语言的好处1、加速开发速度2、一次编写到处运行(跨平台,windows下的ext在linux,unix下不可执行)3、简化开发,降低开发难度4、对外没有指针(JVM是用C++实现的)Java属于复合型:先编译后解释。

JDK的环境变量配置Windows下在我的电脑☞系统属性☞高级☞环境变量配置JAVA_HOME 中配置的是java的安装目录Classpath中配置的是class文件的目录,一般配置,既可以配置jdk中的jar包进去(JDBC会自动配置),类库的路径(lib),”.”一般代表当前目录Path中配置的是可执行命令的路径(bin),path在windows系统变量中是有的,配path 时千万不要将原来的内容删除,在最前面配置。

linux下Java环境的配置Linux:/etc/.profile这是所有用户的全局文件主目录下的.bash_profile 这是当前用户的全局文件到当前用户的目录下,用vi .bash_profile在文件的最后加上以下内容(文件非空) export JAVA_HOME=某个目录(bin和lib的上层);expert PATH=某个目录/bin:$PATH;其中PATH绝对不能错,否则系统会崩溃export CLASSPATH=.:某个目录/lib;保存退出。

二、第一个程序体验步骤:1、vi xx.java2、编辑xx.java文件3、javac编译生成xx.class文件4、如编译通过,用java 包名.类名运行package day01;public class First{public static void main(String[] args){String name="wang";int age=25;System.out.println("my name is :"+name);System.out.println("my age is :"+age);}}编译运行:编译:javac -d . First.java //-d 代表生成目录,.代表当前目录,把目录生成到当前。

Core Java 第六章知识点总结

Core Java 第六章知识点总结

Core Java 第六章知识点总结——面向对象知识点预览对象的概念类的概念方法方法的重载(Overloading)构造方法对象与引用this关键字对象的概念1. 什么是对象(具体的定义状态(属性)和行为(方法)的一个实体)一切客观存在的事物都是对象2.对象的组成属性有什么(描述对象)对象的属性也可以是对象方法能做什么(自己使用别人使用)3.计算机世界中的对象(连续的存储空间)类的概念1. 类是什么具有相同行为和状态的对象的集合a)类是对大量共性的抽象b)类是客观事物在人脑中的主观反映c)类是创建对象的模板先有类,后有对象class Student{String name;//属性、实例变量、成员变量int age;}2. 定义类、创建对象a) 创建对象 new Student();b) 定义一个变量存储创建的对象Student s;s = new Student();可写在一起Student s = new Student();基本类型8种对象类型(引用):数组、对象、接口3. 实例变量(类中的变量)属于对象a)访问 .b)属性初始化class Student{String name = “suns”;int age;}4. 实例变量(类)与局部变量(方法)的区别局部变量先赋值后使用作用范围(从定义的代码块开始到定义的代码块结束)命名不可冲突(同一作用范围内)实例变量可以不赋值就使用a)实例变量存在默认值(各种各样的0)b)实例变量至少在本类的范围内有效c)实例变量可以和局部变量命名冲突,局部变量优先使用方法方法声明、方法实现1. 格式修饰符返回值类型方法名(参数1,参数2) [异常]{方法体}方法的重载(Overloading)1. 方法重载(Overloading)同一个类中方法名相同、参数不同2. 源码参考class A{//参数个数不同void m(){}void m(int a){}void m(int a,int b){}//参数类型不同void m(String s){}//参数类型相同但排列不同void m(int a,String s){}void m(String s,int a){}//形参名字不同不算重载void m(int a){}void m(int b){}}3. 方法重载的意义对方法的调用者屏蔽因方法参数不同所造成的差异构造方法特殊性:定义语法作用1.构造方法的概念publicStudent(){}a)没有返回值类型(和没有返回值void不同)b)方法名同类名一致c)用在对象的创建构造对象2.构造方法的重载3. 构造方法的特点a)构造方法不能手工调用,被JVM自动调用Student s = new Student();//告诉虚拟机s.Student();b)构造方法在对象构造时,被自动调用一次,而且只会被调用一次i. 分配空间ii. 初始化属性iii. 调用构造方法c)构造方法没有返回值d)如果一个类中没有定义构造方法,系统默认提供一个公开的、无参的空构造方法4. 构造方法的使用场景构造方法经常用于给实例变量赋值对象与引用1.引用概念Student s;s = new Student();2.引用存储的是对象内存空间的首地址s.print();//遥控器与电视机的关系s指向首地址3.程序中的值传递简单类型存储值(在内存中)对象类型存储地址[java]view plaincopy1.//TestValue1.java2.package chp6.ex08;3.4./**5. *6. * 说明:本程序演示了值传递结果为10 基本类型内存中存的是值7. */8.public class TestValue1 {9.public static void main(String args[]){10.int a = 10;11.int b = a;12. b++;13. System.out.println(a);14. }15.}16.17.//答案:1018.19.//TestValue2.java20.package chp6.ex09;21.22./**23. *24. * 说明:本程序演示了值传递结果为21 对象类型内存中存储的是地址25. */26.public class TestValue2 {27.public static void main(String args[]){28. Student s1 = new Student();29. Student s2 = s1;//s2和s1指向的是同一地址30. s2.age = 21;31. System.out.println(s1.age);32. }33.}34.class Student{35.int age = 20;36.}37.38.//答案:2139.40.//TestValue3.java41.package chp6.ex10;42.43./**44. *45. * 说明:本程序演示了方法中的值传递结果为10 基本类型内存中存的是值46. */47.public class TestValue3 {48.public static void main(String args[]){49.int a = 10;50. m1(a);51. System.out.println(a);52.53. }54.55.public static void m1(int a){56. a ++;57. }58.}59.60.//答案:1061.62.//TestValue4.java63.package chp6.ex11;64.65./**66. *67. * 说明:本程序演示了的方法中的值传递结果为21 对象类型内存中存储的是地址68. */69.public class TestValue4 {70.public static void main(String args[]){71. Student s = new Student();72. m2(s);73. System.out.println(s.age);74.75. }76.public static void m2(Student stu){77. stu.age++;78. }79.}80.class Student{81.int age = 20;82.}83.this关键字1. this关键字的概念this是一种特殊的引用,指向当前对象2. this的作用a) 如果方法局部变量与实例变量命名冲突时,可以通过this属性的方式区分实例变量和局部变量b) 如果发生一个构造方法中需要调用另一个构造方法,可以通过this()的方法调用,但this()必须书写在第一行String类1. 创建一个字符串对象String s = “suns”;String s = newString(“suns”);2. 字符串值的判断equals方法Stri ng s1 = newString(“suns”);String s2 = newString(“suns”);System.out.println(s1== s2);//false ==判断引用System.out.println(s1.equals(s2));//true equas判断内容3. 串池(””创建的字符串独立存储在内存的串池空间中)String s1 = “suns”;String s2 = “suns”System.out.println(s1== s2);//true4. String类中的常用方法booleanequals();char charAt(intpos);int length();//方法数组length为属性String[]split();booleanstartWith(String s);trim();StringsubString(int begin,int end);//”suns”.subString(0,2);su5. 字符串的连接//不好过多侵占内存空间String s1 = “sun”;String s2 = “shuai”String s2 = s1 +s2;//推荐使用不会开辟新空间StringBuffer sb= new StringBuffer(); sb.append(“sun”);sb.append(“shuai);System.out.println(sb);。

CoreJava第三章总结

CoreJava第三章总结

CoreJava第三章总结最近下定决⼼⼊坑后端了,要学的⽐较多,⾸先本周把之前看的Core Java复习⼀遍。

VIO课结课了,拿了优秀学员,但是可能不会去做这个了吧,有空把作业内容补上来数据类型:8种基本类型整型4种int 4 short 2 long 8 byte 1浮点2种float 4 double 8(⼤部分都⽤double)⽤p不是e⾮数值:⽆穷⼤ Double.POSITIVE_INFINITY⼩。

NEGATIVENaN:0/0或负数平⽅根⾮数值都认为不等浮点不能⽤if(x==Double.NaN)要⽤if(Double.isNaN(x))保证精度的场合需要BigDecimal类char 不怎么⽤UTF-16 2-4个字节boolean 和C不同不能直接和整型转换变量:每个变量属于⼀个类型type声明后必须显式初始化。

声明尽可能靠近第⼀次使⽤的地⽅final关键字指⽰常量,赋值后不能更改类常量:static final, 定义在main⽅法外,所有类中⽅法都能⽤运算符与或⾮&& || !,三元 a?b:c移位>>>⽤0填充,>>根据符号数填充(补码)类型转换:规则和c⼀样,强制类型转换也是加括号运算符级别同C枚举类型:enum Size{ Small, Medium, Large};Size s = Size.Medium;//可以写null字符串:实际上是Unicode序列,标准库中有预订义类Strings.substring(a,b);拼接⽤+ 任何对象都能转成StringJava中字符串不可更改,只有新字符串!但是存储区可以共享(指针指向同⼀个)s.equals和==不同,⼀个⽐较内容,⼀个⽐较引⽤。

(记得String的equals⽅法被重载过,看到了回来确认)API太多了StringBuilder类new出⼀个对象,不断append添加内容,可以⽤setCharAt更改字符,以及insert插⼊,以及delete,最后输出时toString() StringBuilder 在添加字符时不同于StringBuffer有Sychronized关键字,导致线程不安全,这两个类都是通过底层的char数组以及控制⼀个count数值控制字符串⼤⼩。

CoreJava全套详细笔记(心血放出)资料

CoreJava全套详细笔记(心血放出)资料

目录1.原码、反码、补码 (5)1.1.原码 (5)1.2.反码 (5)1.3.补码 (5)1.4.负数的补码转换为十进制数 (6)2.char (6)3.运算符 (6)3.1.移位运算符 (6)3.2.位运算符 (7)3.3.逻辑运算符 (7)4.流程控制 (7)4.1.switch (7)4.2.break和continue (8)5.方法 (8)5.1.构造方法 (8)5.2.方法重载 (8)6.this (9)7.继承 (9)7.1.super (9)7.2.多态(polymorphism) (10)7.3.instanceof (10)8.static (11)9.final (11)10.abstract (12)11.类的加载 (12)11.1.触发类加载的几种情况 (12)11.2.类加载的顺序 (12)12.接口(interface) (13)13.访问控制 (14)14.Object类 (15)14.1.clone() (15)14.1.1.对象克隆过程 (15)14.1.2.浅复制和深复制概念 (16)14.2.finalize() (16)14.3.equals(Object obj) (16)14.4.toString() (16)15.String类及对象池 (16)15.1.String a="hello"; (17)15.2.String c=new String("hello"); (17)16.StringBuffer和StringBuilder (17)17.主方法参数 (18)18.方法的可变长参数 (18)19.包装类 (18)19.1.Number (19)19.2.自动封箱/自动解封(Autoboxing/Unboxing) (19)19.3.对象池 (19)20.内部类 (20)20.1.意义 (20)20.2.四种形式的内部类 (20)20.2.1.静态内部类 (20)20.2.2.成员内部类 (21)20.2.3.局部内部类 (22)20.2.4.匿名内部类 (22)20.3.内部类的应用 (24)21.集合框架(Collection Framework) (24)21.1.Iterator接口和Iterable接口 (25)21.2.Connection接口和Connections类 (25)21.2.1.java.util.Collection (25)21.2.2.java.util.Collections (25)21.3.List(列表)接口 (25)21.3.1.ArrayList (26)21.3.2.LinkedList (26)21.3.3.Vector (26)21.4.Set(集合)接口 (26)21.4.1.HashSet (27)21.4.2.TreeSet (29)21.5.排序的两种办法 (29)parable(可比较的) (29)parator(比较器) (30)21.6.Map (30)21.6.1.HashMap (30)21.6.2.Hashtable (31)21.6.3.Hashtable下的子类Properties类 (31)21.6.4.SortedMap接口下的TreeMap类 (31)22.泛型(Generic) (32)22.1.泛型特点 (32)22.2.通配符 (32)22.2.1.上限通配符: (32)22.2.2.下限通配符 (33)22.2.3.总结: (33)22.3.运用 (34)23.异常 (34)23.1.异常处理基础 (34)23.2.异常的类继承结构 (34)23.3.常见的未检查异常 (35)23.4.throw (35)23.5.自定义异常类 (36)24.反射(Reflection) (37)24.1.反射需要用到的类 (37)ng.Class (37)ng.reflect.Field (38)ng.Package (38)ng.relect.Modifier (38)ng.reflect.Mothed (38)ng.reflect.Array (38)ng.reflect.Constructor (38)24.2.三种获得某个类的Class对象的方法 (38)24.2.1.Class c=Class.forName("类名"); (38)24.2.2.Class c=类名.class; (39)24.2.3.Class c=对象名.getClass(); (39)24.3.所能探查出来的类的特征 (39)24.4.通过反射生成一个类的实例 (39)24.4.1.第一种方法 (40)24.4.2.第二种方法 (40)25.File (40)25.1.构造方法 (40)25.2.重点方法 (41)25.3.目录 (42)26.流 (42)26.1.字节流 (42)26.2.字符流 (44)26.3.节点流(Node Stream): (45)26.4.过滤流(Filter Stream) (45)26.5.ObjectInputStream和ObjectOutputStream (46)26.6.字节流转化成字符流的桥转换器 (48)26.7.文本文件和二进制文件 (50)27.线程 (50)27.1.概念与原理 (50)27.1.1.操作系统中线程和进程的概念 (50)27.1.2.Java中的线程 (51)27.1.3.Java中的线程模型 (51)27.1.4.一些常见问题 (51)27.2.线程状态的转换 (52)27.2.1.线程的七种状态 (52)27.2.2.阻止线程执行 (54)27.3.线程的同步与锁 (55)27.3.1.同步和锁定 (55)27.3.2.静态方法同步 (60)27.3.3.如果线程不能获得锁会怎么样 (60)27.3.4.何时需要同步 (61)27.3.5.线程安全类 (61)27.3.6.线程死锁 (62)27.3.7.线程同步小结 (63)27.4.线程的交互 (64)27.4.1.线程交互的基础知识 (64)27.4.2.多个线程在等待一个对象锁时候使用notifyAll() (66)27.5.守护线程(后台服务线程) (67)27.6.并发协作-生产者消费者模型 (68)27.7.volatile关键字 (68)28.网络编程 (69)28.1.TCP Socket编程 (69)28.1.1.ServerSocket (70)28.1.2.Socket (70)28.2.UDP Socket编程 (71)28.2.1.DatagramSocket (71)28.2.2.DatagramPacket (71)1.原码、反码、补码1.1. 原码将最高位作为符号位(以0代表正,1代表负),其余各位代表数值本身的绝对值(以二进制表示)。

CoreJAVA核心个人见解

CoreJAVA核心个人见解

CoreJava核心技术一、概念:1、配置Java的运行环境在.bash_profile中添加环境变量:export CLASSPATH=.:$CLASSPATH(系统去查找字节码,按字节路径搜索) Export JAVA_HOME=./opt/jdk/ (jdk的安装目录) export PATH=$PATH:$JAVA_HOME/bin:$HOME/bin(按命令搜索的路径/jdk/bin 类库文件:rt.jar中有很多.class文件)想要在多个终端中使用需要source .bash_profile之后重启.且机器上装有JDK(用于开发里头的bin用于连接数据库文件 lib用于java的归档文件)和JRE(由于运行)和JVM(用于跨平台)没有主(main)方法的类是不可运行的,但可以编译2、JAVA的特点:简单(java可自动的回收垃圾)、安全(可以使用指针,但不可以对指针进行操作)、跨平台(通过JVM的技术从源码—字节码—jvm—系统通过字节码可在多种系统中运行java屏蔽了底层平台的差异统一了运行的环境)。

其产生于1995-5-23日3、标识符命名规则1)可以用数字、字符、字母、组成,不可以使用关键字2)必须以下划线(_)或“$”或字母开头3)严格区分大小写a)类名和方法名一般都以大写开头之后的单词以首字母大写命名b)变量和方法名一般都以首个单词小写后单词的首字母大写命名c)常量一般都是大写的单词与单词之间以下划线(_)隔开,用final关键字定义d)Java中有50个关键字,true、flaseh和null不是关键字但也不可用;goto、const是关键字但也不用再程序中使用;4、对类的定义(类名一般是以大写字母开头后面的单词的首字母大写)在java文件中可以定义多个类,但最多只能有一个public类,而且该public类的类名必须与文件名一致Java源文件在变异后形成的字节码文件数与该源文件中定义的类的个数相同,每个类的编译后形成对应的字节码文件一个可运行的java必须包含一个main方法,该方法是程序运行的入口方法,main方法不一定包含在public的类中Public class FirstJava{Public static void main(String[] args){System.out.println(“hi MyFirstJava!”);}}编译:javac FirstJava.java运行:Java FirstJavaJava的运行顺序:1启动JVM虚拟机;2装载包(从当前类所在的包中找,在从jre/bin/***.jar中找,再从CLASSPATH中的路径中找;先找到那个就是用那个后面就不找了,如果找不到测出错);3运行5、package包的定义:它可以大量的存放字节码功能相似或相同的类放在一个包中(一般的包名是小写)只有在ng包下的类可以无需导入其他都要用import导入一次可导入多个包import java.util.*1 package com.tool;Public class FirstJava{Public static void test(){System.out.println(“hi MyFirstJava!”);}}2 package com.tool;Import com.tool.FirstJava;//调用包Public class TestJava {Public static void main(String[] args){FirstJava.test();}}编译:javac FirstJava.java –d . javac TestJav a.javaJavadoc:把取出注示文档放入一个.html文件中把firstjava类打包成test.jar包放在个目录下:jar–cvf test.jar .(-c:创建;-v:可视化;-f:文件名)删除com文件夹,改环境变量exportCLASSPATH=$CLASSPATH:/home/soft01/myjava/test.jar 在任何的目录下都可运行Java TestJava6、数据类型注意:Char、byte、short、int、long统称为整型,其中char是用补码存储的-1—11111111;127—01111111;-128—10000000其他是正的就是二进制源码,负的是源码取反加1;char a=’a’;int b=97;a=’\u0061’=’a’=b; Ox123:表十六进制;o12433:表八进制;char没有负数;自动转化的从范围小的到大的Byte—>short—>int—>long—>float—>double以及char—>int也可自动转化;其他情形需要强制转化(类型),但boolean型无法强制转换成整型或浮点型,强制转换可能有数据和精度的丢失(与存储的空间的结构有关),也可能改变正负,大的取前几位,小的去后几位Java 的数据类型有三种:基本数据类型(8种)。

CoreJava笔记汇总

CoreJava笔记汇总
1
class 檔的源码。 jre 目录是 JDK 自带的 JRE ,里面也有 bin 目录,一般存放的是运行时的一些命令 jre 活页夹中的 lib 文件中有一些 jar 文件,里面都是一些 class 檔在虚拟机运行时作为类 代码其中一个比较重要的 jar 檔就是 rt.jar,里面放的是 JDK 给我们提供的一整套类库的字 节码。 五、配置环境变量 JAVA_HOME :JDK 的安装路径 CLASSPATH:类的搜索路径 PATH :命令的搜索路径 Linux: --一般 JDK 是放在/opt/jdk1.6.0_05 --配置环境变量的文件是主目录中的".bash_profile"文件 进入终端后:vi .bash_profile 在里面配置: JAVA_HOME=/opt/jdk1.6.0_05 CLASSPATH=. PATH=$PATH:$JAVA_HOME/bin:....... export JAVA_HOME export CLASSPATH export PATH --配置完后保存退出,然后 source .bash_profile 在命令行打 java 命令验证是否配置成功,如果成功了,注销一遍系统 Windows: --右键我的计算机-->高级-->环境变量-->在系统变量或者用户变量上配置--> JAVA_HOME :当前机器上 JDK 的文件目录 "C:\Program Files\Java\jdk1.6.0_05" CLASSPATH:类的搜索路径 "." 当前目录 Path:命令的搜索路径 ...;%JAVA_HOME%\bin --开始-->运行-->cmd-->java 验证是否配置成功 六、第一个 JAVA 程序 一个 java 檔只能定义一个 public 类,并且 public 修饰的类的类名要与文件名相同 vi MyFirstJava.java public class MyFirstJava{ public static void main(String[] args){ String name="tangliang"; int age=30; System.out.println("my name is:"+name); System.out.println("my age is:"+age); } } 写好后在命令行 cd 到文件所在目录,然后打 javac MyFirstJava.java 编译檔 编译成功后当前檔夹中会出现一个 MyFirstJava.class 文件

java core读书笔记

java core读书笔记

java core读书笔记摘要:1.Java核心概念介绍2.Java编程语言的特点3.面向对象编程的理解4.异常处理与日志记录5.数据结构与算法6.网络编程与多线程7.数据库操作与JDBC8.实战案例与项目经验分享正文:一、Java核心概念介绍Java作为一种广泛应用的编程语言,其核心概念包括:Java虚拟机、JRE 与JDK、Java核心库等。

了解这些概念有助于更好地理解和使用Java编程语言。

二、Java编程语言的特点1.简单:Java继承了C++的优点,摒弃了其缺点,如指针、多重继承等。

2.面向对象:Java是强面向对象的编程语言,提供了类、对象、接口等丰富的面向对象特性。

3.平台无关:Java代码可运行在任意支持Java虚拟机的平台上,实现“一次编写,到处运行”。

4.高效:Java的JVM可以进行字节码到机器码的直接编译,提高运行效率。

5.安全:Java提供了沙箱机制,确保应用程序在运行时的安全。

三、面向对象编程的理解面向对象编程(OOP)是一种编程范式,强调以对象为中心、封装、继承和多态等特性。

在Java编程中,我们需要熟练掌握类与对象的关系、类的封装、继承和多态等概念。

四、异常处理与日志记录1.异常处理:Java提供了丰富的异常处理机制,如自定义异常、捕获异常、抛出异常等。

2.日志记录:Java提供了日志记录工具,如System.out.println、Log4j、Logback等。

五、数据结构与算法1.数据结构:Java中常用的数据结构有数组、链表、栈、队列、树、图等。

2.算法:熟悉常用的排序算法(冒泡排序、快速排序、归并排序等)、查找算法(二分查找、哈希查找等)以及图算法等。

六、网络编程与多线程1.网络编程:Java提供了套接字编程、HTTP编程等网络编程技术。

2.多线程:Java支持多线程编程,需要掌握线程的创建、同步、通信等知识。

七、数据库操作与JDBC1.数据库操作:熟悉SQL语言、数据库连接技术等。

core java知识点总结

core java知识点总结

core java知识点总结Core Java is a foundational programming language that is widely used for developing applications and software. It provides a strong base for developing enterprise-level applications, web applications, and mobile applications. It is essential for any Java developer to have a clear understanding of core Java concepts in order to write efficient and error-free code. This article aims to summarize some of the key core Java concepts, including object-oriented programming, multithreading, collections, and I/O, among others.1. Object-Oriented Programming (OOP)Object-oriented programming is a programming paradigm that revolves around the concept of objects. In Java, everything is an object except for primitive data types. The key principles of OOP are inheritance, encapsulation, polymorphism, and abstraction.a. Inheritance: Inheritance is the mechanism by which a class can inherit properties and behavior from another class. It promotes code reusability and helps in creating a hierarchical relationship between classes.b. Encapsulation: Encapsulation is the concept of hiding the internal implementation details of a class and exposing only the necessary functionalities. It is achieved through access specifiers such as private, protected, and public.c. Polymorphism: Polymorphism allows objects to be treated as instances of their parent class, enabling flexibility and extensibility. There are two types of polymorphism in Java: compile time (method overloading) and runtime (method overriding).d. Abstraction: Abstraction is the process of hiding the implementation details and showing only the necessary features of an object. It is achieved through abstract classes and interfaces.2. MultithreadingMultithreading is a powerful feature of Java that allows concurrent execution of multiple threads within a single process. It is used to utilize the CPU efficiently and to create responsive and interactive applications. Java provides built-in support for multithreading through the ng.Thread class and the java.util.concurrent package.a. Creating Threads: Threads in Java can be created by extending the Thread class or implementing the Runnable interface. The run() method is overridden to define the task to be performed by the thread.b. Thread Synchronization: Synchronization is used to control the access of multiple threads to shared resources. Java provides the synchronized keyword, locks, and semaphores to achieve thread synchronization.c. Thread Communication: Communication between threads can be achieved using methods such as wait(), notify(), and notifyAll(). These methods are used to implement the producer-consumer problem and other synchronization scenarios.3. Collection FrameworkThe Java Collection Framework is a set of interfaces and classes that provide essential data structures and algorithms for storing and manipulating groups of objects. It includes the List, Set, Map, Queue, and Deque interfaces, along with their respective implementations.a. List: Lists in Java maintain the order of elements and allow duplicate elements. The key classes implementing the List interface are ArrayList, LinkedList, and Vector.b. Set: Sets in Java do not allow duplicate elements and do not maintain any specific order. The key classes implementing the Set interface are HashSet, LinkedHashSet, and TreeSet.c. Map: Maps in Java store key-value pairs and do not allow duplicate keys. The key classes implementing the Map interface are HashMap, LinkedHashMap, and TreeMap.d. Queue and Deque: Queues in Java follow the FIFO (First-In-First-Out) order, while Deques (Double-Ended Queues) support operations at both ends. The key classes implementing these interfaces are PriorityQueue and ArrayDeque.4. Input/Output (I/O)Java I/O is used for reading and writing data from and to external sources such as files, streams, and consoles. It provides classes and methods for performing various I/O operations, such as reading from a file, writing to a file, and handling character and byte streams.a. File I/O: File I/O in Java is performed using classes such as File, FileInputStream, FileOutputStream, FileReader, FileWriter, and RandomAccessFile. These classes enable operations such as reading and writing files, creating directories, and checking file attributes.b. Stream I/O: Stream I/O in Java is based on the concept of reading and writing data in a sequential manner. There are two types of streams: byte streams (InputStream and OutputStream) and character streams (Reader and Writer).c. Serialization: Serialization is the process of converting an object into a byte stream for transmission or storage. Deserialization is the reverse process of reconstructing the object from its byte stream. Java provides the Serializable interface and the ObjectOutputStream and ObjectInputStream classes for serialization and deserialization.5. Exception HandlingException handling in Java is a mechanism for handling runtime errors and abnormal conditions that may arise during the execution of a program. It provides a structured way to deal with unexpected situations and maintain the robustness of the application.a. Checked Exceptions: Checked exceptions are the exceptions that are checked at compile time. They are typically handled using try-catch blocks or by declaring them in the throws clause of a method.b. Unchecked Exceptions: Unchecked exceptions, also known as runtime exceptions, are not checked at compile time and can occur at runtime. They are typically caused by programming errors and should be handled using try-catch blocks.c. Custom Exceptions: Java allows developers to define custom exceptions by extending the Exception class or one of its subclasses. This allows for more specific and meaningful error handling within the application.6. GenericsGenerics in Java enable the creation of parameterized types, allowing classes, interfaces, and methods to operate on objects of various types while providing compile-time type safety. They prevent type mismatches and class cast exceptions at runtime and promote code reuse and robustness.a. Generic Classes: Generic classes are defined using a type parameter enclosed in angle brackets. This type parameter represents the type of objects that the class can operate on.b. Generic Methods: Generic methods are methods that can operate on objects of different types. They are defined using a type parameter before the return type of the method.c. Bounded Type Parameters: Bounded type parameters in generics restrict the types that can be used as arguments to a generic class or method. They are used to specify upper and lower bounds for the type parameter.7. Java 8 FeaturesJava 8 introduced several new features and enhancements to the language, including lambda expressions, functional interfaces, the Stream API, and the new date and time API.a. Lambda Expressions: Lambda expressions provide a concise way to represent anonymous functions. They are used for implementing functional interfaces and enable functional programming in Java.b. Functional Interfaces: Functional interfaces are interfaces that contain exactly one abstract method. They are used in conjunction with lambda expressions to enable the use of functional programming constructs in Java.c. Stream API: The Stream API provides a declarative way to process collections of objects. It allows for filtering, mapping, reducing, and iterating over collections in a functional style.d. Date and Time API: Java 8 introduced a new date and time API in the java.time package, which provides classes for handling dates, times, durations, and periods in a more flexible and comprehensive manner.8. AnnotationsAnnotations in Java are a form of metadata that can be added to code elements such as classes, methods, and fields to provide additional information about the code. They are widely used for marking code for special processing or adding information for tools and libraries.a. Built-in Annotations: Java provides several built-in annotations, such as @Override,@Deprecated, and @SuppressWarnings, which are used for indicating method overriding, deprecation, and suppression of warnings, respectively.b. Custom Annotations: Java also allows developers to create custom annotations for their specific requirements. Custom annotations are defined using the @interface keyword and can contain elements and values.c. Annotation Processors: Annotation processors are tools that read and process annotations during compilation. They are used for generating code, validating code, and performing various other tasks based on the presence of annotations.In conclusion, core Java is a fundamental programming language that forms the basis for building robust and scalable applications. Understanding the core Java concepts such as object-oriented programming, multithreading, collections, I/O, and annotations is essential for any Java developer. Mastering these concepts will enable developers to write efficient, maintainable, and high-quality code for a wide range of applications and systems. As Java continues to evolve with new features and enhancements, staying updated with the latest developments in the language is crucial for Java developers to stay competitive in the industry.。

CoreJava(第二章)

CoreJava(第二章)

第二章、JAVA编程基础一、JAVA的基本语法(1)JAVA代码的落脚点Java中所有程序代码都必须在一个类中,用class关键字定义类,class前面可以有一些修饰符号。

格式:[修饰符] class 类名{程序代码}例:public class MyTest{程序代码}注:当修饰符号为public关键字时,文件名必须与类名相同。

而且只能有一个类用public关键字修饰。

(2)JAVA严格区分大小写JAVA语言是严格区分大小写的。

例:定义一个类用“class 类名”,而不能写成“Class 类名”。

String name,Name;//其中name与Name是不同的变量。

(3)JAVA代码是一种自由格式的语言Java中所有程序代码分为结构定义语句和功能执行语句,一条语句可以写在若干行上,功能执行语句必须用分号(;)结束,不必要对齐或缩进一致.例:public class HelloWorld{ public static void main(String args[]){System.out.println(“Hello world”);}}和public class HelloWorld{public static void main(String args[]){System.out.println(“Hello world”);}}他们是一样的。

(4)JAVA程序的注释注释:不被程序编译的文字信息,增强源文件的可读性。

单行注释:// 注释内容多行注释:/* 注释内容 */文档注释:/** 注释内容 */文档注释的内容会被解释成程序的正式文档。

(5)JAVA中的标识符程序员对程序中的各个元素加以命名时使用的命名记号称为标识符包括:类名、变量名、常量名、方法名、…。

标识符是以字母,下划线(_),美元符($)开始的一个字符序列,后面可以跟字母,下划线,美元符,数字。

Java标识符大小写敏感(区分大小写),没有长度限制,可以为标识符取任意长度的名字,但不能是java中的关键字(保留字)。

Core Java经典教程 一

Core Java经典教程 一

Core Java 辅导资料第一章:一、Java 简介Java 语言是编译后再解释执行,Java 源码是通过编译生成一种特殊的.class 的中间字节码文件,然后再有JVM 进行解释执行,JVM (Java 虚拟机)是运行在操作系统中,用来屏蔽的系统间的差异。

Java 虚拟机处理编译后的字节码,并根据不同的系统来申请相应的资源,这样就可以保证程序的运行正常,在Java 虚拟机的基础之上,由解释器来解释执行字节码文件。

Java 虚拟机+解释器=JRE (Java RunTime Environment )Java 运行环境JRE+Java 系统类库=JDK (Java Deveple Kit )JAVA 开发工具包Java 简单特性:① 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 是不跨平台的。

)类库 工具JRE JDK二、使用Java是需要进行配置的环境变量JAVA_HOME, 指明JDK安装的位置;CLASSPATH,指明类文件的位置;PATH,指明命令的可执行文件的位置。

例:Unix/Linux中JAVA环境变量的配置在(.profile(Unix) /.bash_profile(Linux) /.bashrc(Linnx))这些文件中作以下配置Java的一些特点:①Java是一种纯面向对象的语言,在Java中所有的方法必须写在class(类)中,包括main 方法。

java核心知识点

java核心知识点

java核心知识点Java核心知识点Java是一种广泛应用于开发各种应用程序的编程语言,具有简单易学、跨平台、面向对象等特点。

作为一名Java程序员,掌握Java 的核心知识点是非常重要的。

下面将介绍一些Java的核心知识点。

1. 数据类型和变量Java提供了多种数据类型,包括基本数据类型和引用数据类型。

基本数据类型包括整型、浮点型、字符型和布尔型,而引用数据类型包括类、接口、数组等。

在Java中,我们可以使用变量来存储数据,并通过变量名来访问这些数据。

2. 运算符和表达式Java提供了丰富的运算符,包括算术运算符、关系运算符、逻辑运算符等。

运算符可以用于操作各种数据类型,进行加减乘除、比较大小、判断条件等操作。

表达式是由运算符和操作数组成的,通过表达式可以实现各种复杂的计算。

3. 控制流程控制流程是指程序在执行过程中的控制顺序。

Java提供了多种控制流程语句,包括条件语句、循环语句和跳转语句。

条件语句用于根据条件来选择执行不同的代码块,循环语句用于重复执行一段代码,而跳转语句用于改变程序的执行顺序。

4. 数组和集合数组是一种用于存储多个相同类型数据的数据结构,在Java中,数组是固定长度的。

集合是一种可以动态增加和删除元素的数据结构,Java提供了多种集合类,如ArrayList、LinkedList、HashSet等。

数组和集合在Java中非常常用,可以用于存储和操作大量的数据。

5. 类和对象Java是一种面向对象的编程语言,类是Java中最基本的组织单位。

类由属性和方法组成,属性用于描述对象的状态,方法用于定义对象的行为。

对象是类的一个实例,通过创建对象可以访问类的属性和方法。

类和对象是Java程序中最基本的概念,掌握类和对象的使用非常重要。

6. 继承和多态继承是面向对象编程中实现代码复用的一种机制,通过继承可以创建一个新的类,并从已有的类中继承属性和方法。

子类可以继承父类的属性和方法,并可以在此基础上进行扩展和修改。

core java 知识点

core java 知识点

core java 知识点核心Java知识点为了帮助读者更好地理解核心Java知识点,本文将逐步回答以下问题:1. 什么是Java?2. Java的历史背景和发展历程是什么?3. Java的特点和优势有哪些?4. Java的基本语法是什么?5. Java的数据类型有哪些?6. Java的循环结构和条件语句有哪些?7. Java中的面向对象编程概念是什么?8. Java中的异常处理机制是什么?9. Java中的输入和输出如何实现?10. Java中的多线程编程是什么?11. Java的集合框架是什么?12. Java的反射机制是什么?13. Java的网络编程是什么?14. Java的文件操作是什么?15. Java的数据库连接是什么?16. Java的图形用户界面编程是什么?17. Java的国际化编程是什么?18. Java中的注解是什么?19. Java的常见设计模式有哪些?20. Java中的单元测试和集成测试是什么?接下来,我们将逐个回答这些问题。

1. 什么是Java?Java是一种广泛使用的计算机编程语言,由Sun Microsystems(现为Oracle)在1995年首次推出。

Java是一种面向对象的、基于类的编程语言,其设计目标是让开发者能够使用一次编写多处运行的原则,编写的Java代码可以在多个平台上运行。

2. Java的历史背景和发展历程是什么?Java的发展历程可分为以下几个阶段:- 1991年,Sun Microsystems的James Gosling和他的团队开始研发Oak语言,该语言后来演变为Java语言。

- 1995年,Sun Microsystems正式发布了Java语言,引起了广泛关注和使用。

Java 1.0成为第一个正式的Java版本。

- 1996年,Java 1.1发布,带来了许多重要的改进和新特性。

- 1998年,Java 2发布,引入了Java虚拟机(JVM)和Java 2标准版(J2SE)的概念。

java核心基础知识

java核心基础知识

java核心基础知识Java核心基础知识1、先了解什么是Java的四个方面初学者先弄清这些Java的基本概念也是必不可少的,死记硬背肯定是不行的,重在理解,理解它们之间的区别与联系,分别有哪些应用。

想想这些代码中用到了哪些知识点。

不要一味地照着书本敲代码。

而不去理解。

1.Java编程语言,即语法。

2.Java文件格式,即各种文件夹、文件的后缀。

3.Java虚拟机(JVM),即处理_.class文件的解释器。

4.Java应用程序接口(Java API)。

2、掌握静态方法和属性静态方法和属性用于描述某一类对象群体的特征,而不是单个对象的特征。

Java中大量应用了静态方法和属性,这是一个通常的技巧。

但是这种技巧在很多语言中不被频繁地使用。

理解静态方法和属性对于理解类与对象的关系是十分有帮助的,在大量的Java规范中,静态方法和属性被频繁使用。

因此学习者应该理解静态方法和属性。

Java在方法和属性的调用上是一致的,区别只表现在声明的时候,这和c++是不同的。

3、初学者还需明白JAVA的三个技术平台的关系Java分为三个体系,分别为Java SE(J2SE,Java2 Platform StandardEdition,标准版)。

JavaEE(J2EE,Java 2 Platform, Enterprise Edition,企业版)。

JavaME(J2ME,Java 2 Platform Micro Edition,微型版)。

要知道java是分两部分的:一个是编译,一个是运行。

javac:负责的是编译的部分,当执行javac时,会启动java的编译器程序。

对指定扩展名的.java文件进行编译。

生成了jvm可以识别的字节码文件。

也就是class文件,也就是java的运行程序。

java:负责运行的部分.会启动jvm.加载运行时所需的类库,并对class文件进行执行.一个文件要被执行,必须要有一个执行的起始点,这个起始点就是main函数。

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

Java知识总结--CoreJava在学习编程的过程中,我觉得不止要获得课本的知识,更多的是通过学习技术知识提高解决问题的能力,这样我们才能走在最前方,更多Java专业知识,广州疯狂java培训为你讲解;1 简述下java基本数据类型及所占位数,java基本数据类型:4类8种整数类型:byte(1byte),short(2byte),int(4byte),long(8byte)浮点类型:float(4byte),double(8byte)字符类型:char(2byte)逻辑类型:boolean(false/true 1byte)2 说出5个启动时异常RunTimeException------NullPointerException------ArrayIndexOutOfBoundsException------ClassCastException------NumberFormatException3 HashMap 和HashTable的区别:1HashMap 允许空键值对,HashTable不允许2HashMap不是线程安全的,HashTable是3HashMap直接实现Map接口,HashTable继承Dictionary类4.ArrayList,Vector,LinkedList存储性能和区别它们都实现了List接口ArrayList和Vector都是基于数组实现的LinkedList基于双向循环链表(查找效率低,添加删除容易)ArrayList不是线程安全的而Vector是线程安全的,所有速度上ArrayList高于Vector5.Collection和Collections的区别Collection是集合类的上级接口,继承与他的接口主要有Set和ListCollections是针对集合类的一个帮助类,他提供一系列静态方法实现对各种集合的搜索、排序、线程安全等操作。

6 List、Map、Set三个接口,存取元素时,各有什么特点?List以特定次序来持有元素,可有重复元素。

Set 无法持有重复元素,内部排序Map保存key-value值,value可多值。

7 final,finally,finalize的区别Final用于声明属性,方法和类,分别表示属性不可变,方法不可覆盖,类不可继承Finally 是异常处理语句结构的一部分,表示总是执行Finalize 是Object类的一个方法,在垃圾收集时的其他资源回收,例如关闭文件等。

8 Overload和Override的区别。

Overload的方法是否可以改变返回值的类型?方法的重写Override和重载Overload是Java多态的不同表现。

重写Overriding是父类与子类之间多态的一种表现,方法名,参数列表返回值类型都得与父类的方法一直。

重载Overloading是一种类中多态的一种表现。

重载的方法是可以改变返回值类型的。

9用一句话总结一下冒泡排序依次比较相邻的两个数,将小数放在前面,大数放在后面。

10 实现线程安全的两种方式1)synchronized方法:通过在方法声明加入synchronized关键字来声明synchronized方法2)Synchronized块:通过synchronized关键字来声明synchronized快11 说一下"=="和equal()方法在字符串变量操作中的不同?"=="比较的是两个字符串对象的地址,equal() 是比较两个字符串的具体值12 sleep和wait方法有什么区别Sleep是线程(Thread)的方法,导致此线程暂停执行指定时间,把执行机会给其他线程,但是监控状态依然保持,到时会自动恢复。

调用sleep不会释放对象锁。

Wait是Object类的方法,对此对象调用wait方法导致本线程放弃对象锁,进入等待此对象的等待锁定池,只有针对对象发出notify方法(或notifyAll)后本线程才进入对象锁定池准备获得对象进入运行状态。

13 &和&&的区别&位运算符:非短路运算符,它会把所有条件执行完毕之后,才会返回结果&&逻辑运算(and):短路运算符,遇到不符合条件,立即终止程序的执行14 error和exception的区别Error:表示恢复是不可能的一种严重的问题,比如:内存溢出,不指望程序处理Exception 程序运行时的异常,如果程序设计合理不会出现的情况15请说出你锁知道的线程同步的方法Wait():使一个线程处于等待状态,并且释放所有持有的对象的lock;Sleep():使一个正在运行的线程处于睡眠状态,是一个静态方法,调用此方法要捕捉InterruptedException异常;Notify():唤醒一个处于等待状态的线程,注意的是在调用此方法的时候,并不能确切的唤醒某一个等待状态的线程,而是由JVM确定唤醒哪个线程,而且不是按优先级。

notityAll():唤醒所有处于等待状态的线程,注意不是给所有唤醒线程一个对象的锁,而是让它们竞争。

16.网络编程中涉及并发服务器,使用多进程和多线程,请问有什么区别?1)进程:子进程是父进程的复制品子进程获得父进程数据空间堆和栈的复制品2)线程:相对于进程而言,线程是一个更加接近与执行体的概念,它可以与同进程的其他进程共享数据,但拥有自己的栈空间,拥有独立的执行序列两者都可以提高程序的并度,提高程序运行效率和响应时间。

线程和进程在使用上各有优缺点:线程执行开销小,但不利于资源管理和保护;而进程正相反同时,线程适合于在SMP机器上运行,而进程则可以跨机器迁移。

17 什么是反射?在运行过程中:1对于任意一个类,可以知道这个类的属性和方法。

2对于任意一个对象,可以调用这个对象的任意方法。

对于这种动态获取的信息,以及动态调用对象方法的功能成为反射。

Java反射机制提供的功能1运行时判断任意对象的所属类2运行时构造任意类的对象3运行时判断和调用对象的成员变量和方法4生成动态代理18 线程的基本概念、线程的本状态及状态之间的关系新建(Born)新建的线程处于新建状态就绪(Ready)在创建线程后,它将处于就绪状态,等待start()方法被调用运行(Running)线程在开始执行时进入运行状态睡眠(Sleeping)线程的执行可通过sleep()方法来暂时中止。

在睡眠后,线程将进入就绪状态等待(Waiting):如果调用了wait()方法,线程将处于等待状态。

用于在两个或多个线程并发运行时。

挂起(Suspended)在临时停止或中断线程的执行时,线程就处于挂起状态。

阻塞(Blocked)在线程等待一个事件时(例如输入/输出操作),就称处于阻塞状态死亡(Dead)在run()方法已经执行或其stop()方法被调用之后,线程就处于死亡状态19 描述下JVM加载class文件的原理机制JVM中类的装载是由ClassLoader和它的子类来实现的java ClassLoader是一个重要的java运行时系统组件。

它负责在运行时查找和装入类文件的类。

20什么是触发器和存储过程触发器是存储在数据库中的块,这个块一旦被构造后,就可以多次执行,当触发它的事件发生时调用该触发器。

触发事件是指对表中数据的操作,如插入、删除和修改。

存储过程是将常用的或很复杂的工作,预先用SQL语句写好并用一个指定的名称存储起来,那么以后要叫数据库提供与已定义好的存储过程的功能相同的服务时,只需调用execute,即可自动完成命令。

我的理解就是一堆sql的集合,可以建立非常复杂的查询,编译运行,所以运行一次后,以后再运行速度比单独执行SQL快很多21什么是回调函数某个程序S(Student.main)调用服务程序A(Arrays)中的某个方法(sort),服务程序A的sort方法在某个时候反过来调用S的某个方法(compareTo),这种情况下,compare叫做S的回调方法。

例如:public class Student implements Compareble{Private int id;Private String name;Private int age;Private int score;//构造器//getter/setter方法//回调方法Public int compareTo(Object obj){ReturnThis.id-((Student)obj).id;}}Student s1 = new Student(1,"a",18,89);Student s2 = new Student(2,"a",18,89);Student s3 = new Student(3,"a",18,89);Student [] arrs = {s1,s2,s3};Arrays.sort(arrs);22 遍历文件夹下所有.java的文件?Public void listFiles(String path){File dir = new File(path);Files [] files = dir.listFiles(new FileFilter(){Public boolean accept(File f){Return f.getName().endWith(".java");}});For(File file:files){System.out.print(file.getName());}}疯狂Java培训(疯狂软件学院咨询QQ:707,552,864 )专注软件开发培训,提升学员就业能力,重点提升实践动手能力。

技术知识沉淀深厚的老师,让你感受Java的魅力,激发你对于编程的热爱,让你在半年的时间内掌握8-10万的代码量,掌握Java核心技术,成为真正的技术高手;通过大量全真企业项目疯狂训练,迅速积累项目经验。

让你成为技能型的现代化高端人才,迅速获得高薪就业!时间不等人,赶紧联系我们吧!疯狂java培训中心地址:广州天河区车陂沣宏大厦3011。

相关文档
最新文档