java基础
java起源于SUN公司的一个GREEN的项目,其原先目的是:为家用消费电子产品发送一个信息的分布式代码系统,通过发送信息控制电视机、冰箱等
简单的、面向对象的、分布式的、安全的、稳定的、与平台无关的、可解释的、多线的、动态的语言。
JAVA:一种编程语言
一种开发环境
一种应用环境
一种部署环境
三种版本:
JME:是面向内存有限的移动终端. 为消费性产品设计的;
JSE: 是SUN公司针对桌面开发和低端商务计算方案开发的版本。为笔记本电脑、PC机设计的;
JEE: 是一种利用JAVA 2平台来简化企业解决方案的开发、部署和管理相关的复杂问题的体系结构。 为企业级的、服务器端的高端应用而设计的;
java虚拟机
垃圾回收
代码安全性
(1)通过 ClassLoader 寻找和装载 class 文件
(2)解释字节码成为指令并执行,提供 class 文件的运行环境
(3)进行运行期间垃圾回收
(4)提供与硬件交互的平台
(1)编译时的错误检验
(2)类装载检查,把本机上的类和网络资源类相分离,在调入类的时候进行检查,因而可以限制任何“特洛伊木马“的应用
(3)字节码校验
(4)沙箱机制,限定访问权限
Java 编程语言解除了程序员释放内存的责任。它可提供一种系统级线程以跟踪每一次内存的分配情况。在 Java 虚拟机的空闲周期,垃圾收集线程检查并释放那些可被释放的内存。垃圾收集在 Java 技术程序的生命周期中自动进行,它解除了释放内存的要求,这样能够有效避免内存漏洞和内存泄露(内存泄露就是程序运行期间,所占用的内存一直往上涨, 很容易造成系统资源耗尽而降低性能或崩溃 。
垃圾回收有以下特点:
(1)垃圾回收是一个自动的系统行为,程序员不能控制垃圾回收的功能和行为。
(2)有一些跟垃圾回收相关的方法,比如:System.gc( ) ,调用这些方法,仅仅是在通知垃圾回收程序,至于垃圾回收程序运不运行,什么时候运行,都是无法控制的。
(3)程序员可以通过设置对象为 null,来标示某个对象不再被需要了, 这只是表示这个对象可以被回收了,并不是马上被回收。
(1)加载代码 通过类装载器装载CLASS文件
(2)校验代码 由字节码校验
(3)执行代码 由解释器将字节码转换成机器码
首先下载安装JDK 然后配置环境
(1)配置PATH,
(2)配置CLASSPATH
(3)配置JAVA_HOME
简述classpath,path,JAVA_HOME的意义和配置方法
path 操作系统运行环境的路径
classpath JAVA运行应用程序时所需要的类包的路径
JAVA_HOME 供需要运行JAVA的程序使用
请描述:一个完整的Java文件的代码分几个部分,每部分都起什么作用,大致的写法
package 当前类所在位置
import 当前类运行时所需要的包或类
public class 类名 {
属性定义;
方法定义:
构造方法定义;
public static void main(String args []) 例外{ 程序入口
语句;
}
}
//注释
(1) // 单行注解
(2) /* */ 块注释
(3) /* *
* 文档注释
*/
什么是Java代码的语句,什么是Java代码的块,举例说明
语句 是一行以分号终止的代码,例:int a;
块 是以{ }为边界的一些语句的集合 例:public void tt( ){}
什么是标示符? 标识符:是赋予变量、类、方法的名称。
标示符定义的规则?
首字母只能以字母、下划线、$开头,其后可以跟字母’下划线、$和数字配置CLASSPATH
首字母小写中间用大写字母隔开
标识符具有一定的含义
什么是关键字? 关键字就是编程语言与机器语言的编码约定
true、false、null、sizeof、goto、const那些是Java关键字 true 、false 、null 为JAVA的关键字
Java的基本数据类型有几种?分别是? short int long boolean float double char byte
请写出每种基本类型的默认值?取值范围?分别给出一个定义的例子
默认值 取值范围 示例
字节型 : 0 -2^7—-2^7-1 byte b=10;
字符型 : ‘ ′ 0—-2^16-1 char c=’c’ ;
short : 0 -2^15—-2^15-1 short s=10;
int : 0 -2^31—-2^31-1 int i=10;
long : 0 -2^63—-2^63-1 long o=10L;
float : 0.0f -2^31—-2^31-1 float f=10.0F
double : 0.0d -2^63—-2^63-1 double d=10.0;
boolean: false true alse boolean flag=true;
在基本类型中,如果不明确指定,整数型的默认是什么类型?带小数的默认是什么类型?
整数类型 默认为 int
带小数的默认为 double
float f = 1.2f
long l = 1.2L
变量是用来引用一块内存区域或一个值,用标识符来表示,可以通过操作变量来操作变量所对应的内存区域或值块的值。
变量的定义规则?
以字母、$、下划线开头,其后可以跟字母、下划线、$和数字;
首字母小写,中间单词用大写字母隔开;
名称具有一定含义;
请写出Java编码约定中对下列部分的要求:类、属性、方法、包、文件名、变量、常量、控制结构、语句行、注释
类: 一个类文件中类名要和文件名相同,类名一定要以大写字母开头,单词之间用大写字母分隔
属性: 属性名首字母小写,中间用大写字母隔开。
方法: 方法名首字母小写,中间用大写字母隔开。
包: 引用包必须写在类文件的开头,有且只能有一个包,全部用小写字母。
控制结构:当语句是控制结构的一部分时,即使是单个语句,也应使用大括号将语句封闭。
语句行:每行只写一个语句,并使用四个缩进的空格,使代码更易读,注意用分号结束。
注释: 用注释来说明那些不明显代码的段落。
常量: 常量名一般用大写字母,单词之间用下划线分隔,一旦赋值不允许修改。
按照一定格式生成程序的文档的工具。
什么是引用类型? 用户定义类型, 它可引用类和数组。
除去基本数据类型的其他类型都是引用数据类型。
按值传递:就是将该值的副本传过去(基本数据类型+String类型的传递,就是按值传递)
按引用传递:就是将值的内存地址传过去(除基本数据类型+String以外类型的传递,就是引用传递)
使用new 关键字来创建一个新的对象;
通过对象的实例用”. “(点)来调用对象中的属性和方法;
静态的方法和属性,也可以直接用类名”. “(点)来调用;
简述new关键字所做的工作 new 创建一个对象,并为对象分配一块内存。
“=” 赋值,
“= =”当比较基本数据类型的时候,判断前后两个值是否相等;
当比较引用数据类型的时候,判断= =前后两个值的内存地址是否相等;
区别:
= :为赋值表达式
= = :为逻辑表达式
什么是实例变量?什么是局部变量?什么是类变量?什么是final变量?
实例变量: 类中定义的变量,即类成员变量,如果没有初始化,会有默认值;
局部变量: 在方法中定义的变量,必须初始化;
类变量: 用static修饰的属性;
final变量: 用final 修饰的变量,
实例变量: 不需要static关键字来声明,需要类的实例(对象)调用(用”. “);
类变量: 用static修饰,可以用类名调用,也可以用类的实例调用;
局部变量: 在方法内任意定义变量即为局部变量;
final变量: 一旦赋值,不可以再修改的变量;
final属性只允许赋值一次,且只能通过构造方法赋值,定义后也就是一个常量;
final修饰的变量,只允许赋值一次
a++ : 先使用,后加1
++a : 先加1,后使用
? : 三目运算符:
表达式1?表达式2: 表达式3
如果表达式1为true,执行表达式2,否则执行表达式3
&: 位运算:按位与 |
&&: 逻辑运算:逻辑与
10>>4 :算术或符号右移位运算符
<< :算术或符号左移位运算符
>>> :逻辑或无符号右移位运算符
请描述什么是强制类型转换?什么是自动类型转换?什么是向上造型?并分别举例说明
强制类型转换:在一个类型前面加( ),来强制转换
long l = 9L;
int i = (int)l;
自动类型转换:
int i = 5;
String str = “”+i;
向上造型:把范围小的造型为范围大的类型:
int i = 2;
long l = i;
if(布尔表达式){
语句
}else{
语句
}
请写出完整的switch语句的结构
switch(字符){
case 字符: 语句
break;
case 字符: 语句
break;
default:语句
}
for(初始语句;条件语句;步长){
}
while(boolean语句){
}
do{
}while(boolean语句);
请描述break 和 continue的功能和用法
break:终止(跳出)最近的循环
continue:跳出本次循环,执行下一次循环
定义一个一维的int数组,先创建它,并初始化它,给它赋值,然后输出其中的一个值
public class Arr{
public static void main(String args[]){
int a[] = new int[5];
a={1,2,3,4,5};//错误 , 只能在初始化时这样做
a[0]=1;
a[1]=2;
System.out.println(a[0]);
}
}
定义一个一维的A类型数组,直接定义并赋值,然后输出其中的一个值
public class A{
public static int i;
public static void main(String args[]){
A aa = new A( );
A bb = new A( );
A a[] = {aa,bb};
a[0].i=2;
System.out.println(a[0]);
}
}
public class A{
public static int i;
public static void main(String args[]){
A a[ ][ ] = new A[5][5];
a[0][0].i=2;
System.out.println(a[0][0]);
}
}
举例说明数组拷贝方法的使用:arraycopy方法
public class A{
public static void main(String args[]){
int a[] = new int[5];
int b[] = new int[5];
System.arraycopy(a[5],0,b[5],0,a.length)
System.out.println(b[0][0]);
}
}
构造方法:每个类至少有一个构造方法,类初始化时调用的方法
1.方法名和类名相同
2.无返回值类型
格式:访问权限 类名(参数列表) {};
1.自己定义构造后,就没有默认的构造方法
2.无构造方法时,默认为空参的构造方法(无参数,方法体为空) 析构方法:finalize
类销毁时,自动调用方法
当对象在内存中被删除时,自动调用该方法
在此方法中可以写回收对象内部的动态空间的代码
public 公开的,任何一个类都有可以访问
protected 同包同类,只可被它的子类访问
default 只能被同一个包中类访问
private 私有的,只能在本类中被访问
分别说明:在类上、在属性上、在方法上能使用哪些访问修饰符
在类上:public default final
在方法上: 访问权限:public protected private default
方法修饰符:static
final
返回类型:void
在属性上:public protected private default
static
final
包:对所定义的多个JAVA类进行分组,将多个功能相关的类定义到一个包(文件)中。
功能:1.易于查找和使用适当的类
2.包不止包含类和接口,还可以包含其它包,形成层次的包空间
3.有助于避免命名冲突
java.awt: 包含构成抽象窗口工具集的多个类,用来构建和管理应用程序的图形用户界面
java.lang: 提供java编成语言的程序设计的基础类
java.io: 包含提供多种输出输入功能的类,
java.net: 包含执行与网络有关的类,如URL,SCOKET,SEVERSOCKET,
java.applet: 包含java小应用程序的类
java.util: 包含一些实用性的类
什么是包装类?Java中都有哪些包装类 在JDK中针对各种基本类型分别定义相应的引用类型 ————–称为封装类
Boolean Byte Short Integer Long Float Double Character
OOP(面向对象)语言的三大特征是? 封装性,继承性,多态性
封装:隐藏类的实现细节、迫使用户去使用一个接口去访问数据、使代码更好维护
继承:子类可以直接继承使用父类的方法,程序员只需要做的是定义额外特征或规定将适用的变化
多态性:同一个行为具有多个不同表现形式或形态的能力
public class A extends B{
}
单继承性
构造方法不能继承
super引用父类,调用父类的属性,方法
当子类中出现与父类的方法名,返回类型,参数列表相同的方法时要覆盖此方法
this :
能访问除构造方法以外所有的属性、方法,通过this. 来调用方法和属性
不可以在静态方法中使用,
在调用其它构造方法时,必须放在该构造方法的第一行
在构造方法中使用this(参数列表),相当于调用本类的其它构造方法,它必须作为构造方法的第一句
super :访问父类
super. 点取父类中被子类隐藏的方法和属性,
通过 super(参数列表) 来调用父类的属性和方法,在调用父类的构造方法时必须放在子类构造方法里的第一行;
如何确定在多态的调用中,究竟是调用的那个方法? new的是哪一个类就是调用的哪个类的方法。
权限修饰符 修饰符 返回类型 方法名(参数) 例外{
方法体;
}
什么是重载? 在一个类中出现方法名相同,但参数列表不同时,这种情况就是重载。
简述重载的规则
方法名称必须相同;
参数列表必须不同(个数不同,或类型不同,或参数排列顺序不同);
与返回类型无关;
什么是方法的覆盖?什么情况下出现?
方法覆盖:
子类可以修改从父类继承过来的行为,也就是说子类可以创建一个与父类方法有不同功能的方法,但具有相同的:名称、返回类型名和参数列表。
在父子类的情况下出现时。
方法覆盖的规则?
方法名要和父类中被覆盖的方法名相同,返回类型相同,参数列表相同。
访问权限要大于等于被覆盖方法的权限。
例外列表要小于等于被覆盖方法的例外列表。
static修饰符的功能是?可以用在什么地方?怎么访问?
static 修饰符功能:
共用一块内存区域,也就是用static修饰的变量或成员方法对所有类的实例都是相同的
静态成员方法和静态变量的优点在于他们能在没有创建类的任何一个实例的情况下被引用。
可以用在方法或属性上
访问方式:
static的基本规则
类中的静态方法只可以调用静态的属性和方法,不允许调用非静态的属性和方法。
静态变量为类变量,可以用类名直接调用静态的属性和方法。
静态方法中不允许出现this和super
构造方法不允许声明static
非静态变量为实例变量,通过实例调用
静态方法不能被非静态方法覆盖
功能:final标记所有通用的功能,不能随意更改
可以用在类、属性和方法上
final的基本规则
final修饰的类不能被继承
final修饰的成员变量只允许赋值一次,且只能通过构造方法里赋值。
final修饰的局部变量即为常量,只能赋值一次。
final修饰的方法不允许被子类覆盖。
用abstract修饰的方法,只有方法的声明,而没有方法的实现,就叫抽象方法。
用abstract修饰的类,就叫抽象类。
抽象类的规则
抽象类内部可以没有抽象方法
必须用abstract修饰
不能够直接使用抽象类,必须通过子类继承并且实现
抽象方法不允许被private修饰
什么情况下使用抽象类
当一个类的一个或多个方法是抽象方法时;
当类是一个抽象类的子类,并且不能为任何抽象方法提供任何实现细节或方法体时;
当一个类实现一个接口,并且不能为任何抽象方法提供实现细节或方法体时;
功能:判断对象是否相等
区别:
equals方法比较的是对象的值
= =:比较的是对象值的内存地址,对基本数据类型来说= = 比较的是数值
返回一个String类型
public String toString(){
return “”;
}
String的方法的功能和基本使用方法,请描述5个以上
substring(参数1,参数2); 功能:取字符串中参数1到参数2的的所有字符; “String”.subString(0,1);
replace(参数1,参数2); 功能:用参数1中的值替换字符串中所有参数2的值 “String”.replace(ing,tt);
equals( ); 功能:判断两个字符串是否相等 “String”.equals(“tt”);
trim( ); 功能:去掉字符串两边的空格 “String”.trim();
indexof( ); 功能:查找字符串中参数所在位置,并返回字符串第一个出该参数的下标
“String”.indexOf(“ing”);
split( ); 功能:根据参数分割该字符串 “String”.split(“-”);
为什么使用StringBuffer类?有什么功能和优点?
–只创建一个对象
–StringBuffer 对象的内容是可以被修改的
–除了字符的长度之外,还有容量的概念
–通过动态改变容量的大小,加速字符管理
StringBuffer sb = new StringBuffer();
sb.append(“aaa”);
Properties props = System.getProperties ();
Enumeration prop_names = props.propertyNames();
while (prop_names.hasMoreElements()) {
String prop_name = (String) prop_names.nextElement();
String property = props.getProperty(prop_name);
System.out .println(“Property ‘” + prop_name + “‘ is ‘”+ property + “‘”);
}
写:
System.setProperties(props);
用法:
public class Test {
public static void main(String args[]) {
try {
String name = “test.properties”;
InputStream in = new BufferedInputStream(new FileInputStream(name));
Properties p = new Properties();
p.load(in);
System.out .println(“a的值==” + p.getProperty(“a”));
} catch (Exception err) {
err.printStackTrace();
}
}
}
接口是抽象方法和常量值的定义的集合。从本质上讲,接口是一种特殊的抽象类,这种抽象类中只包含常量和方法的定义,而没有变量和方法的实现。
public interface Tt {
public void outPut( );
public int tt( );
}
封装、隔离
功能,实现的分离
多态
便于后期维护
接口是可插入性的保证。
封装 隔离
接口及相关机制的最基本作用在于:通过接口可以实现不相关类的相同行为,
而不需考虑这些类之间的层次关系。
根据接口可以了解对象的交互界面,而不需了解对象所属的类。
面向对象程序设计讲究”提高内聚,降低耦合”。
public class MyCast implements Tt{
public void outPut( ){}
public int tt( ){
return 0;
}
}
public interface Animal(){
public void tt( );
}
public class Dog implements Animal{
public void tt ( ){}
}
Animal ani = new Dog();
如何选择接口和抽象类?为什么? 优先选用接口,尽量少用抽象类
在下列情况下选择抽象类:需要定义子类的行为,又要为子类提供共性的功能。
什么是异常,异常的分类? 程序中导致程序中断的一些情况叫做异常,一般程序员可以处理。 异常分为运行时异常和非运行时异常(一般异常) 运行时异常是指因设计或实现方式不当导致的问题。也可以说,是程序员的原因导致的,本来可以避免发生的情况。例如:BufferOverflowException, ClassCastException,IndexOutOfBoundsException,ArithmeticException。 出现这些异常的代码不需要try块包围。 非运行时异常是指除运行时异常以外所有的异常,出现这些异常的代码必须用try块包围。例如:FileNotFoundException,EOFException,
简述处理异常的两种方式? 抛出(throws)和catch语句处理
try块内部一般写一些编程人员认为可能会出现异常的代码,使程序运行时不会因为出现异常而中断。
功能:可以截获所声明的异常,并在语句块内对其进行处理
规则:catch(Exeption e){
e.printStackTrace( );
}
finally块一般写一些不论是否发生异常都必须执行一次的代码
例如关闭与数据库的连接等
throw 指编程人员主动抛出一个异常
throw new NullPointerExeption( );
throws指程序遇到异常情况自动的被动抛出一个异常
public void test( ) throws Exeption{}
错误(Error): JVM 系统内部错误、资源耗尽等严重情况,程序员不可控制
例外(Exception):其它因编程错误或偶然的外在因素导致的一般性问题,程序可以控制
java程序中预先定义好的异常叫做预定义异常
写一个类继承Exception
用户自定义异常通常属Exception范畴,依据惯例,应以Exception结尾,应该由人工创建并抛出。
用来证明和测试程序的假设。
一种是assert<<布尔表达式>>;另一种是assert<<布尔表达式>>:<<细节描述>>。
assert a= =10 : “这里a等于10″;
集合框架
什么是集合?什么是元素?
IO
流是要传输的数据在源和目的地之间运行的轨迹。
代码示例:使用URL流,读取网页代码 import java.io.*; import java.net.URL; import java.net.URLConnection; public class ReadURL { public static void main(String[] args) throws Exception { URL url = new URL(“http://bbs.tarena.com.cn”); // 建立封装统一资源定位符的类 URLConnection uc = url.openConnection(); //打开连接 InputStreamReader isr = new InputStreamReader(uc.getInputStream()); BufferedReader br = new BufferedReader(isr); // 传输数据 while(true){ String temp = br.readLine(); if(temp==null){ break; } System.out.println(temp); } br.close(); } }
是一种字符的编码方式,占16位字节,Java 技术使用 Unicode 来表示字符串和字符。
代码示例:如何使用Reader和Writer来进行输入输出
//Writer写入操作
FileOutputStream fos=new FileOutputStream(“a.txt”);
OutputStreamWriter osw=new OutputStreamWriter(fos);
BufferedWriter bw=new BufferedWriter(osw);
bw.write(“欢迎来到java快车”);
bw.close();
//Reader读取操作
FileInputStream fis=new FileInputStream(“a.txt”);
InputStreamReader isr=new InputStreamReader(fis);
BufferedReader br=new BufferedReader(isr);
String str=br.readLine();
System.out.println(str);
将一个对象存放在某种类型的永久存储器上(比如硬盘,光盘,软盘等),称为保持。
标识一个类可以被持久化,叫序列化,也叫串行化或持久化。表示这个类中的数据可以按流式输出。
实现可序列化的方法:实现java.io.Serializable接口。
//读
try {
String str = “123″;
FileOutputStream f = new FileOutputStream(“test.txt”);
ObjectOutputStream s = new ObjectOutputStream(f);
s.writeObject(str);
f.close( );
}catch(Exception e) {
e.printStackTrace( );
}
//写
try {
FileInputStream f = new FileInputStream(“test.txt”);
ObjectInputStream s = new ObjectInputStream(f);
str =(String)s.readObject( );
f.close( );
}catch(Exception e){
e.printStackTrace( );
}
处理文件和获取文件信息;文件或文件夹的管理。
概括一句话就是:除了读写文件内容其他的都可以做。
RW表示文件时可读写的
读:
try{
RandomAccessFile f = new RandomAccessFile(“test.txt”, “rw”);
long len = 0L;
long allLen = f.length();
int i = 0;
while (len < allLen) {
String s = f.readLine();
if (i > 0) {
col.add(s);
}
i++;
//游标
len = f.getFilePointer();
}
}catch(Exception err){
err.printStackTrace();
}
写:
try{
RandomAccessFile f = new RandomAccessFile(“test.txt”, “rw”);
StringBuffer buffer = new StringBuffer(“”);
Iterator it = col.iterator();
while (it.hasNext()) {
buffer.append(it.next() + “”);
}
f.writeUTF(buffer.toString());
}catch(Exception err){
err.printStackTrace();
}
try{
DataInputStream in =
new DataInputStream(
new BufferedInputStream(
new FileInputStream(“Test.java”)
)
);
String currentLine=null;
while ((currentLine = in.readLine()) != null){
System.out.println(currentLine);
}
}catch (IOException e){
System.err.println(“Error: ” + e);
}
可以包含其他对象的简单对象就叫集合
集合框架中所包含的对象就叫做元素
Collection—-Set和List
Set—-HashSet和SortedSet
List—-ArrayList和LinkedList
Map—-HashMap、SortedMap和TreeMap
String oldValue = “abcd”;
String newValue = “1234″;
//增加
col.add(oldValue);
Iterator it = col.iterator();
while(it.hasNext()){
//取值
String str = (String)it.next();
if(str.equals(oldValue)){
//删除
col.remove(oldValue);
//修改
col.add(newValue);
}
}
代码示例:List接口的使用,包括如何定义、初始化、赋值、取值、修改值、删值
List col = new ArrayList();
String oldValue = “abcd”;
String newValue = “1234″;
col.add(oldValue);
Iterator it = col.iterator();
while(it.hasNext()){
String str = (String)it.next();
if(str.equals(oldValue)){
col.remove(oldValue);
col.add(newValue);
}
}
代码示例:Set接口的使用,包括如何定义、初始化、赋值、取值、修改值、删值
Set col = new HashSet();
String oldValue = “abcd”;
String newValue = “1234″;
col.add(oldValue);
Iterator it = col.iterator();
while(it.hasNext( )){
String str = (String)it.next();
if(str.equals(oldValue)){
col.remove(oldValue);
col.add(newValue);
}
}
代码示例:Map接口的使用,包括如何定义、初始化、赋值、取值、修改值、删
Map map = new HashMap();
String oldValue = “abcd”;
String newValue = “1234″;
//增加
map.put(“1″,oldValue);
Set set = map.keySet( );
Iterator it = set.iterator( );
while(it.hasNext( )){
String key = (String)it.next( );
//取值
String value = map.get(key);
}
//修改
map.put(“1″,newValue);
//删除
map.remove(“1″);
}
List接口中的对象按一定顺序排列,允许重复
Set接口中的对象没有顺序,但是不允许重复
Map接口中的对象是key、value的映射关系,key不允许重复
实现comparable接口
多线程
轻量级的进程
处理机
代码
数据
使UI响应更快
利用多处理器系统
简化建模
代码示例:Java中实现多线程的两种方式,包括如何定义多线程,如何使用多线程
实现Runnable接口
class Thread1 implements Runnable{
public void run( ){
//run里一般写一个while(true)循环
System.out.println(“Runnable“);
}
}
public class Test{
public static void main(String[] a){
Thread1 r = new Thread1();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
t1.start();
t2.start();
}
}
继承Thread
class Thread2 extends Thread{
public void run(){
System.out.println(“extends“);
}
}
public class Test{
public static void main(String[] a){
Thread t = new Thread2();
t.start();
}
}
调度用wait和notify,
—-
sleep()
判断哪个线程先执行的级别
sleep是让线程休眠一段时间
wait是让线程挂起
隐藏在后台持续运行的线程
指多个线程共享的资源
用来保证在任一时刻只能有一个线程来访问临界资源的那个标记
在Java中使用
用在对象前面限制一段代码的执行
用在方法声明中,表示整个方法为同步方法。
如果程序中有多个线程竞争多个资源,就可能会产生死锁。当一个线程等待由另一个线程持有的锁,而后者正在等待已被第一个线程持有的锁时,就会发生死锁。
要避免死锁,应该确保在获取多个锁时,在所有的线程中都以相同的顺序获取锁。尽量少用临界资源。
简述wait和notify,notifyAll的使用
被锁定的对象可以调用wait( )方法,这将导致当前线程被阻塞并放弃该对象的互斥锁,即解除了wait( )方法的当前对象的锁定状态,其他的线程就有机会访问该对象。
notify使等待队列上的一个线程离开阻塞状态
notifyAll使等待队列上的所有线程离开阻塞状态
Socket编程 什么是url?基本的格式是? 统一资源定位器 Http://www.163.com:port 简述IP,Port,TCP的基本功能 IP代表网络位置 Port代表端口号 TCP可保证不同厂家生产的计算机能在共同网络环境下运行,解决异构网通信问题,是目前网络通信的基本协议 简述Java网络模型的基本功能 描述服务端和客户端的连接过程 简述Java网络编程究竟做些什么?如何做? 1.建立连接 2.准备输出的数据,流式输出 3.流式输入,编程业务需要的格式 4.关闭连接 服务器分配一个端口号。如果客户请求一个连接,服务器使用accept( )方法打开socket连接。 客户在host的port端口建立连接。 服务器和客户使用InputStream和OutputStream进行通信。 代码示例:基于Socket编程 try { ServerSocket s = new ServerSocket(8888); while (true) { Socket s1 = s.accept(); OutputStream os = s1.getOutputStream(); DataOutputStream dos = new DataOutputStream(os); dos.writeUTF(“Hello,” +s1.getInetAddress() + “port#” + s1.getPort() + “\nbye!”); dos.close(); s1.close(); } }catch (IOException e) { System.out.println(“程序运行出错:” + e); } TCP和UDP区别 TCP(传输控制协议)和UDP(用户数据报协议)是传输层协议 TCP是面向连接的可靠数据传输协议,能保证传输内容的完整和准确;数据传输的辅助开销大,效率低 UDP: 是无连接的,不可靠地传输协议,不能保证传输内容的完整和准确,对信息的适时要求比较高 设计模式 什么是设计模式? 就是经过实践验证的用来解决特定环境下特定问题的解决方案。 设计模式用来干什么? 寻找合适的对象 决定对象的粒度 指定对象的接口 描述对象的实现 运用复用机制 重复使用经过实践验证的正确的,用来解决某一类问题的解决方案来达到减少工作量、提高正确率等目的 什么是对象粒度 对象中方法的大小就是粒度 基本的Java编程设计应遵循的规则? 面向接口编程,优先使用对象组合 设计模式的应用范围 所能解决的特定的一类问题中 简述什么是单例模式,以及解决的问题,应用的环境,解决的方案,应用时应注意什么? 解决的问题:在任何时间内只有一个类实例存在的模式。 应用环境:需要有一个从中进行全局访问和维护某种类型数据的区域的环境下使用单例模式。 解决方案:保证一个类只有一个类实例存在。 本质:控制实例的数量。 注意:要合理的使用单例,避免单例成为瓶颈。 代码示例:单例模式的两种实现方法,并说明优缺点 public class Test{ private static Test test = new Test(); public Test(){ } public static Test getInstance(){ return test; } } public class Test{ private static Test test = null; private Test(){ } public static Test getInstance(){ if(test==null){ test = new Test(); } return test; } } 第一种方式:装载类的时候就创建类的实例,用空间换时间。 第二种方式:延迟装载,不需每次都创建一个类实例,而只是在第一次使用时创建,有效的利用资源,用时间换资源。 简述什么是工厂模式,以及他解决的问题,应用的环境,解决的方案,模式的本质 利用工厂来解决接口选择的问题的模式。 应用环境:当一个类无法预料要创建哪种类的对象或是一个类需要由子类来指定,创建的对象时,就需要用到工厂模式。 解决方案:定义一个创建对象的类,在类的方法中决定具体实例化哪一个类。 本质:就是根据不同的情况来选择不同的实现类,重在选择。 代码示例:工厂模式的实现方法 单独是使用工厂: public class Factory{ public static Sample creator(int which){ if (which==1){ return new SampleA(); }else if (which==2) return new SampleB(); } } } 工厂+单例: public class MyFactory{ public static MyFactory f = null; public MyFactory(){ } public static MyFactory getInstance(){ if(f==null){ f=new MyFactory(); } } public DBDAO getDAO(){ return new DBDAOImpl(); } } 简述什么是值对象模式,以及他解决的问题,应用的环境,解决的方案,模式的本质 用来把一组数据封装成一个对象的模式 解决问题:在远程方法的调用次数增加的时候,相关的应用程序性能将会有很大的下降 解决方案:使用值对象的时候,可以通过仅仅一次方法调用来取得整个对象,而不是使用多次方法调用以得到对象中每个域的数值 本质:封装数据。 代码示例:值对象模式的实现方法 步骤: public class UserModel{ private String userId; private String userName; public void setUserId(String id){ this.userId = id; } public String getUserId(){ return userId; } public void setUserName(String name){ this.userName = name; } public String getUserName(){ return userName; } } 简述什么是DAO模式,以及他解决的问题,应用的环境,解决的方案,模式的本质 数据访问对象 解决问题:根据数据源不同,数据访问也不同。根据存储的类型(关系数据库、面向对象数据库、纯文件等)和供应商实现不同,持久性存储(如数据库)的访问差别也很大。如何对存储层以外的模块屏蔽这些复杂性,以提供统一的调用存储实现。程序的分布式问题 解决方案:将数据访问逻辑抽象为特殊的资源,也就是说将系统资源的接口从其底层访问机制中隔离出来;通过将数据访问的调用打包,数据访问对象可以促进对于不同数据库类型和模式的数据访问。 本质:分层,是系统组件和数据源中间的适配器。(一层屏蔽一种变化) 代码示例:DAO模式的实现方法 什么是框架?框架的优点? 框架是能够完成一定功能的半成品 1.优点:完成一定的功能、提供一个精良的应用程序架构 2.框架都是以接口的形式出现 3.应该了解框架完成的功能、框架的API接口、框架的功能是怎么实现的 什么是开放-封闭法则(OCP) 可扩展但是不可以更改已有的模块 对扩展是开放的,对修改是封闭 什么是替换法则(LSP) 使用指向基类(超类)的引用的函数,必须能够在不知道具体派生类(子类)对象类型的情况下使用。 如何综合使用我们学过的设计模式来构建合理的应用程序结构 是采用接口进行隔离,然后同时暴露值对象和工厂类,如果是需要数据存储的功能,又会通过DAO 模式去与数据存储层交互。 构建常用的合理的Java应用包结构 Ui(表现层) business–factory,ebi,ebo dao–factory,dao,impl
awt、swing 什么是GUI中的容器?什么是GUI中的组件? 容器:能包含其他container和其他component的component。 组件:在设计上能实现一定功能的封装体; 简述AWT中的Frame、Panel和组件的关系 组件放在Panel上,而多个Panel可以叠加到Frame上,Frame一般只有一个,各个Panel可以互相在Frame上切换 简述如何使用一个组件 初始化,加到容器中,注冊事件,实现相应的事件 Panel pan = new Panel(); TextField td = new TextField(); td.setText(“this is in a TextField.”); pan.add(td); 描述一个GUI界面的基本构成? Frame,Panel,組件 Popmenu 如何控制外观,如颜色、字体等? 可使用setColor(),setFont()方法 例如: Frame f = new Frame(); Font font = new Font(“TimesRoman”, Font.PLAIN, 14); f.setColor(Color.red); f.setFont(f); 什么是布局管理器? 用来管理GUI界面中组件的分布情況,负责决定布局方针以及其容器的每一个子组件的大小 描述每种布局管理器的基本特点 FlowLayout 从左到右分布,排满推到下一行 BorderLayout 上下左右中分布 CardLayout 卡片式分布 GridLayout 网格式分布 XYLayout 坐标分布 什么是JFC(Java基础类)? 是关于GUI组件和服务完整集合, 主要包括5个API: AWT,JavaD,Accessibility,Drag&Drop,Swing 提供了帮助开发人员设计复杂应用程序的一整套应用程序开发包; Swing和AWT的区别? Swing提供了更完整的组件,引入了许多新的特性和能力。Swing API是围绕着实现AWT 各个部分的API 构筑的。 AWT 采用了与特定平台相关的实现,而绝大多数Swing 组件却不是这样做的,因此Swing 的外观和感觉是可客户化和可插的。 什么是双缓冲? 在后台进行界面的更新,然后在前台进行界面交换 功能:双缓冲可以改善一个被频繁改变的组件的外观 描述GUI的事件机制 事件源:是一个事件的产生者,或产生事件的组件对象 事件监听器:调用事件处理方法的对象 事件处理器:就是一个接收事件、解释事件并处理用户交互的方法。 描述Swing应用程序的基本结构? 组件定义 初始化界面 各种事件处理方法 各种适配类 描述表现层的基本功能? 展示数据 人机交互 收集参数、调用逻辑层api 描述在开发Swing应用程序中,一般都要写那些代码?都写到什么地方? 一般要在类的初始化的时候给组件赋值,写在jinit的方法里面 一般要在按扭的事件处理中写收集参数,组织参数,调用业务接口的方法 对于GUI组件而言,最主要的方法是哪些? 初始化 如何给组件初始化 如何从组件中取值 设计组件的属性 如何学习GUI组件的用法? 主要学会组件的定义、取值、赋值的方法 类比学习
CSS 如何把样式表加入到html页面中 在文档中用定义; 使用 元素链接到外部的样式表单。 ; 如何链接元素和样式,请写出4种方法,并代码示例 1、直接连接 2、class连接 3、id连接 4、元素的style=””
成长值: 570
签到天数: 347 天
[LV.8]以坛为家I
10 #
发表于 2014-12-03 12:43:23
| 只看该作者
Xml XML有几种解析方法,有什么区别? 有XML DOM解析、SAX解析、StAX解析 XML DOM:(XML Document Object Model)处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的,这种结构占用的内存较多,而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问; SAX:(Simple API for XML)不同于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件,不需要一次全部装载整个文件。当遇到像文件开头,文档结束,或者标签开头与标签结束时,它会触发一个事件,用户通过在其回调事件中写入处理代码来处理XML文件,适合对XML的顺序访问; StAX:(Streaming API for XML)与其他方法的区别就在于应用程序能够把 XML 作为一个事件流来处理,无论从性能还是可用性上都优于其他方法; DOM解析代码如下: import java.io.*; import java.util.*; import javax.xml.parsers.*; import javax.xml.transform.*; import javax.xml.transform.dom.*; import javax.xml.transform.stream.*; import org.w3c.dom.*; public class Fuxi{ public Fuxi(){} public void runXml(){ File f = new File(“f:/test/xmltest/student.xml”); try{ //首先创建一个documentbuilderfoctory的工厂 DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); //利用工厂来创建documengbuilder DocumentBuilder db = dbf.newDocumentBuilder(); //利用db的parse方法来解析xml文件 Document doc = db.parse(f); //将读出来的文件格式化 doc.normalize(); //定义一个nodelist数组来存放xml文件中的节点(标签) NodeList students = doc.getElementsByTagName(“student”); //从xml文件中读取数据 for(int i=0;i //定义一个元素 Element student = (Element)students.item(i); System.out.println(“stu_id :”+student.getElementsByTagName(“stu_id”).item(0).getFirstChild().getNodeValue()); System.out.println(“name :”+student.getElementsByTagName(“name”).item(0).getFirstChild().getNodeValue()); System.out.println(“age :”+student.getElementsByTagName(“age”).item(0).getFirstChild().getNodeValue()); } //向文件中写数据 String stu_id = “001″; String name = “xingxing”; String age = “22″; Text msg; //创建元素 Element studentNew = doc.createElement(“student”); //创建子元素 Element stuid = doc.createElement(“stu_id”); //设置元素的值 msg = doc.createTextNode(stu_id); //将值添加 给元素 stuid.appendChild(msg); //将元素添加到节点数组中 studentNew.appendChild(stuid); Element name1 = doc.createElement(“name”); msg = doc.createTextNode(name); name1.appendChild(msg); studentNew.appendChild(name1); Element age1 = doc.createElement(“age”); msg = doc.createTextNode(age); age1.appendChild(msg); studentNew.appendChild(age1); //将元素studentnew添加到document树中 doc.getDocumentElement().appendChild(studentNew); //进行写操作 TransformerFactory tff = TransformerFactory.newInstance(); Transformer tfor = tff.newTransformer(); DOMSource dos = new DOMSource(doc); StreamResult result = new StreamResult(f); tfor.transform(dos,result); }catch(Exception e){ System.out.println(e.toString()); } } public static void main(String[] args){ Fuxi ff = new Fuxi(); ff.runXml(); } }