java语言

第一章 Java 语言基础知识

1.1 Java语言与面向对象的程序设计

1.1.1 java-----建立在网络上的软件系统（分布式系统），面向对象

1.1.2 面向对象（客观事物）的思想

将客观事物看作具有状态和行为的对象，通过抽象找出同一类对象的共同状态和行为，构成类。

1.1.3 定义class类（状态和行为）

class Car {
//状态
    int color_number;  
    int door_number;
    int speed;
    ……
//行为
    void brake() { … }
    void speedUp() {…};
    void slowDown() { …  }；
	……
}  

1.1.3面向对象语言的基本特征

• 抽象和封装
• 继承性
• 多态性

1.1.2 Java语言的特点

①面向对象

②安全性

Java不支持指针
Java的内部安全措施

③平台无关性

一出编写多出运行，编译后的字节码对应于Java虚拟机，因此可在不同平台上运行
多线程
Java是第一个在语言级提供内至多线程支持的高级语言，简化了多线程程序编写。

④内存管理

Java对内存自动进行管理并进行垃圾回收

1.1.3 Java类

• 组成Java程序的最小单位是类，类封装了数据与处理数据的方法。

1.2 Java程序概述

1.2.1 Java 程序由Java虚拟机程序执行

1.2.2 java开发工具包

JDK 6是目前比较常用的java开发工具包。
JDK中部分常用工具包括

①Javac.exe:

Java编译器，用来将java程序编译成字节码，即将.java文件编译成.class文件。

②Java.exe：

Java解释器，用于解释执行Java字节码，即接受.class文件，然后启动Java虚拟机解释并执行。

③Jdb：

Java调试器， 用来调试java程序。

④Javap：

反编译，将类文件还原回方法和变量。

⑤Javadoc.exe：

文档生成器,创建HTML文件。

⑥Appletviwer.exe：

Applet解释器, 用来解释已经转换成字节码的java小应用程序。

1.2.3 java的程序概述

运行在客户端Java虚拟机上的Java程序

可在客户端机器中读写
可使用自己的主窗口、标题栏和菜单
程序可大可小
能够以命令行方式运行
主类必须有一个主方法main()，作为程序运行的入口。

public class MyClass{  
 private int val1,val2 ;
	public void myFun(int x,int y)
     {
	    val1=x ;
	    val2=y ;
	    System.out.println("The sum is: "+(val1+val2)) ; 
	} 
	public static void main(String arg[])
	{
	    MyClass MyObj=new MyClass();
	    MyObj.myFun(1,2);
	}
}

1.2.4 包

包的定义：

package 包名;

1.2.5 小应用程序（浏览器程序）-----Applet

小应用程序Applet总是放在Web浏览器的图形用户界面中，但Applet不能随意的读取本地磁盘。

• 仅能在服务器和客户端之间建立联系

JAVA Applet:
//import-----导入要用到的包中的类接口
import java.awt.Graphics;
import java.applet.Applet;
//extend-----继承已有的类
public class MyApplet extends Applet
{
	public String s;
	public void init()
	{     s=new String("Hello World !");   }
	public void paint(Graphics g)
	{     g.drawString(s,25,25);   }
}

需要编写HTML文件，把Applet嵌入其中，然后用
appletviewer运行，或在支持Java的浏览器上运行

HTML:
<applet  code= MyApplet.class  width=400  height=400>
</applet>

HTML:

1.3 基本数据类型与表达式

1.3.1 变量与常量

1.3.1.1 变量的定义和声明

Type varName[=value]

//变量的声明
double v, r, h;

1.3.1.2 声明常量-----final

final Type varName[=value]

//常量的声明
final  double   PI=3.1415926;

常量声明格式前加上final修饰符就声明了一个常量。

1.3.1.3 基本数据类型

float -----4个字节
double-----8个字节
'单引号括起来的字母，通过ASCII表将他转换为数字
“双引号括起来的，为字符串

1.3.1.4类型转换（布尔类型能不能进行类型转换）

小的自动转换为大的
大的需要强制类型转换-----在要强制转换类型的前面加上括号，然后在括号里面加上你要转换的类型

(double)x

1.3.2 标识符

• 标识符的第一个字符必须是下列字符之一：
  大写字母 (A-Z)
  小写字母 (a-z)
  下划线(_)
  美元符号 ($)
• 标识符的第二个字符及后继字符必须是：
  上述列表中的任意字符
  数字字符 (0-9)

1.3.3 表达式与运算符

①移位运算符

<<-----左移

//num乘以2
num<<1   

>>-----右移

>>>-----无符号右移

②~-----按位取反

③字符串连接运算符-----+

String wechat = "Hollis";
String intr = "o";
String holi = wechat + "," + intr;

1.3.4 String——字符串

• String 是一个类
• String类JDK标准类集合中的一部分

String animal = "walrus";

1.3.4.1 在特殊字符想输出其字符时，在前面加\

例如：要输出\，就要打出\，这样可以输出一个\

1.3.5 文字量（变量是自定义的名字，文字量是变量的具体值）

直接出现在程序中并被编译器直接使用的值.

整数文字量

• ①十六进制，必须以0x开头
  例如： 0xff
• ②八进制，必须以0开头
  例如： 0377

浮点文字量

一个浮点文字量包括以下几个部分：
整数部分
小数点 
小数部分
指数 (e or E)

float 类型文字量举例： 
1e  1f   2.f   .3f   0f   3.1  4f   6.022137e+23f 

double 类型文字量举例： 
1e1    2.    .3    0.0    3.1   4   1e-9d   1e137
//1的1次方 

1.3.6 表达式的优先级

1.3.7 i++和++i的区别

① for循环中,for(int i = 0;i < 6;i++)和for(int i = 0;i < 6;++i)效果一样
② while(i++)是先用i的初始化值做循环变量再i+1
而while(++i)是先用i的初始值+1,再循环
③ a = i++是a = i,i = i +1;
而a = ++i是a = i + 1,i = i + 1

1.3.8 表达式

①a+=8; 等效于 a=a+8;

1.3.9 运算符

1.3.9.1类型比较运算符-----instanceof

判断object是否是class的一个实例

• 用法

boolean result = object instanceof class；

• 参数
  ①Result：布尔类型。
  ②Object：必选项。任意对象表达式。
  ③class：必选项。任意已定义的对象类。

• 返回值
  ①如果 object 是 class 的一个实例，则 instanceof 运算符返回 true。
  ②如果 object 不是指定类的一个实例，或者 object 是 null，则返回 false。

1.3.9.2 “非”运算符！

• 操作数的类型必须是布尔类型
• 如果操作数的结果为 false，则表达式的结果为 true ，如果操作数的结果为 true，则表达式的结果为 false

1.3.9.3 按位反运算符-----~

对数据二进制取反

1.3.9.4 按位异或运算符-----^

同值取0，异值取1

1.4 数组的概念

1.4.1 成员变量length

String a="apple";
System.out.println(a.length());

1.5 数组的创建和引用

*java中，数组必须给他主动分配内存空间才能使用

*1.5.1 数组的创建

①.数据类型[ ] [ ]变量名=new 数据类型[储存元素的个数]；

②.数据类型[ ] [ ]变量名=new 数据类型[ ]{元素1，元素2，元素3}；

③数据类型[ ] [ ]变量名={元素1，元素2，元素3}；

*1.5.2 数组的声明

声明一维数组的语法形式：

①Type[ ] arrayName;

例如：
int[] intArray;
String[] stringArray;

②Type arrayName[ ];

例如：
int intArray[];
String stringArray[];
元素个数可以是常量也可以是变量

1.5.3 new一个对象

   int[] ai;   //声明数组
   ai=new int[10];  //创建数组

1.5.4 数组的初始化

• 创建数组的时，如果没有指定初始值，数组便被赋予默认值初始值。
• 基本类型数值数据，默认的初始值为0；
• boolean类型数据，默认值为false;
• 引用类型元素（除整数，浮点数，char，boolean）的默认值为null

1.5.5 数组的引用

由于数组是引用类型的，所以当a2 = a1时，a2和a1引用同一个数组
当a2[i]改变时，就相当于a1[i]也随之改变了

数组的长度

①数组行为: array.length

//二维数组用length属性表示行数

②数组列数为:array[0].length或者array[1].length

//*列数=数组名[0].length这句之前要判断数组是否为空，若为空则数组名[0]所代表的子数字不存在，会报错。

*第二章 类与对象的基本概念

2.1 面向对象的程序设计方法概述

2.1.1 概念

①将属性及行为相同或相似的对象归为一类

② 面向对象程序设计基本组成单位是类，程序在运行时由类生成对象

*2.1.2 抽象

忽略问题中与当前目标无关的方面，以便更充分地注意与当前目标有关的方面。

*2.1.3 封装

是一种信息隐蔽技术，利用抽象数据类型将数据和基于数据的操作封装在一起。

• 接口
  对象向外界提供的方法，外界可以通过这些方法与对象进行交互
• 功能的实现细节，不能从类外访问。

*2.1.4 继承

指新的类可以获得已有类（称为超类、基类或父类）的属性和行为，称新类为已有类的派生类（也称为子类）

• java只支持单继承（一个孩子_派生类只有一个直接父亲）
• 不同类的对象可以响应同名的消息(方法) ，具体的实现方法却不同

2.1.5 *多态

多态是一个程序中同名的不同方法共存

主要通过子类对父类方法的覆盖来实现

2.2 类与对象

2.2.1 类与对象的概念-----对象是一个抽象类

一个类是对一类对象的描述。
类是构造对象的模板
对象是类的具体实例

2.2.2 类的声明

[public] [abstract | final] class 类名称 
  	[extends 父类名称]  
    [implements 接口名称列表]
	{  
		变量成员声明及初始化；
     	方法声明及方法体；
	}

2.3 对象初始化和回收

2.4 枚举类型

2.5 应用举例

2.5 UML简介

*第四章 类的重用

4.1 类的继承

每个子类只能有一个直接父类

*4.1.1 继承的概念——基类和派生

①基类(base class)-----是被直接或间接继承的类

②派生类-----继承其他类而得到的类

• 派生类可以增加变量和方法
• 派生类也可以覆盖(override)继承的方法

4.1.2 继承的方法

class childClass extends parentClass
{ 
	//类体，新增的成员或者覆盖父类的方法
}

继承时，子类不能直接访问从父类中继承的私有属性及方法，但可使用公有（及保护）方法进行访问

4.1.3 继承时添加新的方法和属性

直接extend继承后添加新的就行

//父类Employee
class Employee
{    
    int  employeeNumbe ;
    String  name, address, phoneNumber ;
}
//子类Manager
class  Manager extends Employee 
{
    //子类增加的数据成员
    String responsibilities, listOfEmployees;
}

4.1.4 隐蔽和覆盖

4.1.5 有继承时的构造方法

• 子类不能从父类继承构造方法
• 子类调用父类，要用super关键字

//调用父类的构造方法
super();

//继承父类中的aNumber和aPhoneNumber
super(aNumber, aPhoneNumber);

• 如子类构造方法的声明中没有明确调用父类构造方法，则系统在执行子类的构造方法时会自动调用父类的默认构造方法（即无参的构造方法）

4.2 类

Object类是类层次的最高层
构造方法：Object()
常用函数:

①public final Class getClass()

获取当前对象所属的类信息，返回Class对象

②public String toString()

返回当前对象本身的有关信息，按字符串对象返回

*③public boolean equals(Object　obj)

比较两个对象是否是同一对象，是则返回true

④protected Object clone( )

生成当前对象的一个拷贝，并返回这个复制对象

⑤Public int hashCode()

返回该对象的哈希代码值

⑥protected void finalize() throws Throwable

定义回收当前对象时所需完成的资源释放工作

4.2 Object类

4.2.1 相等 VS 同一

相等：两个对象具有相同的类型，及相同的属性值，则称二者相等(equal)
比较运算符“==” 判断的是这两个对象是否同一(a和b的地址相同)

*4.2.2 equals()方法-----比较接受者对象与参数对象是否是同一个对象，即对象的地址是否相同

//判断是否同一
a.equals(b);

equals方法的重写

4.2.3 *finallize方法

• 在对象被垃圾回收器回收之前，系统自动调用对象的finalize方法
• 如果要覆盖finalize方法，覆盖方法的最后必须调用super.finalize

4.2.4 通过Class 对象，你可以查询Class对象的各种信息：比如它的名字，它的基类，它所实现接口的名字等。

 obj.getClass().getName();

4.3终结类和终结方法

final修饰的类（终结类）和方法不能被继承，且不能被当前类的子类重写和覆盖
可以防止子类和父类对该类的错误重写

4.3.1 终结类(不能被子类继承)

final class ChessAlgorithm {   . . .   }

4.3.2 终结方法(不能被子类覆盖)

 final int getPI() { return Math.PI; } //终结方法

4.4 抽象类-----可以在子类中具体实例化

4.4.1抽象类的定义(不能实例化_new具体对象的值)

abstract class Number {
    . . .
}

public abstract <returnType> <methodName>(...)；

4.4.2 抽象类的特征

• 代表一个抽象概念的类

• 没有具体实例对象的类，不能使用new方法进行实例化
• 类前需加修饰符abstract
• 也可包含抽象方法，这种方法只有方法的声明，而没有方法的实现

抽象类中可以包括被它的所有子类共享的公共行为
抽象类可以包括被它的所有子类共享的公共属性

• 一个抽象类的子类如果不是抽象类，则它必须为父类中的所有抽象方法书写方法体，即重写父类中的所有抽象方法
• 只有抽象类才具有抽象方法

4.5 类的组合

将一个类的对象放到另一个类里

4.5.1 类的组合的用法

class Cooker{   // 类的语句  }
class Refrigerator{   // 类的语句}
class Kitchen{   
	Cooker myCooker;
    Refrigerator myRefrigerator;
}	

4.5.2 组合 VS 继承

• 组合是包含关系，一个包含在另一个里
• 继承是获取一个新类，并根据需求定制

4.6（了解） 包的应用

4.6.1 包-----利用包来管理类

• 在默认情况下，只能访问当前包内的类
• 在public条件下，可以访问别的包的类、

Java提供的包主要有：
java.lang，java.io，java.math，java.util
java.applet，java.awt，java.awt.datatransfer
java.awt.event，java.awt.image，java.beans
java.net，java.rmi，java.security，java.sql等

语言包(java.lang)

语言包java.lang提供了Java语言最基础的类，包括

Object类

数据类型包裹类(the Data Type Wrapper)
字符串类(String、StringBuffer)
数学类(Math)
系统和运行时类(System、Runtime)
类操作类(Class，ClassLoader)

①数据类型包裹类

② string类对象为常量字符串

new String(char[] value, int offset, int count);

③ 数学类

• 提供一组常量和数学函数，例如
  E和PI常数
  求绝对值的abs方法
  计算三角函数的sin方法和cos方法
  求最小值、最大值的min方法和max方法
  求随机数的random方法等
• 其中所有的变量和方法都是静态的(static)
• 是终结类(final)，不能从中派生其他的新类

Math.sin(0)            //返回0.0

④ 系统和运行时类(System、Runtime)

System类

• 访问系统资源
  arraycopy() 复制一个数组
  exit() 结束当前运行的程序
  currentTimeMillis() 获得系统当前日期和时间等
• 访问标准输入输出流
  System.in 标准输入，表示键盘
  System.out 标准输出，表示显示器

Runtime类

• 可直接访问运行时资源
  totalMemory() 返回系统内存总量
  freeMemory() 返回内存的剩余空间

⑤ 类操作类(Class，ClassLoader)

Class类
是object类的子类，也是最一般的类，包含了所有共享的公共行为
为类提供运行时信息，如名字、类型以及父类
getClass-----返回当前对象所在的类，返回类型是Class

 Class aClass = anAccount.getClass(); 

getName-----返回一个类的名称，返回值是String
getSuperclass-----可以获得当前对象的父类

ClassLoader类

提供把类装入运行时环境的方法

*第五章 接口与多态

5.1 接口

• 接口的数据默认为final
• 方法默认为public abstract
  接口：有共同属性/功能的集合

5.1.1 接口的语法

• 包含数据成员，但它们都默认为static和final
• 接口的数据成员一定要赋初值，且此值将不能再更改，允许省略final关键字
• 接口中的方法必须是“抽象方法”，不能有方法体，允许省略public及abstract关键字

5.1.2 接口的作用

• 引用是为了实现多继承
• 接口中的所有方法都是抽象的，这些抽象方法由实现这一接口的不同类来具体完成
• 建立类和类之间的“协议”
  把类根据其实现的功能来分别代表，而不必顾虑它所在的类继承层次；这样可以最大限度地利用动态绑定，隐藏实现细节
• 实现不同类之间的常量共享(默认数据成员为static类型)

5.1.3 接口 VS 抽象类

• 接口定义的可以是不同大类，甚至没什么交集的对象之间的共同行为/属性
• 抽象类是同一大类对象之间的共同行为/属性
• 接口的数据必须初始化，而抽象类的数据不能初始化

5.1.4 接口的定义

[接口修饰符] interface 接口名称 [extends 父接口名]{
     …//方法的原型声明或静态常量
}

5.1.5 接口的实现(接口方法的实例化)-----必须将全部抽象方法都实现

• 也可以额外写自己新增的方法

public class 类名称 implements 接口名称 { 
        /* Bodies for the interface methods */ 
        /* Own data and methods. */ 
}

//定义一个接口
interface Shape2D{　　      //声明Shape2D接口
   double pi=3.14;                 //数据成员一定要初始化
   double area();                   //抽象方法
}

//接口的实现
class Circle implements Shape2D
{
    double radius;
    public Circle(double r)
    {
       radius=r;
    }
    public double area()      
   {
       return (pi * radius * radius);
   }
}

Car  jetta = new Car(); 
Insurable  item = (Insurable)jetta;   //对象转型为接口类型 
item.getPolicyNumber();
item.calculatePremium(); 
item.getMileage();           // 接口中没有声明此方法，不可以
jetta.getMileage();           // 类中有此方法，可以
((Car)item).getMileage(); // 转型回原类，可调用此方法了

5.1.6 多重继承

[类修饰符] class  类名称  implements 接口1,接口2,  …
{
… …
}

5.1.7 接口的扩展

• 实现接口的类也必须实现此接口的父接口

interface 子接口的名称 extends 父接口的名称1，父接口的名称2，…
{
  … …
}

5.2 塑型

5.3 多态的概念

5.4 多态的应用

5.5 构造方法与多态

5.6 内部类