传智博客JAVA基础第十四天

工欲善其事必先利其器。

为了提高Java程序的开发效率。

现在介绍一下Eclipse。

了解就行。

1：Eclipse的介绍

(1)eclipse的由来

A：由IBM一个小组开发。

(2)eclipse的特点

A：完全由Java语言编写的工具。

B：不需要安装

C：免费的，eclipse.org

D：开源的

E：扩展性非常强

(3)eclipse和MyEclipse的区别

A：MyEclipse是基于eclipse加入了一些用于开发Web的插件

   并对这些自己开发的插件进行收费。

B：特点 MyEclipse集成性很好。收费。

(4)在使用eclipse之前，系统中必须要先有JDK或者JRE。

因为eclipse就是用Java语言编写的程序，所以需要jvm的解释执行。

A：对于高版本的MyEclipse，内部已经集成了JDK。

   所以安装后，它会用自己的JDK来执行MyEclipse。

(5)Eclipse的安装与汉化 重点

A：解压即可。

B：汉化的方式：

**直接解压，并覆盖即可。但是不建议这样做，这样做的，如果我不想汉化，想还原起来就麻烦了。

**步骤如下：

***在eclipse目录下建立文件夹links

***在links下面建立一个文件名字任意。比如 cn.txt

***在cn.txt中写如下内容(根据你插件包的位置而定)

path=D:\\develop\\eclipse_CN\\eclipse

***启动或者重新启动eclipse。

C：可以检查是否插件是否成功

D:\develop\eclipse\configuration\org.eclipse.update\platform.xml

中有一行：

<site enabled="true" policy="USER-EXCLUDE" updateable="true" url="file:../eclipse_CN/eclipse/">

插件说完了。我们来玩一下Eclipse。建议玩英文的。

你可以有两个。一个挂中文，一个英文。

可以对照着看。

2：Eclipse的组成

整体叫做视图，没一个小玩意叫做视窗。

在eclipse中要想爽一下，必须先有项目(工程)。

(1)视图，视窗

(2)视图就是某些视窗的组合。

A：Java视图

B：Debug视图

C：JavaEE视图

(3)视图还原

在视图操作中，我有可能有误操作。这个时候怎么办？

Window--Reset重置视图

3：Java透视图

(1)Package Explorer 包资源管理器

A：该视图中显示当前工作空间中的所有项目以及项目中的文件。

   但不显示项目下bin目录中的运行文件。

B：可以直接在该视图中创建项目，包，类，接口等。

(2)Outline 大纲视窗

A：该视图中显示当前代码视图中源文件中定义的类或者接口。

   以及定义的所有成员。

B：当代码过长时，查找代码中的某一个类或者成员，在该视窗中

   是最方便的。

C：在代码中出现多次的名称要同一更改，也可以在该视窗中完成。

   同时其他代码如果使用了该变量，那么也会一并改变。

(3)Console 控制台视窗

A：用于显示程序的运行结果，相当于DOS命令。

B：如果有多个控制台同时运行。比如：服务器端和客户端。

   可以通过控制台上的小屏幕按钮进行控制台的切换。

C：通过点击小方框，进行控制台的强制停止，相当于DOS中的Ctrl+C。

(4)Hierarchy 层次视窗

A：用于显示类之间的层次(继承)关系。

B：在当前类上，按F4就可以切换到该视窗，并查看层次关系。

查看原码，当前类上F3，或者Ctrl+鼠标点击

4：对工作空间进行基本配置

注意：在工作空间的设置对于该空间中的所有项目都有效。

      更换了工作空间，需要重新设置。

(1)配置Java的编译和运行环境版本

windows--perference-Java

|--Compiler 设置成5.0以上，要和运行环境版本一致。

|--Installed JREs：可以指定多个jre环境，但是仅有一个是当前执行的。

   要和编译器一致，或者高于编译器版本。

如果采用高版本编译，用低版本jre运行，会出现异常。

(2)代码视窗加上行号。

A：首选项--常规--编辑器--文本编辑器

B：在当前类中，左侧，右键。Show Line Numbers

(3)调整字体

windows--perference-General--Appearance--Color and Fonts

右边选择Java。编辑即可。

字体选择 Courier New 比较标准，个人爱好

(4)取消悬浮提示

在首选项设置面板中

Java--Editor--Hovers。

右边将Combined Hover勾去掉。

这样代码的悬浮框就不会自动出现了。

如果想看提示，将光标悬浮在代码上，按F2即可。

(5)取消默认注释

在首选项设置面板中

Java--Code Style--Code Templates

右边选择Code，将不希望出现默认注释的代码块中的注释去掉。

5：常用的提高开发的操作

(1)创建面板 定义类和接口，权限，父类已经实现的接口等。

回车 到行首

shift+回车 到下行的行首

syso:然后alt+/就能出现输出语句

main:然后alt+/就能出主方法

自己也可以定义。sop：

步骤:windows--perference-Java-Editor-Templates--New

(2)常用的快捷键 (A,E,F必须掌握)

A：alt+/ 内容辅助键 这个功能很酷啊."酷就一个字，我只说一次"

补充类或者接口名，帮我们起变量名，new 后面直接提示等。

B：ctrl+/ 单行注释，在按一次，取消单行注释

C：ctrl+shift+/ 对选中的区域进行多行注释的封装

D：ctrl+shift+\ 用于取消多行注释，只要光标在多行注释中即可

E：ctrl+shift+o 对使用了其他包中的类或者接口进行自动导入

F：ctrl+shift+f 对代码进行格式化

G：alt+上键 向上移动当前行或者选中行

H：alt+下键 向下移动当前行或者选中行

I：ctrl+d 删除当前行，或者删除选中行

J：ctrl+shift+x 将选中部分的字母大写

K：ctrl+shift+y 将选中部分的字母小写

L：ctrl+1 光标放在编译中出现红色波浪线提示的内容上，

   在该快捷键可以获取建议的处理方式

M：F3 可以查看类或者方法的源码，前提是，该原码已经关联。

6：代码生成的快捷键

出现source

1：在区域中右键

2：alt+shift+s

(1)私有字段的get/set 重点

(2)构造方法 

(3)重写父类方法 重点

@Override 注解 表明此方法是重写父类的.

(4)添加注释 /** 回车

(5)方法的重构 

右键--refactor--Extract Method

int sum = a + b;

System.out.println(sum);

选中a+b 扩展可以生成带返回值的。

(6)将方法抽取到类或者接口中

Refactor--Extract Superclass

Refactor--Extract Interface

7：Debug 调试程序

注释找错误

输出打印调试程序

程序不是写出来的,是改出来的.

(1)让我们调试程序更加方便

(2)想要调试，需要在程序中加入断点

(3)运行debug as，打开debug视图

(4)快捷键

f5:跳入

f6:跳过

f7:跳出

drop to frame 调到方法的第一行

(5)清除断点

在Breakpoints视窗中清除指定断点或者所有断点。

8：打jar包，导入jar包，及jar包的使用。

生成doc文档说明书:

选中项目--右键--Export--Java--javadoc--next--finish.

1：打jar包。

选中项目--右键--Export--Java--jar--next--自己写jar包的名字和选择路径--finish.

2:jar包的使用。

导入jar包

1:单独添加jar，

把jar复制,然后粘贴到项目路径下

一定要把jar添加至classpath路径中.

怎么添加呢?

右键jar包--添加构建路径 项目下：.classpath文件中可以看到

如果你给你一个项目,添加了jar,并且添加至了构建路径中,

这个时候,你又把jar包删除了,项目就会有红色标示,认为它的jar丢失了.

这个时候,两种解决方案:

A:重新添加你添加过jar包

B:如果,这写jar包真是不用了,那么,就从构建路径中把jar包移除.

**选中项目--右键--首选项--Java Build Path--library--选中其中的jar包,给remove.

2:为了方便管理多个jar包。

通常建立一个目录，名字建立定义为lib。

将jar都存放在该目录下

如果要使用jar包，只要将该jar导入到eclipse的classpath路径下。

右键至添加构建路径 项目下：.classpath文件中可以看到

9：导入已有的项目

空白区域--右键--import--General--Existing Project into Workspace--选中你的项目目录--finish--OK

   

   删除项目中有两种。

选中和不选中删除硬盘上的项目.

请不要选中删除硬盘上的项目。

Eclipse下改Console的内容.

10:window/preferences/General/Editors/TextEditors/右下角的colors and fonts/找Debug/console font 双击修改即可

知识回顾

第一部分：java的基础知识：必会的。

day01:

1：安装卸载JDK

2：配置path环境变量

3：第一个HelloWorld案例

4：关键字

java中的所有的关键字都是小写的。

byte,short,int,long,float,double,char,boolean,true,false,null

public,protected,private,new,void

static,final,abstract

class,interface

extends,implements

this,super

if,else,switch,case,default,for,do,while,break,continue,return

throw,throws,try,catch,finally

package,import

instanceof,synchronized

goto,const保留未被使用。

5：标识符

6：注释

单行：//

多行：/*  */

文档注释：/** */

注释是给人看到。用于解释说明程序的。

day02:

1：变量

数据类型 变量名 = 初始化值;

当你要操作的数据是不确定的时候，需要用变量。

0??表示的是8进制的, 0-7

??表示的是10进制的, 0-9

0x??表示的是16进制的, 0-9,a-f(大小写都行)

2：数据类型

引用类型：类，接口，数组

基本类型：4类8种

整型：byte,short,int,long

浮点型：float,double

字符型：char

布尔型：boolean

注意：整型默认是int，浮点型默认是double

      long类型用L或者l标识，float类型用F或者f标识。

运算过程中的类型转换：

boolean类型不参与运算

byte,short,char -- int -- long -- float -- double

隐式转换：从小到大

强制转换：从大到小，可能损失精度。

3：运算符

算数运算符：+,-,*,/,%,++,--

赋值运算符：=,+=,-=,*=,/=,%=

逻辑运算符：&,|,!,^,&&,||

比较运算符：>,<,==,>=,<=,!=

位运算符：

三元运算符：表达式?值1:值2

4：练习

面试题：

+=有自动转换功能

short s = 1;

s = s + 1;

short s = 1;

s+=1;

最有效率的2乘以8。

2<<3

两个数据的交换。

开发常用：

int a = 10;

int b = 20;

int temp = a;

a = b;

b = temp;

面试用：

a = a^b;  //a^b

b = a^b;  //a^b^b  b=a;

a = a^b;  //a^b^a  a=b;

day03：

表达式:用运算符连接起来的式子就是表达式。

1:if

if(条件表达式){}

条件表达式无论是简单还是复杂，结果是boolean类型。

if(条件表达式){}

else{}

if(条件表达式){}

else if(条件表达式){}

else if(条件表达式){}...

else {}

else后面没有if的时候，该行是没有条件表达式的。

2:switch

switch(表达式)

{

case 值1:

语句1;

break;

case 值2:

语句1;

break;

case 值3:

语句1;

break;

default:

语句n;

break;

}

表达式运算后的结果是:byte,short,int,char。

JDK5以后可以用枚举。

JDK7以后可以用String。

每个语句后的break最好写上，否则程序有可能出现意外。最后一个是可以不写的。

switch语句的结束：当遇到break或者程序执行到末尾了。

3:循环

while

while(条件表达式)

{

}

do...while

do{

}while(条件表达式);

for

for(初始化表达式;条件表达式;增量表达式)

{

}

while和for可以相互转换。

do...while和其他两种的区别在于它至少执行一次循环体。

4:其他的

continue:结束本次循环，进入下一次。

break:结束当前循环。

return:返回，程序不往下执行。

day04：

1：函数 实现一个特定功能的代码。

函数的格式：

修饰符 返回类型 方法名(参数列表...)

{

方法体;(就是实现这个功能的逻辑代码)

return 返回值;

}

权限修饰符：

本类  同一个包中(包括子类) 不同包中的子类 不同包中

private： OK

默认 OK OK

protected OK OK OK

public Ok Ok OK    OK

修饰符：权限修饰符

返回类型：功能的返回值的数据类型

方法名：方便调用

参数列表：

实际参数：就是实际参与运算的值

形式参数：接收实际参数的变量

方法体：就是实现这个功能的逻辑代码

return 返回值：把功能的结果返回。

特殊：如果一个功能没有返回值，用void。

2：数组

存储同一种数据类型的集合。

定义数组：

一维数组：

int[] arr = new int[3];

//int arr[] = new int[3];

int[] arr = new int[]{1,2,3};

int[] arr = {1,2,3};

二维数组：行和列

int[][] arr = new int[2][3]; //规则的矩阵

int[][] arr = new int[2][];  //不规则的矩阵

int[][] arr = {{1,2,3},{4,5,6,7},{8,9}};

数组中的元素是带编号。

数组的操作的离不开索引。

数组还有一个属性：length

用法：数组名.length 数组的长度

数组的功能：

遍历

获取最值

排序

选择排序

冒泡排序

查找

普通查找

二分查找

第二部分：面向对象，理解思想。封装，继承，多态。

面向对象：

1：类和对象：

类：同一种类型的对象的描述。

对象：实际的，具体的存在的个体

能够描述一个现实生活中的事物。

而这个事物通过java语言的描述就是类来体现的。

事物：属性和行为来描述

举例：手机事物

属性：颜色，重量，价格

行为：打电话，发短信，玩游戏

你要把这个事物用类来体系。

事物  --  类的转换

属性  --  成员变量

行为  --  成员方法

class Phone

{

private String color;

private double height;

private int price;

//打电话的功能

public void call(String name)

{

sop("给"+name+"打电话");

}

//群发短信

public void sendMessage()

{

sop("群发短信");

}

//玩游戏

public int play()

{

sop("完竞技游戏,挣了500");

reutrn 500;

}

}

2:封装 隐藏实现细节，提供公共的访问方式。

体现：类中的成员变量私有化，提供公共的get/set方法。

3:继承

类与类的关系。某个类继承了一个类，就拥有了这个类中除私有的内容。

继承的出现：

class A

{

void show(){sop("show")}

}

class B

{

void show(){sop("show")}

}

发现代码重复度很高。我们就把这些重复的代码写到一个类中。

然后，让A类和B类与这个类产生一个关系，以此来简写很多代码。

那么，这个关系就是继承。

class C

{

void show(){sop("show")}

}

class A extends C{}

class B extends C{}

抽象类：

class A

{

void show(){sop("show A")}

}

class B

{

void show(){sop("show B")}

}

上面的类中方法声明一样，方法体不一样。

我们就把声明进行抽取。让继承的类自己去实现方法体。

abstract class C

{

public abstract void show();

public void method(){}

}

class A extends C

{

public void show(){sop("show A")}

}

class B extends C

{

public void show(){sop("show B")}

}

当某个类继承抽象类的时候，一定要实现里面的抽象方法。

在一个继承体系中，如果有些操作是必须要做的，而且每种子类实现的时候

是不一样的，这个时候，我们就可以采用抽象类来解决这个问题。

接口：当一个抽象类中的方法全部都是抽象的时候，我们把该类用接口表示。

interface C

{

public abstract void show();

public abstract void method();

}

class A implements C

{

public void show(){sop("show A")}

}

class B implements C

{

public void show(){sop("show B")}

}

抽象类和接口的区别：

抽象类：

成员变量：可以使常量，也可以是变量。

成员方法：可以使抽象的，也可以是非抽象的。

构造方法：可以有。用于子类实例化使用。

接口：

成员变量：全部是常量。默认修饰符 public static final

成员方法：必须是抽象的。

设计理念：

类被继承：体现的是”is a“的关系。基类定义的是这个体系的共性内容。

接口被实现：体现的是”like a“的关系。定义的是体系的扩张功能。

关系：

类和类：是继承关系，而且是单继承。

类和接口：是实现关系，可以多实现。

  类可以在继承一个类的同时，实现多个接口。

接口和接口：是继承关系，可以单继承，也可以多继承。

4：多态

事物在不同时刻的多种状态。

动物 dw = new 猫();

猫 m = new 猫();

生活中：水的状态(气态，液态，固态)

向上转型和向下转型。

Fu f = new Zi();  //多态，向上转型

f.show();

Zi z = (Zi)f;    //向下转型

举例：

孔子爹：教课("java");

孔子:教课("论语"),玩游戏();

//多态

孔子爹 k爹 = new 孔子(); //向上转型。孔子穿上爹的衣服，带上眼睛。

k爹.教课();  //"论语"

//k爹.玩游戏();

孔子 k = (孔子)k爹;  //向下转型。把衣服一脱，就开始玩游戏。

k.玩游戏();

k.教课(); //论语

5：this

   super

   匿名对象

   Person p = new Person();

   p.show();

   new Person().show();

   匿名内部类

   new 父类名或者接口名(){

//重写父类方法，或者实现接口的方法

   }

异常：

理解异常的处理机制。

1：处理 try...catch...finally

2：抛出 throw,throws

throws是放在方法声明上，后面跟的是异常的名称

throw是出现在方法体中，后面跟的是异常的对象

能try就try。

只要不在主方法上throws就OK了。

面试题：

finally的应用。永远被执行，特殊情况：退出jvm。

try{

sop("hehe");

sop(10/0);

sop("heihei");

}catch(Exception e)

{

e.printStackTrace();

return;

}

finally{

sop("haha");

}

sop("over");

结果是：hehe

        haha

第三部分：多线程(了解原理就OK了)

1:实现多线程方式有几种。

继承Thread类

实现Runnable接口

2:启动一个线程是调用start方法，还是run方法呢？

start方法。

start方法的调用做了两件事情：启动线程，调用run方法。

3:线程安全的问题如何解决

A:同步：同步代码块，同步方法。

B:notify和wait的结合。

了解内容：将来可能会被面试到

4:死锁问题

5:线程间通信问题

单例设计模式：懒汉式会有线程安全问题。怎么解决呢？

class Demo

{

private Demo(){}

private static Demo d = null;

public synchronized static Demo getInstance()

{

if(d==null)  //第一个线程来了，第二个线程来了，

{

//第一个线程进来了，然后睡眠

//第二个线程来了，

d = new Demo();

}

return d;

}

}