java基础教程笔记文档格式.docx
《java基础教程笔记文档格式.docx》由会员分享，可在线阅读，更多相关《java基础教程笔记文档格式.docx（18页珍藏版）》请在冰点文库上搜索。
0或1…….?
Byte:
本身是整形，是一个字节，在32位机和64位机上是不会改变的。
Unicode：
唯一码是两个字节，
背景：
用两个字节表示一个汉字
*char与byte或short之间的赋值必须实行强制转换
有关基本数据类型的知识挖掘？
算术运算符和算术表达式：
JAVA移位运算符：
移位运算符就是在二进制的基础上对数字进行平移。
按照平移的方向和填充数字的规则分为三种：
<
（左移）、>
>
（带符号右移）和>
（无符号右移）。
在移位运算时，byte、short和char类型移位后的结果会变成int类型，对于byte、short、char和int进行移位时，规定实际移动的次数是移动次数和32的余数，也就是移位33次和移位1次得到的结果相同。
移动long型的数值时，规定实际移动的次数是移动次数和64的余数，也就是移动66次和移动2次得到的结果相同。
三种移位运算符的移动规则和使用如下所示：
<
运算规则：
按二进制形式把所有的数字向左移动对应的位数，高位移出（舍弃），低位的空位补零。
语法格式：
需要移位的数字<
移位的次数
例如：
3<
2，则是将数字3左移2位
计算过程：
3<
2
首先把3转换为二进制数字00000000000000000000000000000011，然后把该数字高位（左侧）的两个零移出，其他的数字都朝左平移2位，最后在低位（右侧）的两个空位补零。
则得到的最终结果是00000000000000000000000000001100，则转换为十进制是12.数学意义：
在数字没有溢出的前提下，对于正数和负数，左移一位都相当于乘以2的1次方，左移n位就相当于乘以2的n次方。
>
按二进制形式把所有的数字向右移动对应位数，低位移出（舍弃），高位的空位补符号位，即正数补零，负数补1.
需要移位的数字>
例如11>
2，则是将数字11右移2位
11的二进制形式为：
00000000000000000000000000001011，然后把低位的最后两个数字移出，因为该数字是正数，所以在高位补零。
则得到的最终结果是00000000000000000000000000000010.转换为十进制是3.数学意义：
右移一位相当于除2，右移n位相当于除以2的n次方。
按二进制形式把所有的数字向右移动对应位数，低位移出（舍弃），高位的空位补零。
对于正数来说和带符号右移相同，对于负数来说不同。
那么不同点是什么？
无符号位移（>
）和有符号位移（>
）的区别是
有符号位移运算时如果数字为正数时位移后在前面补0，为负数时则在位移后在前面补1
例
100>
2==25和上面的计算方法一样
如果100为负数
-100>
2
-100的二进制为111111*********1111111111111111111111111111111111111111111111100
移除最后2位后
111111*********11111111111111111111111111111111111111111111111
之后在前面补两位
111111*********1111111111111111111111111111111111111111111111111
变为十进制后结果为-1
所以
2=-1
其他结构和>
相似。
小结
二进制运算符，包括位运算符和移位运算符，使程序员可以在二进制基础上操作数字，可以更有效的进行运算，并且可以以二进制的形式存储和转换数据，是实现网络协议解析以及加密等算法的基础。
实例操作：
publicclassURShift{
publicstaticvoidmain（String[]args）{
inti=-1;
i>
=10;
//System.out.println（i）;
mTest（）;
}
publicstaticvoidmTest（）{
//左移
inti=12;
//二进制为:
0000000000000000000000000001100
i<
=2;
//i左移2位，把高位的两位数字（左侧开始）抛弃,低位的空位补0,二进制码就为0000000000000000000000000110000
System.out.println（i）;
//二进制110000值为48；
System.out.println（"
br>
//右移
=2;
//i右移2为，把低位的两个数字（右侧开始）抛弃,高位整数补0，负数补1，二进制码就为0000000000000000000000000001100
//二进制码为1100值为12
//右移example
intj=11;
//二进制码为00000000000000000000000000001011
j>
//右移两位，抛弃最后两位,整数补0,二进制码为：
00000000000000000000000000000010
System.out.println（j）;
//二进制码为10值为2
bytek=-2;
//转为int,二进制码为：
0000000000000000000000000000010
k>
//右移2位，抛弃最后2位，负数补1,二进制吗为：
11000000000000000000000000000
//二进制吗为11值为2
在ThinkinginJava第三章中的一段话:
移位运算符面向的运算对象也是
二进制的“位”。
可单独用它们处理整数类型（主类型的一种）。
左移位运算符（<
）能将运算符左边的运算对象向左移动运算符右侧指定的位数（在低位补0）。
“有符号”右移位运算符（>
）则将运算符左边的运算对象向右移动运算符右侧指定的位数。
“有符号”右移位运算符使用了“符号扩展”：
若值为正，则在高位插入0；
若值为负，则在高位插入1。
Java也添加了一种“无符号”右移位运算符（>
），它使用了“零扩展”：
无论正负，都在高位插入0。
这一运算符是C或C++没有的。
若对char，byte或者short进行移位处理，那么在移位进行之前，它们会自动转换成一个int。
只有右侧的5个低位才会用到。
这样可防止我们在一个int数里移动不切实际的位数。
若对一个long值进行处理，最后得到的结果也是long。
此时只会用到右侧的6个低位，防止移动超过long值里现成的位数。
但在进行“无符号”右移位时，也可能遇到一个问题。
若对byte或short值进行右移位运算，得到的可能不是正确的结果（Java1.0和Java1.1特别突出）。
它们会自动转换成int类型，并进行右移位。
但“零扩展”不会发生，所以在那些情况下会得到-1的结果。
基本语句
三种基本语句类型和c语言相同。
break;
带标签和不带标签的区别
outer：
for………,这里面outer就是标签的作用。
Continue语句，也可以带标签。
一般带有标签的操作，是作用于多层循环之中，为了跳出某层循环的作用。
Java中各种运算符中的优先级：
说明：
1、该表中优先级按照从高到低的顺序书写，也就是优先级为1的优先级最高，优先级14的优先级最低。
2、结合性是指运算符结合的顺序，通常都是从左到右。
从右向左的运算符最典型的就是负号，例如3+-4，则意义为3加-4，符号首先和运算符右侧的内容结合。
3、instanceof作用是判断对象是否为某个类或接口类型，后续有详细介绍。
4、注意区分正负号和加减号，以及按位与和逻辑与的区别
其实在实际的开发中，不需要去记忆运算符的优先级别，也不要刻意的使用运算符的优先级别，对于不清楚优先级的地方使用小括号去进行替代，示例代码：
intm=12;
intn=m<
1+2;
（1+2）;
//这样更直观
java的分支语句
练习：
1.屏幕输出九九乘法表如下：
2.对一个给定的数组进行排序，要求输出原数组和排序后的数组。
3.屏幕输出一个魔方阵：
魔方阵的排列方法
如3×
3的魔方阵：
816
357
492
魔方阵的排列规律如下：
第三章：
面向对象
面向过程：
结构话程序设计：
面向对象的程序设计：
类的创建
[public][abstract|final]classclassName[extendssuperclassName][implementsinterfaceNameList]
{
成员变量声明及初始化；
方法声明及方法体；
}
[implementsinterfaceNameList]：
接口的列表
Protected，是只有子类可以访问该属性
缺省：
就是同一包内面可以访问
Example3-15参数的传递？
Dos下typejavacjavajavap：
反编译
Javadoc.java
Startindex.html
第四章：
继承和多态
如果要声明类B继承类A，则必须满足两个条件：
（1）类A非final；
（2）类A是public或类B与类A同包。
如果这两个条件满足则可按照以下的语法声明类B：
classBextendsA
{…..
}
在上述面向对象的基本概念基础之上，不可避免地要涉及到面向对象程序设计所具有的4个共同特征：
抽象性、封装性、继承性和多态性。
1．抽象
抽象是人们认识事物的常用方法，比如地图的绘制。
抽象的过程就是如何简化、概括所观察到的现实世界，并为人们所用的过程。
抽象是软件开发的基础。
软件开发离不开现实环境，但需要对信息细节进行提炼、抽象，找到事物的本质和重要属性。
抽象包括两个方面：
过程抽象和数据抽象。
过程抽象把一个系统按功能划分成若干个子系统，进行"
自顶向下逐步求精"
的程序设计。
数据抽象以数据为中心，把数据类型和施加在该类型对象上的操作作为一个整体（对象）来进行描述，形成抽象数据类型ADT。
所有编程语言的最终目的都是提供一种"
抽象"
方法。
一种较有争议的说法是：
解决问题的复杂程度直接取决于抽象的种类及质量。
其中，"
种类"
是指准备对什么进行"
。
汇编语言是对基础机器的少量抽象。
后来的许多"
命令式"
语言（如FORTRAN、BASIC和C）是对汇编语言的一种抽象。
与汇编语言相比，这些语言已有了较大的进步，但它们的抽象原理依然要求程序设计者着重考虑计算机的结构，而非考虑问题本身的结构。
在机器模型（位于"
方案空间"
）与实际解决的问题模型（位于"
问题空间"
）之间，程序员必须建立起一种联系。
这个过程要求人们付出较大的精力，而且由于它脱离了编程语言本身的范围，造成程序代码很难编写，而且要花较大的代价进行维护。
由此造成的副作用便是一门完善的"
编程方法"
学科。
为机器建模的另一个方法是为要解决的问题制作模型。
对一些早期语言来说，如LISP和APL，它们的做法是"
从不同的角度观察世界"
、"
所有问题都归纳为列表"
或"
所有问题都归纳为算法"
PROLOG则将所有问题都归纳为决策链。
对于这些语言，可以认为它们一部分是面向基于"
强制"
的编程，另一部分则是专为处理图形符号设计的。
每种方法都有自己特殊的用途，适合解决某一类的问题。
但只要超出了它们力所能及的范围，就会显得非常笨拙。
面向对象的程序设计在此基础上则跨出了一大步，程序员可利用一些工具来表达问题空间内的元素。
由于这种表达非常普遍，所以不必受限于特定类型的问题。
人们将问题空间中的元素以及它们在方案空间的表示物称作"
对象"
当然，还有一些在问题空间没有对应体的其他对象。
通过添加新的对象类型，程序可进行灵活的调整，以便与特定的问题配合。
所以在阅读方案的描述代码时，会读到对问题进行表达的话语。
与以前的方法相比，这无疑是一种更加灵活、更加强大的语言抽象方法。
总之，OOP允许人们根据问题，而不是根据方案来描述问题。
然而，仍有一个联系途径回到计算机。
每个对象都类似一台小计算机；
它们有自己的状态，而且可要求它们进行特定的操作。
与现实世界的"
或者"
物体"
相比，编程"
与它们也存在共通的地方：
它们都有自己的特征和行为。
2．封装
封装是面向对象编程的特征之一，也是类和对象的主要特征。
封装将数据以及加在这些数据上的操作组织在一起，成为有独立意义的构件。
外部无法直接访问这些封装了的数据，从而保证了这些数据的正确性。
如果这些数据发生了差错，也很容易以介绍面向对象编程的基本概念、基本理论为重点，结合Java语言的语法规则、编程特点和设计思想、强调容易发生错误和编程应注意的地方，使学生能对Java技术有一个总体了解，通过本课程学习，使学生掌握Java语言的基础知识，理解和掌握面向对象程序设计的基本思想，熟练地使用Java语言进行程序的编写、编译以及调试工作定位错误是由哪个操作引起的。
如果外部需要访问类里面的数据，就必须通过接口（Interface）进行访问。
接口规定了可对一个特定的对象发出哪些请求。
当然，必须在某个地方存在着一些代码，以便满足这些请求。
这些代码与那些隐藏起来的数据叫作"
隐藏的实现"
站在过程化程序编写（ProceduralProgramming）的角度，整个问题并不显得复杂。
一种类型含有与每种可能的请求关联起来的函数。
一旦向对象发出一个特定的请求，就会调用那个函数。
通常将这个过程总结为向对象"
发送一条消息"
（提出一个请求）。
对象的职责就是决定如何对这条消息作出反应（执行相应的代码）。
若任何人都能使用一个类的所有成员，那么可对这个类做任何事情，则没有办法强制他们遵守任何约束--所有东西都会暴露无遗。
有两方面的原因促使了类的编制者控制对成员的访问。
第一个原因是防止程序员接触他们不该接触的东西--通常是内部数据类型的设计思想。
若只是为了解决特定的问题，用户只需操作接口即可，无需明白这些信息。
类向用户提供的实际是一种服务，因为他们很容易就可看出哪些对自己非常重要，以及哪些可忽略不计。
进行访问控制的第二个原因是允许库设计人员修改内部结构，不用担心它会对客户程序员造成什么影响。
例如，编制者最开始可能设计了一个形式简单的类，以便简化开发。
以后又决定进行改写，使其更快地运行。
若接口与实现方法早已隔离开，并分别受到保护，就可放心做到这一点，只要求用户重新链接一下即可。
封装考虑的是内部实现，抽象考虑的是外部行为。
符合模块化的原则，使得软件的可维护性、扩充性大为改观。
3．继承
继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。
对象的一个新类可以从现有的类中派生，这个过程称为类的继承。
新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。
派生类可以从它的基类那里继承方法和实例变量，并且派生类可以修改或增加新的方法使之更适合特殊的需求。
这也体现了大自然中一般与特殊的关系。
继承性很好地解决了软件的可重用性问题。
比如说，所有的Windows应用程序都有一个窗口，它们可以看作都是从一个窗口类派生出来的。
但是有的应用程序用于文字处理，有的应用程序用于绘图，这是由于派生出了不同的子类，各个子类添加了不同的特性。
关于继承的详细讨论，将在第4.1～4.2节进行。
4．多态性
多态性是指允许不同类的对象对同一消息作出响应。
比如同样的加法，把两个时间加在一起和把两个整数加在一起肯定完全不同。
又比如，同样的选择"
编辑"
粘贴"
操作，在字处理程序和绘图程序中有不同的效果。
多态性包括参数化多态性和运行时多态性。
多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好地解决了应用程序函数同名问题。
关于多态性的讨论，将在4.7～4.9节进行。
最后，以AlanKay的话作为本节的结束语。
他总结了Smalltalk（这是第一种成功的面向对象程序设计语言，也是Java的基础语言）的五大基本特征。
通过这些特征，读者可以理解"
纯粹"
的面向对象程序设计方法。
（1）所有东西都是对象。
可将对象想象成一种新型变量，它保存着数据，但可要求它对自身进行操作。
理论上讲，可从要解决的问题上，提出所有概念性的组件，然后在程序中将其表达为一个对象。
（2）程序是一大堆对象的组合。
通过消息传递，各对象知道自己该做些什么。
为了向对象发出请求，需向那个对象"
更具体地讲，可将消息想象为一个调用请求，它调用的是从属于目标对象的一个子例程或函数。
（3）每个对象都有自己的存储空间，可容纳其他对象。
或者说，通过封装现有对象，可制作出新型对象。
所以，尽管对象的概念非常简单，但在程序中却可达到任意高的复杂程度。
（4）每个对象都有一种类型。
根据语法，每个对象都是某个"
类（Class）"
的一个"
实例"
类"
是"
类型（Type）"
的同义词。
一个类最重要的特征就是"
能将什么消息发给它？
（5）同一类所有对象都能接收相同的消息。
这实际是别有含义的一种说法，读者不久便能理解。
由于类型为"
圆（Circle）"
的一个对象也属于类型为"
形状（Shape）"
的一个对象，所以一个"
圆"
完全能接收"
形状"
的消息。
这意味着可让程序代码统一指挥"
，令其自动控制所有符合"
描述的对象，其中自然包括"
这一特性称为对象的"
可替换性"
，是OOP最重要的概念之一。
访问控制符的理解和练习
显示调用和隐式调用的含义：
This：
Super：
1.classA{
2.protecteddoubley=2.13;
3.}
4.classBextendsA{
5.inty=0;
6.voidg（）{
7.y=y+10;
8.System.out.printf（"
y=%d\n"
y）;
9.}
10.}
11.classExample{
12.publicstaticvoidmain（Stringargs[]）{
13.Bb=newB（）;
14.b.y=-20;
15.b.g（）;
16.}
17.}
断点调试此实例的执行过程。
多态的实质
1.基本类型：
inta=10;
longb=a;
a是32位，b是64位。
a拷贝的时候进行自动扩充，实现初始化语句两边的类型一致。
基本类型是通过传值引用来实现。
2.对象类型
对象变量的引用是按照传址来实现的，也就是说变量在传递的过程中传递的是对象变量（对象句柄）的拷贝，也就是内存地址的传递，而实际的对象并不会受到数据位的扩充和缩减，所以实际对象的内容存放在堆中是不会改变的。
见幻灯片类和对象内存的分配。
总结：
在父类总声明，并在子类中覆盖的方法，可以实现多态的调用，编译器和解释器都会找到正确的类型，也就调用对象的实际类型，但在父类中没有声明的方法，是不可以采用多态的形式调用的。
第八章：
多线程
创建线程的两种方法
创建新执行线程有两种方法。
一种方法是将类声明为Thread的子类。
该子类应重写Thread类的run方法。
接下来可以分配并启动该子类的实例。
例如，计算大于某一规定值的质数的线程可以写成：
classPrimeThreadextendsThread{
longminPrime;
PrimeThread（longminPrime）{
this.minPrime=minPrime;
publicvoidrun（）{
//computeprimeslargerthanminPrime
...
然后，下列代码会创建并启动一个线程：
PrimeThreadp=newPrimeThread（143）;
p.start（）;
创建线程的另一种方法是声明实现Runnable接口的类。
该类然后实现run方法。
然后可以分配该类的实例，在创建Thread时作为一个参数来传递并启动。
采用这种风格的同一个例子如下所示：
classPrimeRunimplementsRunnable{
longminPrime;
PrimeRun（longm
升级会员 