java综述

最新推荐文章于 2024-05-05 01:01:51 发布

西_北

最新推荐文章于 2024-05-05 01:01:51 发布

阅读量1.1k

点赞数

分类专栏：大学软件工程

本文链接：https://blog.csdn.net/xuan_xinya/article/details/8749486

版权

大学软件工程专栏收录该内容

156 篇文章 6 订阅

订阅专栏

JAVA概述：

1、一点历史：

Java1.0：Applet开发

Java1.1：加入嵌入式

Java2分流：

J2SE(Java 2 Platform,Standard Edition)

包含了JDK(Java Development Kit,Java开发工具包),Runtime(运行时)，API(Application Programming Interface)。

J2EE(Java 2 Platform,EnterPrise Edition)

包含了JSP(JavaServer Pages)，Servlet，EJB(Enterprise JavaBean)，JTS(Java Transaction Service)，JMS(Java Message Service)等。用于电子商务网站开发。

J2ME(Java 2 Platform,Micro Edition)，用于电子产品开发。

2、Java语言是一门面相对象的语言

Java是从C++衍生而来，跟C++语言风格相近。

Java略去了指针，结构体，联合体，goto，隐式类型转换，运算符重载，多重继承等概念。不需析构，因为有垃圾回收机制。

所有Java程序语言的设计都是为了实现传说中的简单，鲁棒(robust，健壮)，安全。

3、Write Once, Run Anywhere

JVM(Java虚拟机) 使得跨平台得以实现。

4、JDK的配置

参见JDK配置的步骤.doc

Java基础

一、八种基本类型

Java语言提供了八种基本类型。

六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

1、整型：包括int,short,byte,long

2、浮点型：float,double

3、字符型：char

4、布尔型：boolean

二、变量与常量（主要常变量）

变量

1)标识符：

1. 大小写有别，例如 a 和 A是两个变量（为区别与类与接口，首字母一般小写）

2. 长度任意

3. 可以任何字母开始，另外还可以以"_"和"$"开始，一般"$"是很多代码生成器用的，人工写出来的代码不鼓励"_" "$"

4. 除了第一个字符，后面可以跟任何字母，数字，_和$

2）关键字

abstract assert boolean break byte case catch char class const continue default do double else enum extends final finally float for if goto implements import instanceof int interface long native new package private protected public return short static strictfp super switch synchronized this throw throws transient try void volatile while

保留字const,goto

常量

1）字面常量，如'A' ,3.142f

2）自定义常量（常变量）

形如 final int const的 const即为常量

如 fianl int i = 0;

这样i被赋值一次，它也终究只能被赋值一次，以后它的值就会一直是0。

一个解释，可以这样记着它：一见钟情式... :)

三、运算符、表达式与语句

1）运算符

1、算术运算符（+ - * / % ++ --）

2、位运算符(& | ^ ~ >> <<)

3、赋值运算符（= ）

4、复合赋值运算符（1、3复合或 2、3复合）

5、关系运算符（> >= <= < == !=）

6、逻辑运算符（&& || !）

7、条件运算符（?:）

注意：Java中有两个运算符，也仅有两个运算符重载了：“+”与“+=”。(Java中不允许用户自定义操作符重载！！！)

2）表达式

1、算术表达式(形如：3*2+1)

2、条件表达式（形如：1+2！=4）

3）语句

1、注释

单行注释：//System.out.println();

多行注释：/* System.out.println();*/

文档注释：/**

*@ author 张三

2、方法调用

System.out.println();

3、表达式语句

3*2+1；

4、流程控制

选择（if...else... switch）

循环（for foreach while do...while...）

循环辅助语句

break（跳出去...）

continue（继续下去...）

注意：没有goto!!!

5、复合语句

...

｛

int a;

｛

Double b;

｝

Java类

面向对象的特性：封装、继承和多态。
类是对象的模板，对象是类的实例。

可以这样来理解，类就是个模子，对象就是模子中铸出来的一个东西。

类中有方法和属性。

Think：

啥叫方法（成员方法）？

啥叫属性（成员变量）？

方法：类里面的函数，Think again：这些函数又有什么用？

属性：类里面的数据，Think again：这些数据的作用有事什么？

类里面的函数（方法）用来操作属性，也就是作用于属性。

类里面的数据（属性）用来存放数值。

============================================================

类可以有构造方法（默认的有不带参数的构造方法）。------想想这算什么？

关键字：this

继承：

class A extends B{

........

}

子类中调用父类成员，super（关键字）

多态：

通过继承，一个类可以用作多种类型：可以用作它自己的类型、任何基类型，或者在实现接口时用作任何接口类型。这称为多态性。

重载、重写与覆盖的区别：

重载时相同名称成员的参数列表是不相同的（参数顺序和类型）。重载基本要求是它的方法名必须相同。其他都可以不同。完全就是一个新方法。

重写是对虚方法的实现。可以重新定义父方法的访问权限。

覆盖是所有都相同。是覆盖了父类的方法。

请记住：以上所有说法全部都是子类相对于父类来说的。

思考一下，封装性体现在哪里呢？为什么要封装呢？

Java常用类

数组（Array类）：

首先，要记得Java 数组是一个类。它内部有方法，有属性。

Java 中数组属于引用数据类型。

Java 中数组的初始化有两种方式，一种是直接赋值法，一种是用new操作符（类的特性体现）。

详情见：Java数组.doc

字符串（String类和StringBuffer类）：

Java 中使用String 和StringBuffer来完成字符串的各种操作。

他们也是类，类中也有方法和属性。

String类：

注意几点：

1、String类是final的，不可被继承。

2、String类是的本质是字符数组char[], 并且其值不可改变。

3、String类对象有个特殊的创建的方式，就是直接指定比如String x = "abc"，"abc"就表示一个字符串对象。而x是"abc"对象的地址，也叫做"abc"对象的引用。

4、String对象可以通过“+”串联。串联后会生成新的字符串。也可以通过concat()来串联。

创建字符串的方式很多，归纳起来有三类：
其一，使用new关键字创建字符串，比如String s1 = new String("abc");
其二，直接指定。比如String s2 = "abc";
其三，使用串联生成新的字符串。比如String s3 = "ab" + "c";

String类型是不可改变的，也就是说，当你想改变一个String对象的时候，比如

String name= "tom";

name= "madding";
那么虚拟机不会改变原来的对象，而是生成一个新的String对象，然后让name去指向它，如果原来的那个 "tom "没有任何对象去引用它，虚拟机的垃圾回收机制将接收它。
据说这样可以提高效率！！！

深入了解Java String 类的运行机制见：深入了解Java String 类.doc

思考一下：既然String 类是不可变更类（private），而事实上很多时候是要用同样的变量来表示不同的含义的，那么如何让一个字符串变量的属性可以变更呢（此变更非彼变更，类似于上述所讲的变更）？

显而易见的办法是用“+”串联或者用concat()方法。

可是如果一个字符串频繁变更，这样做就会导致大量的字符串对象的生成与销毁，性能就会大大降低。为此，Java 提供了一种解决方法：StringBuffer类

StringBuffer类：

StringBuffer是可变的，串接时不会创建新的对象。

创建：

StringBuffer sb= new StringBufffer();

sb.append("hello");

sb.append("world");

提一下一个比较特别的类：Object类。

Object 类是所有类的父类。

toString()方法返回：类名@[此对象哈希码的无符号十六进制表示]，通常自定义的类会覆盖掉toString()。

深入了解Java String 类

要理解 java中String的运作方式，必须明确一点：String是一个非可变类（immutable）。什么是非可变类呢？简单说来，非可变类的实例是不能被修改的，每个实例中包含的信息都必须在该实例创建的时候就提供出来，并且在对象的整个生存周期内固定不变。java为什么要把String设计为非可变类呢？你可以问问 james Gosling ：）。但是非可变类确实有着自身的优势，如状态单一，对象简单，便于维护。其次，该类对象对象本质上是线程安全的，不要求同步。此外用户可以共享非可变对象，甚至可以共享它们的内部信息。（详见《Effective java》item 13）。String类在java中被大量运用，甚至在class文件中都有其身影，因此将其设计为简单轻便的非可变类是比较合适的。

一、创建。
好了，知道String是非可变类以后，我们可以进一步了解String的构造方式了。创建一个Stirng对象，主要就有以下两种方式：
java 代码

1. String str1 = new String("abc");

2. Stirng str2 = "abc";

虽然两个语句都是返回一个String对象的引用，但是jvm对两者的处理方式是不一样的。对于第一种，jvm会马上在heap中创建一个String对象，然后将该对象的引用返回给用户。对于第二种，jvm首先会在内部维护的strings pool中通过String的 equals 方法查找是对象池中是否存放有该String对象，如果有，则返回已有的String对象给用户，而不会在heap中重新创建一个新的String对象；如果对象池中没有该String对象，jvm则在heap中创建新的String对象，将其引用返回给用户，同时将该引用添加至strings pool中。注意：使用第一种方法创建对象时，jvm是不会主动把该对象放到strings pool里面的，除非程序调用 String的intern方法。看下面的例子：
java 代码

1. String str1 = new String("abc"); //jvm 在堆上创建一个String对象

3. //jvm 在strings pool中找不到值为“abc”的字符串，因此

4. //在堆上创建一个String对象，并将该对象的引用加入至strings pool中

5. //此时堆上有两个String对象

6. Stirng str2 = "abc";

8. if(str1 == str2){

9. System.out.println("str1 == str2");

10. }else{

11. System.out.println("str1 != str2");

12. }

13. //打印结果是 str1 != str2,因为它们是堆上两个不同的对象

14.

15. String str3 = "abc";

16. //此时，jvm发现strings pool中已有“abc”对象了，因为“abc”equals “abc”

17. //因此直接返回str2指向的对象给str3，也就是说str2和str3是指向同一个对象的引用

18. if(str2 == str3){

19. System.out.println("str2 == str3");

20. }else{

21. System.out.println("str2 != str3");

22. }

23. //打印结果为 str2 == str3

再看下面的例子：

java 代码

1. String str1 = new String("abc"); //jvm 在堆上创建一个String对象

3. str1 = str1.intern();

4. //程序显式将str1放到strings pool中，intern运行过程是这样的：首先查看strings pool

5. //有没“abc”对象的引用，没有，则在堆中新建一个对象，然后将新对象的引用加入至

6. //strings pool中。执行完该语句后，str1原来指向的String对象已经成为垃圾对象了，随时会

7. //被GC收集。

9. //此时，jvm发现strings pool中已有“abc”对象了，因为“abc”equels “abc”

10. //因此直接返回str1指向的对象给str2，也就是说str2和str1引用着同一个对象，

11. //此时，堆上的有效对象只有一个。

12. Stirng str2 = "abc";

13.

14. if(str1 == str2){

15. System.out.println("str1 == str2");

16. }else{

17. System.out.println("str1 != str2");

18. }

19. //打印结果是 str1 == str2

20.

    为什么jvm可以这样处理String对象呢？就是因为String的非可变性。既然所引用的对象一旦创建就永不更改，那么多个引用共用一个对象时互不影响。

二、串接（Concatenation）。
     java程序员应该都知道滥用String的串接操作符是会影响程序的性能的。性能问题从何而来呢？归根结底就是String类的非可变性。既然String对象都是非可变的，也就是对象一旦创建了就不能够改变其内在状态了，但是串接操作明显是要增长字符串的，也就是要改变String的内部状态，两者出现了矛盾。怎么办呢？要维护String的非可变性，只好在串接完成后新建一个String 对象来表示新产生的字符串了。也就是说，每一次执行串接操作都会导致新对象的产生，如果串接操作执行很频繁，就会导致大量对象的创建，性能问题也就随之而来了。
    为了解决这个问题，jdk为String类提供了一个可变的配套类，StringBuffer。使用StringBuffer对象，由于该类是可变的，串接时仅仅时改变了内部数据结构，而不会创建新的对象，因此性能上有很大的提高。针对单线程，jdk 5.0还提供了StringBuilder类，在单线程环境下，由于不用考虑同步问题，使用该类使性能得到进一步的提高。

三、String的长度
   我们可以使用串接操作符得到一个长度更长的字符串，那么，String对象最多能容纳多少字符呢？查看String的源代码我们可以得知类String中是使用域 count 来记录对象字符的数量，而count 的类型为 int，因此，我们可以推测最长的长度为 2^32，也就是4G。
    不过，我们在编写源代码的时候，如果使用 Sting str = "aaaa";的形式定义一个字符串，那么双引号里面的ASCII字符最多只能有 65534 个。为什么呢？因为在class文件的规范中， CONSTANT_Utf8_info表中使用一个16位的无符号整数来记录字符串的长度的，最多能表示 65536个字节，而java class 文件是使用一种变体UTF-8格式来存放字符的，null值使用两个字节来表示，因此只剩下 65536－ 2 ＝ 65534个字节。也正是变体UTF-8的原因，如果字符串中含有中文等非ASCII字符，那么双引号中字符的数量会更少（一个中文字符占用三个字节）。如果超出这个数量，在编译的时候编译器会报错。

Java数组

3）一维数组

1、一维数组的定义

type arrayName[];

其中类型(type)可以为Java中任意的数据类型，包括简单类型组合类型，数组名arrayName为一个合法的标识符，[]指明该变量是一个数组类型变量。例如：

int intArray[];

声明了一个整型数组，数组中的每个元素为整型数据。与C、C++不同，Java在数组的定义中并不为数组元素分配内存，因此[]中不用指出数组中元素个数，即数组长度，而且对于如上定义的一个数组是不能访问它的任何元素的。我们必须为它分配内存空间，这时要用到运算符new，其格式如下：

arrayName=new type[arraySize];

其中，arraySize指明数组的长度。如：

IntArray=new int[3];

为一个整型数组分配3个int型整数所占据的内存空间。

通常，这两部分可以合在一起，格式如下：

type arrayName=new type[arraySize];

例如：

int intArray = new int[3];

2、一维数组元素的引用

定义了一个数组，并用运算符new为它分配了内存空间后，就可以引用数组中的每一个元素了。数组元素的引用方式为：

arrayName[index]

其中：index为数组下标，它可以为整型常数或表达式。如a[3]，b[i](i为整型)，c[6*I]等。下标从0开始，一直到数组的长度减1。对于上面例子中的in-tArray数来说，它有3个元素，分别为：

intArray[0]，intArray[1]，intArray[2]。注意：没有intArray[3]。

另外，与C、C++中不同，Java对数组元素要进行越界检查以保证安全性。同时，对于每个数组都有一个属性length指明它的长度，例如：intArray.length指明数组intArray的长度。

3、一维数组的初始化

对数组元素可以按照上述的例子进行赋值。也可以在定义数组的同时进行初始化。

例如：

int a[]={1，2，3，4，5};

用逗号(，)分隔数组的各个元素，系统自动为数组分配一定空间。

与C中不同，这时Java不要求数组为静态(static)。

二、二维数组

1、二维数组的定义：

type arrayName[][];

例如：

int intArray[][];

与一维数组一样，这时对数组元素也没有分配内存空间，同要使用运算符new来分配内存，然后才可以访问每个元素。

对高维数组来说，分配内存空间有下面几种方法：

1）直接为每一维分配空间，如：

int a[][]=new int[2][3];

2）从最高维开始，分别为每一维分配空间，如：

int a[][]=new int[2][];

a[0]=new int[3];

a[1]=new int[3];

完成1中相同的功能。这一点与C、C++是不同的，在C、C++中必须一次指明每一维的长度。

2、二维数组元素的引用

对二维数组中每个元素，引用方式为：arrayName[index1][index2] 其中index1、index2为下标，可为整型常数或表达式，如a[2][3]等，同样，每一维的下标都从0开始。

3、二维数组的初始化

有两种方式：

1、直接对每个元素进行赋值。

2、在定义数组的同时进行初始化。

如：int a[][]={{2，3}，{1，5}，{3，4}};

定义了一个3×2的数组，并对每个元素赋值。

知识:

I/O操作 I /O流 Java文件操作

数据库及数据库基本操作 JDBC

多线程网络编程（Socket TCP/IP）

Java集合类 Collection接口 List Set Map的用法

附件：

1.Java命名规则

命名是尽量按以下约定，以显的你更加专业

1．使用完整描述符来准确地描述变量、字段或类。

例如，使用的名称可以是 FirstName、GrandTotal 或 Corporate Customer。虽然像 x1、y1 或 fn 这样的名称较短轻易输入，但是它们并不提供任何信息指出它们所代表的内容。这样对代码的理解、维护和增强会造成一定困难。

2．使用适用于领域内的术语。

假如您的用户将他们的客户称为顾客，则对这个类使用术语Customer来代替Client。许多开发人员曾经犯了这样一个错误：当业界或领域中已存在更贴切的术语时，他们还冥思苦想，预备为一些概念创建通用术语。

3．巧妙节俭地使用缩写。

这表示您应该维护一份标准短格式（缩写）的列表，应该明智地选择它们，并在使用时保持一贯性。例如，假如要使用字 arithmetic 的短格式，选择 ar、ari 或 art 中的一个，记录下所选的缩写（到底是哪个并不重要），并只使用这一个。

4．使用大小写混合增强名称的可读性。

通常应该使用小写字母，但是将类名和接口名称的第一个字母写成大写，将所有非起始单词的第一个字母也写成大写。

5．将标准首字母缩写词的第一个字母大写。

名称会经常包含标准缩写，如 SQL 表示“Standard Query Language”。诸如表示属性的 sqlDatabase 或表示类的 SQLDatabase 等名称比sQLDatabase 和sqlDatabase 更便于阅读。

6．避免长型名称（最大 15 个字符比较合适）。

虽然类名 AllImplemented 、IterfacesAndSubclass 可能是个比较好的类名（当然，在此示例中有些夸张），但是这个名称显然太长，应该把它重命名为较短的名称才好。

7．避免名称过于相似或仅在大小写方面有区别。

不应该同时使用变量名 myObject 和 myObjects，也不应该同时使用 myOraDatabase 和 anORADatabase。

2.如何使用搜索引擎：

1.选择关键字：只有选择了正确的关键字，才能找到准确的搜索结果

2.使用精准搜索：很多搜索引擎都提供精准搜索

Google,百度提供的精准搜索：

http://www.google.cn/advanced_search

http://www.baidu.com/gaoji/advanced.html

3.学会使用高级搜索语句：

——把搜索范围限定在网页标题中——intitle

网页标题通常是对网页内容提纲挈领式的归纳。把查询内容范围限定在网页标题中，有时能获得良好的效果。使用方法：把查询内容中，特别关键的部分，用“intitle:”|领起来。

例如，找林青霞的写真，就可以这样查询：写真 intitle:林青霞

注意：intitle：和后面的关键词之间，不要有空格。

——把搜索范围限定在特定站点中——site

有时候，您知道某个站点中有自己需要找的东西，就可以把搜索范围限定在这个站点中，提高查询效率。使用方法：在查询内容的后面加上“site:站点域名”。

例如，天空网下载软件不错，就可以这样查询；msn site:skycn.com

注意:“site:”后面跟的站点域名，不要带“http://”；另外，site:和站点名之间不要带空格。

——把搜索范围限定在URL链接中——inurl

网页url中的某些信息，常常有某种有价值的含义。于是，您如果对搜索结果的url做出某种限定，就可以获得良好的效果。使用方法：用“inurl:”，后跟需要在url中出现的关键词。

例如，找关于photoshop的使用技巧，可以这样查询：photoshop inurl:jiqiao

上面这个查询串中的“photoshop”，是可以出现在网页的任何位置，而“jiqiao”则必须出现在网页url中。

注意:inurl:语法和后面所跟的关键词，不要有空格。

——精确匹配——双引号和书名号

如果输入的查询词很长，搜索引擎在经过分析后，给出的搜索结果中的查询词可能是拆分的。如果您对这种情况不满意，可以尝试让搜索引擎不拆分查询词。给查询词加上双引号，就可以达到这种效果。

例如，搜索上海科技大学，如果不加双引号，搜索结果被拆分，效果不是很好，但加上双引号后，“上海科技大学”，获得的结果就全是符合要求的了。

书名号是搜索引擎独有的一个特殊的查询语法。在搜索引擎中，中文书名号是可以被查询的。加上书名号的查询词，有两层特殊功能，一是书名号会出现在搜索结果中；二是被书名号括起来的内容不会被拆分。书名号在某些情况下特别有效果，例如，查询名字很通俗和常用的那些电影或者小说。比如搜索电影“手机”，如果不加书名号，很多情况下出来的是通讯工具——手机，而加上书名号后，《手机》结果就都是关于电影方面的了。

——减除无关资料

如果要避免搜索某个词语，可以在这个词的前面加上一个减号（“-”，英文字符）。

但在减号之前必须留一空格。

也就是说，您发现搜索结果中，有某一类网页是您不希望看见的，而且这些网页都包含特定的关键词，那么用减号语法，就可以去除所有这些含有特定关键词的网页。

例如，搜神雕侠侣，希望是找关于武侠小说方面的内容，却发现很多关于电视剧方面的网页。那么就可以这样查询：神雕侠侣 – 电视剧

注意：前一个关键词，和减号之间必须有空格，否则减号会被当成连字符处理，而失去减号语法功能。减号和后一个关键词之间，有无空格均可。

——利用搜索引擎查找文档：

很多有价值的资料，在互联网上并非是普通的网页，而是以word，powerpoint，PDF等格式存在。百度支持对Office文档（包括word，Excel,Powerpoint）,Adobd,PDF文档，RTF文档进行了全文搜索。要搜索这类文档，很简单，在普通的查询词后面加上一个“filetype:”文档类型限定。“filetype:”后可以跟以下文件格式：DOC,XLS,PPT,PDF,RTF,ALL.其中，ALL表示搜索所有这些文件类型。