JAVA局部变量i重复_java面试笔试总结

Java语言的特点：

1.提供了类机制和接口模型，避免了运算符重载。多继承、指针等复杂且降低安全性的概念。

封装实现了模块化合信息隐蔽；继承实现了代码的重用；子类覆盖父类实现了多态。

Java的多线程机制可以让应用程序并发执行，其同步机制实现了数据的共享。

Java提供了自动回收废弃空间、异常处理等功能，对内存空间的访问要通过对对象的实例进行，有效阻止了部分故障，具有安全、健壮行。

Java面向网络应用，可以处理TCP/IP协议规程，通过URL地址在网络上访问其他的对象。

Java不允许通过直接指出内存地址的方式对其单元的内容进行操作，及没有c语言的指针

Java先将源程序编译成一个字节码，然后再解释器解释成机器指令。

类型转换：byte.short .char

类型的运算操作首先转换成int类型，然后对int类型值进行运算。最后得到int类型的结果。

java使用unicode编码，而C用ASCII编码。通常说的32位平台，使得基本类型所占的字节数不同：

java：

1byte=1字节=8bit

1 short= 2字节 = 16bit

1char=2字节

1 int = 4字节=32bit

1float=4字节

1long=8个字节

1double=8个字节

C：16位平台

Short 2

int 2

long 4

float 4

double 8

char 1

32位平台

Short 2

int 4

long 4

float 4

double 8

char 1

char s[]=”0123456789” sizeof(s)=11

char s[100]=”0123456789” sizeof(s)=100

2.static final 、abstract的区别

静态属性和实例属性的差别：

1.static属性在类中只有一个，而实例属性有多少个对象就有多少个值

2.static 在类加载时，就被实例化，而实例属性在生成对象时被实例化

3.在访问时，static属性要通过类名访问，而实例属性必须要实例化对象后，通过对象调用。

注意：

1.静态方法里只能访问本类中的静态成员，不能直接访问非静态成员，静态方法不依赖于对象，所以当类加载成功够，静态方法就可以访问而这时对象不一定存在，非静态成员自然一定不存在。而且即使存在非静态成员，静态方法也不知道访问哪一个对象的成员。

2.静态方法中也不能出现this关键字，因为this是针对对象而言的。

3.非静态方法可以访问静态的成员。

4.static只能用来修饰成员。Final可修饰类，类的属性，方法、方法中的局部变量

Static 修饰代码块

该代码在类加载的时候就被执行，构造方法运行前就运行了

Static 修饰内部类

不依赖于外部类而存在，静态内部类也不可以用private定义，静态内部类只能访问外部类的静态成员，不能访问非静态成员。

Abstract：

不能和final同时使用，abstract让继承重写，而final则相反。

不能用private修饰方法，原因同上

不能和static同时使用，static不依赖于对象，依赖于类，不能够重写。

3.类型转换的问题：

C为强类型转换：在数值运算时，将short，char，等转换为int型的，最后在根据实际类型转换过来.而double类型则不是。

Java为弱类型转换：要强制类型转换。

主要是编译器的问题：

3、int 和Integer 有什么区别Java

提供两种不同的类型：引用类型和原始类型(或内置类型)。

Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。原始类型封装类booleanBoolean

charCharacter byteByte shortShort intInteger longLong floatFloat

doubleDouble

引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为null，而原始类型实例变量的缺省值与它们的类型有关。

类与接口：类单继承，可实现多个接口。若有A B两个类，C想继承两个类的功能，可让B继承A

然后让C继承B，利用类的继承的传递性

堆和栈

首先，它们都是内存中存放数据的地方。C++中要人工管理，java中自行处理。

其次，堆给new的对象动态地分配空间，因此存取速度较慢；同时堆是有垃圾收集器回收的。

String str1 = new String(“abc”);

String str2 = new String(“abc”);

Str1 == str2 //false “==”//判断是否指向同一个对象 “equals”判断数值是否相等

区分大小写字母；

再次，而栈的数据共享的，主要存放一些基本类型的变量。栈的数据大小与生存期必须是确定的；

String str1 =”abc”;

String str2 = “abc”;

Str1 == str2//true

栈的使用：

String str1 = “abc”；JVM根据是否存在“abc”来创建新对象，而new

则一定创建新对象，故加重了程序的负担。

将String转换成int的方法：Integer.parseInt(string)；

异常处理和垃圾回收器；

异常处理

违反语义规则包括2种情况。一种是JAVA类库内置的语义检查。例如数组下标越界,会引发IndexOutOfBoundsException;访问null的对象时会引发NullPointerException，强制类型转换，类型不匹配时会报出ClassCastException。另一种情况就是JAVA允许程序员扩展这种语义检查，程序员可以创建自己的异常，并自由选择在何时用throw关键字引发异常。所有的异常都是java.lang.Thowable的子类。

Exception 分为RuntimeException和非RuntimeException

RuntimeException包括自带的类型转换、数组越界、空指针等

非RuntimeException

IOException、FileNotFoundException、ClassNotFoundException等可不不做处理的一检查异常。

Try/catch用来处理真正的异常，如IoException，InterruptedException。而RuntimeExcetion在编译时不能获得，

垃圾回收器

在c语言中，要求显式地分配动态内存，释放内存，而由于人为实现，往往分配的内存没有释放，导致了“内存泄露”问题。最终程序耗尽内存从而使得异常的终止，至少无法继续运行。而java创建对象时自动的分配内存，释放内存，避免了很多潜在的问题。垃圾回收器在空闲时自动的检查对象的各个引用，因此它的线程优先级最低，并且不可以被强制执行，可调用system。Gc来建议执行垃圾收集器。

回收标准：(1)给对象赋予了空值null，以下没有再调用过；

(2)给对象赋予新值，及重新分配了内存空间。

进程：

资源分配的基本单位；

3部分组成：进程是由进程控制块(PCB)、程序段、数据段三部分组成;

三种状态：就绪、运行、阻塞。

进入等待状态的3种情况：

CPU调度给优先级更高的Thread，原来thread进入等待；

阻塞的thread获得资源或信号，进入等待状态

时间片轮转的情况下，若时间片到了，也将进入等待状态；

线程：

程序独立调度和分派执行的基本单位：

3要素：cpu、data、code。共享代码与共享数据的问题。

生命周期的4个状态：新建、运行、阻塞、死亡。

新建：继承Tread类或者实现Runnable接口；

运行：调用start方法，准备状态和运行状态；根据系统分配时间片；

阻塞：三种情况：调用sleep让线程进入睡眠状态；等待用户输入；等待锁；—》运行状态

死亡：run执行完毕；发生了异常；

临界资源解决方案：同步技术，互斥锁机制；频繁的使用同步技术造成死锁；

Tread.sleep()这个静态的方法可以强制线程进入等待状态；时间期满后也不一定立即恢复执行(不用释放对象锁)调用此方法要捕捉InterruptedException

异常。

Thread.wait()(object的子类),当线程交互时，如果对一个同步对象x发出一个wait调用，该线程会暂停执行，被调用对象(释放掉对象锁)进入等待此对象锁的等待池中，直到被唤醒或等待时间到。

锁是加在对象上而不是方法上，故如果对象拥有两个同步化的方法，就表示两个线程无法进入同一个方法，也不能进入不同的方法。

多线程有两种实现方法，分别是继承Thread 类与实现Runnable 接口

同步和异步：

同步就是在临界资源的争夺中使用，同步的实现方面有两种，分别是synchronized,wait

与notify。

异步就是用一个不需要返回的方法且该方法花费太长时间的时候使用。

I/O：

File类型

按照数据流的方向分为：输入流和输出流；

按照数据单位不同分为：字节流和字符流；

按照功能的不同分为：节点流和包装流；

字节流：输入流InputStream 和 输出流 OutputStream

用于二进制数据(声音、图像)的读写。、

字节流派生出的节点流子类：

磁盘文件的输入和输出：FileInputSteam、FileInputStream

内存数组的输入和输出：ByteArrayInputStream、ByteArrayOutputstream

管道输入输出，用来在线程间的通信：PipedInputStream、PipedOutputStream

字符流：输入流Reader 和输出流 Writer 用于文本类型数据的读写。

字符流的编码：ISO8859-1、 UTF-8、

字符流派生出来的节点流子类：

磁盘文件的输入和输出：FileReader、FileWriter

内存数组的输入和输出：CharArrayReader、CharArrayWriter

内存字符串的输入和输出：StringReader、StringWriter

管道输入输出，用来在线程间的通信：PipedReader、PipedWriter

包装流：将节点流封装在处理流中使用。包括缓冲流、转换流、数据流、打印流、序列流

缓冲流：提高输入输出的效率减少对硬盘的损坏

字节流：BufferedInputStream、BufferedOutputStream

字符流BufferedReader、BufferdWriter

过滤流：在操作数据的同时，对传输数据进行类型的转换。

字节流：FilerInputSteam FileOutputSream

字符流：FileReader FileWriter

字节流转化为字符流：inputStreamReader outputSreamWriter

打印流：printWriter printStream

数据流：用于网络的数据传输

字节流：DataInputSteam DataOutputStream

随机访问文件类RondomAccessFIle 创建对指定文件或名称的随机访问文件流

对象的序列化：java的远程方法调用，可以像调用自己机器上的对象一样调用其他机器的对象。

字符串：

String s = “aa”；

Char c = s[1];错误；字符串不能分开

String s = “hello”；

Char c[] = {‘h’,’e’,’l’,’l’,’o’};

s.equals(t)为true。

数组没有length()方法，有length属性，String有length()这个方法。、

Char a;

a = ‘*’;

a +=a; a=42*2;

String s=”*”;

String s1 =”*”; s1 +=s1;

S1=”**”;

String s1 = “abc”；

String s2 = “abc”；

创建了一个对象

String s1 = new String(“abc”);

String s2 = new String(“abc”);

创建了3个对象

String s = “a”+“b”；

String s = “a”；

S +=”b”;

前者开辟了三个内存段，后者开辟了两个内存段

String s = “a”+”b”+”c”+”d”;

String s1 = “abcd”;

System.out.println(s==s1);(true)

表明创建了一个对象，javac编译器可以对字符串常量直接相加的表达式进行优化，不必等到运行期，在编译阶段就去进行加法处理，直接就将其编译成一个常量相连的结果。

Equals 比较内容  “==”比较地址

JVM首先根据内容查找对象，若没有找到，则在heap上创建新对象，并将其赋予s1，否则使用已经存在的对象。

String 和 StringBuffer

String result = “result” + “world”;

StringBuffer result = new

String().append(“hello”).append(“world”);

前者效率好于后者

String s =”s1”;

S+=”s2”;

S+=”s3”;

StringBuffer s = new

StringBuffer().append(“s1”).append(“s2”).append(“s3”);

前者的效率要低，因为String为不可变的对象，故每次“+=”操作都会构造新的对象。

char型变量中能不能存贮一个中文汉字?为什么?

能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的

内部类：

成员内部类；

1. 不能含有静态成员。

2. 调用外部类的属性有两种方法，可以调用私有属性：OuterA。This。name或者直接调用

局部内部类；

1.方法中定义的内部类，跟局部变量相同，

2可以访问外部类的实例变量和局部变量，局部变量必须是final型的，非final的不能访问。

3.外部类不能直接访问局部内部类，但是可以间接访问，通过实现接口的办法来实现，

4．在方法中返回接口的类型，这样既可以是局部类不可见，又可以在类的外部访问到内部类的方法。

静态内部类；

1说明这个类不依赖于外部类对象的存在，不能用private修饰。

2只能访问外部类的静态成员

匿名内部类

1是一种特殊的局部内部类，使用于只是用一次且不需要多次创建对象的类。类代码和创建对象同时完成

2没有构造方法的类

3通常用于继承类或者实现接口，不需要增加额外的方法。

HTTP：

Get 和 post 方法；

get通过添加在url后来显示传递参数给服务器，故容量有限，且容易丢失，故是不安全的。

Post 则隐式地传递参数，比get安全。

在form表单提交中，分别对应doget()和dopost()方法来处理请求。

Cookie 和 session 机制：

Cookie

采用客户端保持机制的方案，cookie的使用由浏览器按照一定原则在后台自动发送给服务器。cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗

考虑到安全应当使用session

Seesion是一种服务器的机制，服务器使用一种类似散列表的结构来保存信息。Sessionid的保存方式可以采用cookie。当访问增多，会比较占用你服务器的性能，考虑到减轻服务器性能方面，应当使用COOKIE。

网页设计:

Xml与Html

XMl区分大小写，属性值必须写在引号中，Html则不用，XMl有命名空间方便程序员查询和提取数据，xml的解析技术有DOM、SAX、Pull解析器

Dom解析必须在解析前将整个文档装入到内存，适合随机访问。

SAX是事件驱动行的解析方式，通过触发方式后的文件头和尾，适合顺序访问。

XML技术的数据存储和信息配置

Javascript为动态联编

集合collection：

由set 和 List分别定义了存储方式

Set；没有次序，不允许重复

sortedSet；安升序排列

List；增加或删除按照顺序，允许重复

Map：key不能重复，value可以重复

SortedMap：按照键值升序排列

ArrayList：效率高，不直接支持并发，多用于查询；用size()查看列表中元素个数，底层为数组的存储方式。

LinkedList：效率高。查询慢，多用于插入和删除，底层双链表实现；

Vector：效率低、线程安全(同步方法)，多支持并发，用于查询。

HashMap 和 HashTable 的异同：

相同点：都是属于Map接口的类，实现了将唯一键映射到特定的值上。没有分类和排序。

不同点：

HashMap：允许一个Null键和多个null值，将contains方法改成了containsvalue和containsKey，key是无序存放不可重复，通过hash码值来保证key不充复。

Put(K key， V value)

Remove(key)

Get(key)

keySet()获得key的一个Set集合。在遍历Map时，通过使用KeySet()方法获得Key的一个Set集合，可以通过遍历这个Set。用get()方法获得Key多对应的value，也就遍历了Map

Hashtable：同步方法(线程安全)，多个线程访问时，不需要自己写同步方法，而HashMap就必须提供外同步。

TreeMap；自然排序；也可以自定义类实现Comparable接口。

HashSet:存储效率高，查询低

TreeSet存储低，查询高；

底层为二叉树实现，它可以对集合中的元素进行排序。可以自动过滤掉重复元素，所以不要重载hashcode()。

TreeMap:不支持并行，不允许空键值

package com.amaker.test;

import java.util.Iterator;

import java.util.TreeMap;

public class Test3 {

public static void main(String[] arg0) {

String s = "adaddffdaadefasddeaakkaa";

TreeMap map =

new TreeMap

Integer>();

for(int i=0;i

String tmpStr = s.charAt(i) + "";

Object

tmpobj = map.get(tmpStr);

if(tmpobj == null){

map.put(tmpStr, new Integer(1));

}else

{

map.put(tmpStr, new Integer(((Integer)tmpobj).intValue()

+1));

}

}

for(Iterator itor =

map.keySet().iterator();itor.hasNext();) {

String word = itor.next().toString();

Integer integer = (Integer)map.get(word);

System.out.println("字母[" + word +

"]出现的次数："+integer.intValue());

}

}

}

实现comparab接口的排序叫做自然排序，利用比较器的排序叫做客户化排序。

Comparable接口 和 Comparator 比较器；

实现compara接口要写compareTo()方法

实现comparator接口要写compare()方法

数据库：

(一) 有个表tableqq，有整型的id 项和字符类型的nickname 项，这两个项都不允许为空

新建表；

Create table tableqq

{

Id number(12) not null,

Nickname varchar2(30) not null

};

查找：

Select * from tableqq where nickname = ‘qq’ order by id

desc;

插入：

Insert into tableqq values(123, ‘abc’);

删除：

Delete from tableqq where id = 1234;

删除表：

Drop table tableqq;

(二)有关系 s(sno,sname) c(cno,cname) sc(sno,cno,grade)

上课程“db”的学生：

Select s.sno, s.sname from s, c, sc where s.sno=sc.sno and

c.cno=sc.cno and c.cname=”db”

成绩最高的学生号：

Select sno,max(grade) from sc group by sno;

每科大于90分得学生数；

Select cno, count(sno) from sc where grade>90

group by cno;

(三)

S(SNO,SNAME, SCITY)

P(PNO,PNAME,COLOR,WEIGHT)

J(JNO,JNAME,CITY)

SPJ(SNO,PNO,JNO,QTY);

其中：

S 为供应商表，SNO：供应商号，SNAME：供应商名称，SCITY：供应商

所在城市。

P 为零件表，PNO：零件号，PNAME：零件名称，COLOR：零件颜色，

WEIGHT：零件重量。

J 为工程项目表，JNO：工程项目号，JNAME：项目名，CITY：项目所在

城市

SPJ 为供应情况吧，SNO：为供应商号，PNO：零件号，JNO：工程项目

号，QTY：供应数量

问：

1. 写出没有使用天津供应商生产的红色零件的工程号JNO？

Select distinct JNO from SPJ where SPJ.SNO

not in (select S.SNO from S where S.SCITY = “天津”) or SPJ.PNO

not in (select P.PNO from P where P.COLOR = “红色”)；

2.写出至少使用了S1(SNO)供应商所提供的全部零件的工程号JNO？

Select JNO from SPJ,S where SPJ.PNO in all(select PNO from SPJ,S

where SPJ.SNO = S.SNO AND S.SNAME=”S1”)

3.统计每种零件的供应总量？

Select PNO,SUM(QTY) from SPJ where PNO is not null group by

PNO;

4.建立视图VSJ，它记录了给“北京城建”工程项目的供应零件的情况，

包括供应商号、零件号和零件数量

create view VSJ as select SNO,PNO,QTY from SPJ,J where

SPJ.JNO = J.JNO AND J.JNAME

= ‘北京城建’

笔试题：

1.

要想使只有定义该类所在的包内的类可以访问该类，应该用( final)关键字

2.包pack1中class1的方法 public void method_1() {}

protected void method_2() {}

private void method_3() {}

void method_4() {}

在包pack2中只能访问method——1

和2

2.

String s= "Jessica "; char c=s.charAt(6);字符串中0开始

3当一个类的某个变量声明为protected，同包中的任何其他类能够访问它，不同包中的子类可以访问该变量

4 String 转化成整形 Integer.parseInt(string)

Class Test3 {

public int sign;

public int

m;

public

Test3(int sign, int m){

this.sign = sign;

this.m = m;

}

public int

atoi(String s)

{

char ch[] = s.toCharArray();

if(ch[0]=='+'|| ch[0]=='-')

{

sign = (ch[0] == '+')?1:-1;

}

for(int i=1;i

{

m= m*10+(ch[i]-'0');

}

return m*sign;

}

public

static void main(String[] args) {

String s = "+578";

Test3 t = new Test3(1,0);

System.out.println(t.atoi(s));

}

}

两台笔记本ping不通的原因：

(2) 网线的问题

(3) 局域网的设置问题，Ip地址设置

(4) 网卡驱动

(5) 防火墙设置

(6) 防火墙软件

3次握手！

1.参加代码质量培训，考试过关。

2.怎样才能建立在整个类中都恒定的常量呢？别指望const 数据成员了，应该用类中

的枚举常量来实现。枚举常量不会占用对象的存储空间，它们在编译时被全部求值。枚举常量的缺点是：

它的隐含数据类型是整数，其最大值有限，且不能表示浮点数(如PI=3.14159)

3.函数接口的两个要素是参数和返回值。C 语言中，函数的参数和返回值的传递方式

有两种：值传递(pass by value)和指针传递(pass by

pointer)。C++ 语言中多了引用

传递(pass by reference)。由于引用传递的性质象指针传递，而使用方式却象值传递，

4如果参数是指针，且仅作输入用，则应在类型前加const，以防止该

指针在函数体内被意外修改。

5getchar 的确不是char 类型，而是int 类型，

6swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?

switch(expr1)中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、

short、 char 或者 byte。long,string 都不能作用于swtich。

7 。 静态成员函数和静态数据成员的区别：

它们都通过static来修饰，故都是抽象的成员，属于类，而不依赖于对象，静态数据成员只能通过类来访问，而静态成员函数则类和对象都可访问，非静态成员函数只能通过对象来访问，即依赖于对象。

静态成员函数可以直接访问该类的静态数据成员和函数成员，非静态数据成员只能通过对象来访问。

8

接口：即多态的体现。抽象类不能被实例化，必须被继承。Abstract来修饰。

抽象的方法没有实体，必须被覆盖。含有抽象方法的类也必须是抽象类。

9.静态方法和非静态方法：static修饰，静态方法不能够被初始化。

静态的方法不能调用非静态的变量和非静态的方法。

静态变量对所有的实例来说都相同，即每个类只有一个。它会在该类的任何静态方法执行之前就初始化。

实例变量，每个实例一个。

静态的final变量是常数，静态初始化程序在类加载时会执行的代码。Final修饰的变量，方法、类表示不能改变，覆盖，继承。

10.命名空间：由于不同的程序员在不同模板中使用相同的名字表示不同的事物，引起了程序出错，从而提出了命名空间。Std