【笔记-JAVE_WEB】 java

1. JDK环境变量

JAVA_HOME

C:\Program Files\Java\jdk...

path

%JAVA_HOME%\bin

java5以上不需要配置CLASSPATH

运行环境：

JRE_HOME      jre的bin目录上级

1. 结构

public class A{

   public static void main(String Args[]){

      int   x=10;

      System.out.println("int"+x);

   }

}

编辑文本保存为  A.java。

使用命令  javac   A.java    （编译命令时可以不区分文件名大小写）

生成文件  A.class

运行命令  java A

保存时，一定要用类名作为文件名。单个java文件可以包含多个类，但最多只能有一个public类，如果某个类为public，则该类名要作为文件名。

label:  ........;

continue label;

switch支持字符串

导出jar时，需要选择主类为应用程序主入口。

运行时java -jar *.jar

1. Applet

嵌入HTML标签中(直接在标签中写入java文件名即可)：

<applet code="A.class"  width="100"  height="50">

import java.applet.Applet;

import java.awt.Graphics;

public class A extends Applet{

     public void paint(Graphics g){

             g.drawString("xxxx",20,30);

     }

}

1. 数据类型

包括基本数据类型和引用数据类型，引用数据类型包括class类型，枚举，数组。

对象在函数中传递时，基本类型都是值传递，引用类型传递的是引用，可以在函数中对改变该对象的值，但不能改变该对象的指向。

1. 基本数据类型

数据类型	名称	位长	默认值
布尔型	boolean	1	False
字节型	byte	8	0
字符型	char	16	‘\u0000’
短整型	short	16	0
整型	int	32	0
长整型	long	64	0
浮点型	float	32	0.0f
双精度型	double	64	0.0

========整型常量

不含小数的整数值，十进制以非0开头，八进制以0开头，十六进制以0x开头。如果在数值后面加L或者l则表示64位长整型。

========浮点型常量

1. 十进制形式：.123，0.123,123.0
2. 科学计数法：123e3或123E-3。E后面必须是整数。如果后面加f或F，代表单精度，加上d或者D，表示双精度。不加后缀默认为双精度，占64位。

========字符常量

用’’包起来的单个字符。

可以用字符编码表示，如A的八进制表示’\101’，十六进制’\u0041’

无法通过键盘输入的用转译符号：

‘\b’  退格       ‘\r’  回车

‘\n’  换行      ‘\t’ 水平制表符

‘\’’    ‘\”’    ‘\\’

1. 类型转换

a=(int)b

String str = "12.2";

double d = Double.parseDouble(str);

int i = Integer.parseInt(str);//str不能是小数

1. Class

class类型必须使用new来创建对象：B b=new B();

也可以创建临时对象调用函数：new B().fun();

this可以指代当前对象

super指代父类：super();super.fun();

super(xxx)  只能在构造函数第一行调用基类的构造

1. 1. 修饰符

[public][abstract][final] class 类名

[extends父类][implement  接口]{}

抽象类abstract不能实例化一个对象，只能被继承。如Number只能产生一个数的子类，比如Integer或者Float。

final类不能有子类。为了提高系统安全性和定义一个完全类。

接口是消息传递的通道，通过接口，消息才能传递到处理方法中进行处理。

1. 1. 成员变量

成员变量描述了类和对象的状态，有时也称为属性、数据、域。

[public][private][protected][package]

[static][final][transient][volatile]   类型   名称

final可以定义常量

protected变量可以被声明它的类和子类以及同一个包中的类访问。如果子类在其他包，子类的对象可以访问，但子类中由父类产生的对象就不能访问。

package在声明时常省略，即没有修饰的变量为package变量。

final变量在程序运行过程中不能被改变。

transient一般在对象序列化上使用。

volatile用来防止编译器对变量进行优化。

1. 1. 成员方法

[public][private][protected][package]

[static][final][abstract][native][synchronized]

返回值类型   方法名(参数表)[throws 异常类型]

1. 1. 语句块

static   

{  //main函数所在类，需要用static语句块，其他不需要

System.out.println("xxxxxx");

}

在类中直接写的语句块，类似于类的构造函数中执行初始化语句，程序运行初始化时执行。

1. 1. 继承和多态

继承使用关键字extends，子类如果和父类有同名函数时，函数访问权限不能低于父类。此时将子类对象赋值给父类对象，父类调用该函数时为子类的函数。

class Base{public void fun(){System.out.println("Base");}}

class Der extends Base{public void fun(){System.out.println("Der");}}

使用时Base b1 = new Dir();

或者Dir d = new Dir();Base b2 = d;

此时调用fun函数，输出为Dir。

将基类改为接口，可以使用接口实现多态

interface Base{public void fun();}

class Der implements Base{public void fun(){System.out.println("Der");}}

instanceof  用于测试一个对象是否是一个指定类的实例

1. 1. 抽象类

不能被实例化的类，可以有静态方法，通过类名直接调用。

abstract class B//包含抽象方法的类必须声明为abstract

{

abstract void fun();//抽象方法不能有实现，且声明为abstract

}

class C extends B

{

void fun(){}

}

1. 1. 匿名对象

创建对象时就调用其中的函数，属于临时对象

new A().show();

1. 1. 创建对象时加入代码

创建A对象时，为A类加入成员变量y，重写show方法，在其中可以直接访问外部变量z

int z = 1;

A a = new A(){int y =1; void show(){System.out.println(x+z+y);}};

(new A(){...}).show();  可以加入代码后创建临时变量使用

如果是直接创建接口的对象，则需要该语法实现接口的函数

1. 数组

int[]  arr； 或者int  arr[];

Java在数组定义时并不为数组元素分配内存，因此[]中不用指出数组的长度。

数组作为Array类的实例，可以引用属性和方法。

arr.length直接获取长度属性

for(int x : arr){}遍历数组中每个元素

Arrays.sort(arr);//对数组进行排序，需要实现 Comparable接口

========一维数组

定义数组后，需要为数组分配内存、初始化。

1. int[] arr=new int[3];

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

========多维数组

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

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

二维数组的第二维的长度可以不相等

1. 包装类型

将基本数据类型包装到类类型中，实现toString和compareTo等函数

String str = Integer.toHexString(17); //将整数转换为十六进制字符串

short等基本类型包装类为Short这类将首字母大写，char对应Character，int对应Integer。

 short st = 1;

 Short s = new Short(st);//赋值装箱

 s = 1;//自动装箱

1. 枚举

枚举是一种包含自身全局对象的特殊的类，且构造函数必须是private。

enum  E

{

e1(1),

e2(2)；  //两个E的全局对象，类似单例

public int x = 0; //成员变量

E(int a){x = a;}//构造函数，只能是private

}

======使用

E e = E.e1;//获取枚举对象

if(E.e1 == e)

{

 String str = e.toString();

//将枚举的对象名e1转换为字符串“e1”。与之对应的是E.valueOf("e1")，通过字符串“e1”获取对象E.e1  

}

========遍历

for(E temp : E.values())

{

int value = temp.x;  //获取对象内部的成员变量

}

1. 接口

interface  I

{

    void fun();//不能有权限修饰符

}

class B implements I

{

public void fun(){}//实现接口时必须是public

}

1. 异常

class Ex extends Exception

{//自定义异常类

String s = "Exx";

}

class B

{

void fun(int x) throws Ex

{//可以抛出异常的函数，不能直接被调用，需要在try、catch中调用

if(10 == x)

{

throw new Ex();

}

}

public void ProcessEx()

{

try{

       fun(10);

}catch(Ex e)

{

System.out.println(e.s);

}

}

}

1. 包

javac   A.java    -d  D:\    

         在D：下生成class，如果A.java有声明包路径，则会生成包目录

一般新建项目为一个目录P，目录下有abc目录，则为一个abc的包。

假设main函数所在类为P目录下的ABC目录，则运行时，需要在P目录同级下运行：java P.ABC.A

package P.ABC;//包声明必须是第一句，目录间用.，表示P目录下的abc目录

import  P.ABC.*; //导入ABC包中的全部内容，也可以将*改为类名，只导入某个类。导入的内容访问权限如果是默认，则只能在同一个包下才能访问

1. 导入jar

将jar放入工程目录，右键jar文件，选择Build Path-》add to build path，则可以看到reference libraries中出现新的包和类。（不出现build path菜单说明工程配置损坏）