尚学堂Java笔记Word下载.docx
《尚学堂Java笔记Word下载.docx》由会员分享，可在线阅读，更多相关《尚学堂Java笔记Word下载.docx（36页珍藏版）》请在冰豆网上搜索。
10.包装类使用时，自动装箱和拆箱是怎么回事
IntegerI=3;
//装箱。
实际上是一种编译器魔术。
编译器帮助我们修改了代码：
IntegerI=newInteger（3）;
inta=newInteger（3）;
11.equals方法和==的区别
==判断对象是否相同。
equals是Object类中的方法，他的默认实现也是比较引用地址。
不过，很多类重写了这个方法，一般用来比较对象中某些的属性的值。
12.说出你编程中，常见的异常。
至少5个。
自己去想。
13.成员变量和静态变量的区别在内存中如何存放
成员变量，实例变量：
从属于对象。
存放在堆。
静态变量：
从属于类。
存放在方法区
14.重载是怎么回事重写是怎么回事
重载overload：
一个方法名定义多个方法。
参数列表不同（个数、顺序、类型不同），返回值不能构成重载。
重写override覆盖。
将父类的方法覆盖。
15.java中继承如何实现
extends
16.包含抽象方法的类一定是抽象类吗
是。
17.java中，聊聊的多态面向接口编程
多态的实现：
父类引用指向子类对象。
在实际开发中，我们项目中使用了spring。
一般都采用面向接口编程。
我们将变量类型全部定义成接口的类型。
然后，运行时再通过spring注入具体的实现。
18.封装的实现中，说明private、protected、default、public的区别
private私有。
只有自己类中可以调用。
protected受保护。
子类中能用。
子类不在同一个包中能不能调用
default：
同一个包中可以用。
public:
公开的。
任何地方都可以用。
19.面向对象的三大特征有哪些
封装、继承、多态
20.浮点数是有误差的。
如果要实现精确的计算
BigDecimal
21.char类型，能表示汉字吗？
为什么？
22.final修饰变量、方法、类，都有什么区别
变量：
常量
方法：
不能被子类重写
类：
不能被继承
23.final,finally,finalize方法的区别
final修饰变量、修饰方法、修饰类。
。
finally在异常处理中使用。
表示不管有没有异常都会执行这里。
通常用来释放资源。
finaliize，垃圾回收这个对象前执行的方法。
24.String是不可变字符从源代码分析，为什么
内部有一个char数组。
这个数组使用了final修饰。
意味着只能初始化一次。
25.StringBuffer和StringBuilder的区别
StringBuffer可变字符序列，线程安全
StringBuilder可变字符序列。
线程不安全。
一般用它。
26.java中，类可以多继承吗接口可以多继承吗
类不可以多继承。
接口可以多继承。
27.数组是对象吗
28.数组中元素默认初始化的规则是什么
跟成员变量的规则是一样的。
引用类型为null。
数值：
0布尔：
false
29.数组的长度是固定的吗？
是的。
30.Collection、List和Set接口有什么联系
Collection是List和Set的父接口。
31.list和set接口的区别是
List：
有序、可重复。
Set：
无序、不可重复。
32.Collection和Collections的区别
Collection接口。
Collections是一个针对Collection提供的工具类。
33.Vector、ArrayList的区别是
Vector线程安全。
ArrayList线程不安全。
34.HashMap和HashTable的区别是
HashTable线程安全，HashMap线程不安全。
35.两个对象hashcode（）方法返回值相同，那么调用equals方法一定为true吗
从规范上讲，要。
36.AWT、swing是什么关系swing有什么优势
37.GUI编程中，有哪些常用的布局管理器
Flow、Border、Card、Grid等
38.如何实现序列化
实现Serielizable。
他是一个空接口。
39.要把一个字节流对象转化成字符流对象，需要用到什么类
InputStreamReader，OutputStreamWriter
40.进程和线程的区别是
进程是一个独立运行的程序，拥有独立的内存空间、代码。
一个进程中可以包含多个线程。
多个线程共享同一块空间和代码。
41.写出定义线程类的两种常见方式
继承Thread、实现Runnable接口
42.说说，Runnable接口和Thread的区别
Thread也是实现了Runnalbe接口。
43.synchronized如何使用
如果直接修饰方法，意味着线程要调用这个方法必须要有这个方法所在的对象的锁。
如果修饰了方法块，上面可以声明需要拥有的对象锁。
这样的话，线程只有拥有指定对象的锁才能运行这个代码块。
不然，就等待。
44.说说：
wait（）,notify（）,sleep（）方法作用
wait（），线程进入阻塞状态。
释放持有的对象锁。
sleep（），线程进入阻塞状态。
但是，不是放持有的对象锁。
notify（），唤醒等待池中的线程
45.java中，反射机制的基本原理Class类得作用是
反射机制是java动态性重要手段。
当我们加载完毕一个类的时候，会同时创建一个Class类型的对象，Class类型的对象它包含了这个类的完整的数据结构。
就像一个镜子一样，通过这个镜子我们可以得到对应类的所有信息。
而且，Class类还包含了如何操作属性、构造器、方法的接口。
这样的话，我们就可以通过反射机制动态的创建对象、动态的调用对象的方法、动态的操作属性。
46.通过Class类，可以访问和设置一个类得私有方法、私有成员变量吗如果能，怎么做
可以直接操作私有方法。
可以操作私有成员变量。
通过setAccessible（true）。
47.通讯方式中，TCP和UDP的区别是？
TCP：
transfercontrolprotocol传输控制协议。
面向连接的、安全的。
效率不高的。
我们一般用的Socket就是TCP连接。
我们访问网站也是TCP/IP协议，建立连接。
UDP:
UserDatagramProtocol用户数据包协议。
无连接、不安全、效率高。
48.内部类
java手写编程题目
1.写出冒泡排序代码
publicclassTest{
publicstaticvoidmain（String[]args）{
int[]values={3,1,6,2,9,0,7,4,5,8};
sort（values）;
System.out.println（Arrays.toString（values））;
}
publicstaticvoidsort（int[]values）{
inttemp;
for（inti=0;
i<
values.length;
i++）{
for（intj=0;
j<
values.length-1-i;
j++）{
if（values[j]>
values[j+1]）{
temp=values[j];
values[j]=values[j+1];
values[j+1]=temp;
}
}
}
}
2.写出二分法查找代码
staticintbinarySearch（int[]arr,intsearchWord）{
Arrays.sort（arr）;
//先对传进来的数组进行排序
//二分法查找
intiIndex=0;
//相当于指针的东西
intiStart=0;
intiEnd=arr.length-1;
intsearchCount=0;
arr.length/2;
searchCount++;
iIndex=（iStart+iEnd）/2;
if（arr[iIndex]<
searchWord）{
iStart=iIndex;
}elseif（arr[iIndex]>
iEnd=iIndex;
}else{
break;
returnsearchCount;
3.写出一个双向链表类代码
package
publicclassNode<
E>
{
privateEelement;
//结点数据
privateNode<
next;
//上结点
previous;
//下结点
privatestaticintsize=0;
//链表长
//默认关结点nextprevious都是空，
publicNode（）
this.element=null;
this.next=null;
this.previous=null;
privateNode（Eelement,Node<
next,Node<
previous）
this.element=element;
this.next=next;
this.previous=previous;
/**
*尾部添加元素e
*@parame
*/
publicvoidaddAfter（Ee）
//定义新结点，next-->
头结点；
previous-->
头结点.previous（尾结点）
Node<
newNode=newNode<
（e,this,this.previous==nullthis:
this.previous）;
//头结点next为空则让它指向newNode
if（this.next==null）
this.next=newNode;
//头结点previous为空则让它指向newNode
if（this.previous==null）
this.previous=newNode;
this.previous.next=newNode;
size++;
*头部添加元素e
publicvoidaddBefor（Ee）
（e,this.next==nullthis:
this.next,this）;
this.next.previous=newNode;
*在index处添加元素e
*@paramindex
publicvoidadd（Ee,intindex）
//索引越界
if（index>
=size||index<
0）
thrownewIndexOutOfBoundsException（"
Node.get（）:
"
+index）;
else
//index>
size/2,反向遍历
size>
>
1）
temp=this;
for（inti=size;
i>
index;
i--）
temp=temp.previous;
（e,temp,temp.previous）;
temp.previous.next=newNode;
temp.previous=newNode;
for（inti=0;
=index;
i++）
temp=temp.next;
*删除第index个元素
publicvoidremove（intindex）
temp.previous.next=temp.next;
temp.next.previous=temp.previous;
size--;
*取得第index个元素
*@return
publicEget（intindex）
returntemp.element;
publicintsize（）
returnsize;
publicstaticvoidmain（Stringa[]）
Nodenode=newNode（）;
node.addAfter（"
1"
）;
2"
3"
node.addBefor（"
0"
node.add（"
7"
0）;
System.out.println（node.get（0））;
System.out.println（node.get
（1））;
System.out.println（node.get
（2））;
System.out.println（node.get（3））;
System.out.println（node.get（4））;
4.写出一个二叉树代码
classTreeNode{
privateStringdata;
privateTreeNodeleftNode;
privateTreeNoderightNode;
publicTreeNode（Stringdata,TreeNodeleftNode,TreeNoderightNode）{
this.data=data;
this.leftNode=leftNode;
this.rightNode=rightNode;
publicStringgetData（）{
returndata;
publicvoidsetData（Stringdata）{
publicTreeNodegetLeftNode（）{
returnleftNode;
publicvoidsetLeftNode（TreeNodeleftNode）{
publicTreeNodegetRightNode（）{
returnrightNode;
publicvoidsetRightNode（TreeNoderightNode）{
5.编写一个生产者和消费者的程序
publicclassTestProduce{
SyncStacksStack=newSyncStack（）;
Shengchansc=newShengchan（sStack）;
Xiaofeixf=newXiaofei（sStack）;
sc.start（）;
xf.start（）;
classMantou{
intid;
Mantou（intid）{
this.id=id;
classSyncStack{
intindex=0;
Mantou[]ms=newMantou[10];
publicsynchronizedvoidpush（Mantoum）{
while（index==ms.length）{
try{
this.wait（）;
//wait后，线程会将持有的锁释放。
sleep是即使睡着也持有互斥锁。
}catch（InterruptedExceptione）{
e.printStackTrace（）;
this.notify（）;
//唤醒在当前对象等待池中等待的一个线程（随意的）。
notifyAll叫醒所有在当前对象等待池中等待的所有线程。
//如果不唤醒的话。
以后这两个线程都会进入等待线程，没有人唤醒。
ms[index]=m;
index++;
publicsynchronizedMantoupop（）{
while（index==0）{
index--;
returnms[index];
classShengchanextendsThread{
SyncStackss=null;
publicShengchan（SyncStackss）{
//TODOAuto-generatedconstructorstub
this.ss=ss;
@Override
publicvoidrun（）{
//TODOAuto-generatedmethodstub
20;
造馒头：
+i）;
Mantoum=newMantou（i）;
ss.push（m）;
classXiaofeiextendsThread{
publicXiaofei（SyncStackss）{
Mantoum=ss.pop（）;
吃馒头：
6.定义一个多线程类，并写出如何终止线程的执行，并启动他。
publicclassTestThreadCiycleimplementsRunnable{
Stringname;
booleanlive=true;
publicTestThreadCiycle（Stringname）{
super（）;
this.name=name;
inti=0;
while（live）{
System.out.println（name+（i++））;
publicvoidterminate（）{
live=false;
TestThreadCiyclettc=newTestThreadCiycle（"
线程A:
Threadt1=newThread（ttc）;
//新生状态
t1.start（）;
//就绪状态
1000;
System.out.println（i）;
ttc.terminate（）;
System.out.println（"
ttcstop!
7.写出一个文件复制的程序
voidcopyFile（Stringsrc,Stringdec）{
FileInputStreamfis=null;
FileOu
升级会员 