Java两种核心机制:java虚拟机垃圾收集机制
源程序(*.java)---java编译器---字节码(*.class)—操作系统平台
Java虚拟机可以理解成一个字节码为机器指令的cpu
对于不同的运行平台,有不同的虚拟机
Java虚拟机制屏蔽了底层运行平台的差别,实现了”一次编译,随处运行”
Java是解释型语言
J2SDK(软件开发包) JRE(java运行环境) 开发需要JDK 用户需要JRE
Bin二进制
Dos中输入java –version现在用的jdk版本
Path:window系统执行命令时要搜寻的路径
Classpath:java在编译和运行时要找的class所在的路径
1.Helloworld.java
Public class HelloWorld{
Public static void main(String[] args){
System.out.println(“HelloWorld”);
}
}
d:
cd java//切换到java目录
javac HelloWorld.java
java HelloWorld
详细信息 工具 文件夹 应用到所有文件夹
显示所有文件和文件夹
不隐藏已知文件类型拓展名
在地址栏显示完整路径
类体 方法体
一个原文件中最多有一个public类 每个类对应一个class
源文件的名必须和public类名相同
Java语言注释三种注释方式:
//
/* */
/**
*
*/
Java.lang.NoclassDefound
IDE集成开发环境
J2se基础语法
标识符:凡是自己可以起名字的 由字母 下划线 美元符 或数字组成
应以字母,数字,美元符
见名知意
关键字:专门用途,小写英文
Java常量:用字符串表示,区分为不同的类型
Eg 整型常量123
实型常量3.14
字符常量’a’
逻辑常量true false
字符串常量”helloworld”
“常量”这个名词还会用在另外其它语境中表示值不可变的变量参见Final关键字
Java变量是程序中最基本的存储单元,其要素包括变量名,变量类型和作用域
Java程序中每一个变量都属于特定的数据类型,在使用前必须对其声明.
从本质上讲,变量其实是内存中的一小块区域,使用变量名来访问这块区域,因此,每一个变量使用前必须要先申请(声明),然后必须进行赋值(填充内容),才能使用.
程序执行过程 load到内存 找到main方法开始执行
执行过程管理:code segment存放代码 data segment 静态变量字符串常量
Stack局部变量 heap new出来的东西(内存分的四部分)
Java变量的分类
按被声明的位置划分:
局部变量:方法或语句块内部定义的变量(包含方法参数)
成员变量:方法外部,类的内部定义的变量
类外面不能有变量的声明
大括号里声明的变量,出了大括号就没人认识大括号里声明的变量
按所属的数据类型划分:
基本数据类型变量4类8种
逻辑型boolen true false 不可以以0或非0的整数替代
文本型 字符型char \u后边的数是十六进制的编码 \n换行符 \r回车符
整数型 byte1 short1 int4 long8 八进制0开头 十六进制 0x 或0X开头×××默认为int型,声明long型常量可以后加l或L
浮点数型 两种表示形式 十进制 科学记数
Float4 double8 默认double声明float型常量可以后加f或F
引用数据类型变量
基本数据类型转换:boolean不可以转换为其他数据类型
×××,字符型,浮点型在混合运算中相互转换
Infinity无小的转换成大的自动转化 大的转换成小的强制转换
Byte short char 转换成int处理
程序应该主义的问题
1. 大括号对其
2. 遇到{缩进,Tab/shift+Tab
3. 程序块之间加空格
4. 并排语句之间加空格
5. 运算符两侧加空格
6. {前面有空格
7. 成对编程
运算符
算术运算符 逻辑运算符 赋值运算符 字符串连接符
“+”运算符两侧的操作数中只要有一个是字符串类型,系统会自动将另一个操作数转换为字符串然后在进行连接
当进行打印的时候,无论任何类型都自动转换为字符串进行打印
Print不换行 println换行
表达式
表达式的类型和值 表达式的运算顺序
三目条件运算符 x?y:z x 为boolean类型 为true结果为y 否则为z
语句
条件语句
If
If..else..
If..else if..else..
For循环语句
1+3+5+…+99
public class OddSum{
Public static void main(String[] args){
long result = 0;
for(int i=1; i<=99; i+=2){
result +=i;
}
System.out.println(“result=”+restult);
}
}
Int result=0;
For(int i=1;i<=99;i+=2)
{result+=i}
Tab shift+tab
While do while
Break continue
1 100内前5个可以被3整除的数
输出101 200内的质数
应该由哪些类对象
应该具有的属性方法
类和类之间的关系
Static关键字
用static声明的成员变量为静态成员变量,它为该类的公用变量,在第一次使用时被初始化,对于该类的所有对象来说,static成员变量只有一份.
可以通过对象引用或类名(不需要实例化)访问静态成员
用static声明的方法为静态方法,在调用该方法时,不会将对象的引用传递给它,所以在static方法中不可访问非static的成员.静态方法不再是针对于某个对象调用,所以不能访问非静态成员
Package 和import语句
class文件的最上层包的父目录位于classpath下
执行一个类需要写全包名
J2SDK
Java.lang 包含一些java语言的核心类,如string,math,integer,system和thread,提供常用功能
Java.awt 包含了构成抽象窗口工具集的多个类,这些类被用来构建和管理应用程序的图形用户界面(GUI)
Java.applet包含applet运行所需的一些类
Java.net 包含执行与网络相关的操作的类
Java.io 包含能提供多种输入/输出功能的类
Java.util 包含一些实用工具类,如定义系统特性,使用与日期日历相关的函数
Java.lang不需引入
Dos中打jar包的命令 jar –cvf xx.jar *.*
继承和权限控制
Extends
通过继承,子类自动拥有了基类的所有成员(成员变量和方法)
Java只支持单继承,不允许多继承.一个子类只能有一个基类 一个基类可以派生多个子类
Private 类内部
Default 类内部同一个包
Protected 类内部同一个包子类
Public 类内部同一个包子类任何地方
方法的重写
在子类中可以根据需要从基类中继承来的方法进行重写
重写方法和被重写方法具有相同方法名称,参数列表和返回类型
重写方法不能使用比被重写方法更严格的访问权限
Super关键字
在java类中使用super来引用基类的成分,eg 引用方法
继承中的构造方法
子类的构造过程中必须调用其基类的构造方法
子类可以在自己的构造方法中使用super调用基类的构造方法
使用this调用本类的另外的构造方法
如果调用super,必须写在子类构造方法的第一行
如果子类的构造方法中没有显示的调用基类构造方法,则系统默认调用基类无参数的构造方法
如果子类构造方法中既没有显式调用基类构造方法,而基类中又没有无参的构造方法,则编译出错.
Object类
Object类是所有java类的根基类
Clone()
equals(Object obj)
finalize()
getClass() 拿到编译好的class文件
hashCode()
notify()
toString() 返回代表这个对象的字符串
toString方法
object 类中定义有public String toString()方法,其返回值是String类型,描述当前对象的有关信息.
在进行String与其它类型数据的连接操作是(如:System.out.println)(“info”+person),将自动调用该对象类的toString()方法.
可以根据需要在用户自定义类型中重写toString()方法.
Public class TestToString{
Public static void main(String[] args){
Dog d = new Dog();
System.out.println(“d:=”+d.toString); //object类默认是哈希编码
}
}
Class Dog{
Public String toString(){
Return “I’m a cool Dog!”
}
}
哈希编码: 独一无二的代表一个对象.并且通过哈希编码可以独一无二的找到这个对象的位置.
在java虚拟机运行时需找到运行对象的地址,会用一张表记录每一个对象的位置,根据编码可以找到对象.
equals()方法
重写Public boolean equals(Object obj){}
public class TestEquals{
public static void main(String[] args){
Cat c1 = new Cat(1,2,3);
Cat c2 = new Cat(1,2,6);
System.out.println(c1 = c2); //比较的是引用中的内容,不可能相同
System.out.println(c1.equals(c2));
//上为object类
//下为string类 string类中的equals方法 序列一样就相等
String s1 = new String(“hello”);
String s2 = new String(“hello”);
System.out.println(s1 ==s2);
System.out.println(s1.equals(s2));
}
}
Class Cat{
Int color;
Int height,weight;
public Cat(int color,int height,int weight){
this.color = color;
this.height = height;
this.weight = weight;
}
Public boolean equals(Object obj){
if(obj = = null) return false;
else{
if(obj instanceof Cat){
Cat c = (Cat) obj;
If(c.color==this.color&&c.height==this.height&&c.weight ==this.weiget)
Return true;
}
}
}
Return false;
}
Object 的equals方法定义为:x.equals(y) 当x和y是同一个对象的应用是返回true否则返回false.
对象转型(casting)
一个基类的引用类型变量可以”指向”其子类的对象.
一个基类的引用不可以访问其子类对象新增加的成员(属性和方法)
可以使用引用变量instanceof 类名 来判断该引用型变量所指向的对象是否属于该类或该类的子类
子类对象可以当做基类的对象来使用称作向上转型(upcasting),反之称为向下转型(downcasting).
动态绑定和多态
动态绑定是指在执行期间(而非编译期)判断所引用对象的实际类型,根据其实际的类型调用其相应的方法.
实际中new的谁就调用谁的方法,实际中的地址才会绑定到相应方法之中的地址上面
多态的条件:
1 有继承 2 有重写 3 父类引用指向子类对象
多态特性对于系统可扩充性有重要影响
抽象类
用abstract关键字来修饰一个类时,这个类叫做抽象类,用abstract来修饰一个方法时,该方法叫做抽象方法.
含有抽象方法的类必须被声明为抽象类,抽象类必须被继承,抽象方法必须被重写.
抽象类不能被实例化
抽象方法只需声明,不需实现
Eg:public abstract void enjoy();
Final关键字
Final的变量值不能够被改变
Final的成员变量
Final的局部变量(形参)
Final的类不能够被继承
Final的方法不能够被重写
Public class TestFianl{
Public static void main(String[] args){
T t = new T();
t.i = 9;
}
}
Final Class T{
Final int t = 8;
Public final void m(final int j){
}
}
Class TT extends T{
Public void m(){
}
}
接口interface
多个无关的类可以实现同一个接口
一个类可以实现多个无关的接口
与继承关系类似,接口与实现类之间存在多态性
接口是抽象方法和常量值的定义的集合
从本质上讲,接口是一种特殊的抽象类,这种抽象类中只包含常量和方法的定义,而没有变量和方法的实现
接口特性
接口可以多重实现
接口中声明的属性默认为public static final 的;也只能是public static final 的;
接口中只能定义抽象方法,而且这些方法默认为public的,也只能是public的;
接口可以继承其它的接口,并添加新的属性和抽象方法.
异常处理
运行期出现的错误
Eg: int[] a = {1,2,3};
Try{
System.out..println(arr[4]);
}
Catch(ArrayIndexOutofBoundsException ar){
System.out.println(“系统正在维护”);
ar.printStackTrace();
}
Java.lang.ArrayIndexOutofBoundsException 数组下标越界
printStackTrace();
j2sdk中定义了很多异常类
Throwable (1)error 不可处理(2)exception / RuntimeException经常出现的错误,可以捕获也可以不捕获./另一类必须被catch
Try{}
Catch(someException1 e){}
Catch(someException2 e){}
Finally{}//通常在其中进行资源的清除工作
Void f() throws FileNotFoundException,IOException{}
Void f2(){
Try{
f(0);
}catch(FileNotFoundException e){
System.out.println{e.getMessage()}}
Catch(IOException e){
e.printStackTrace();}
}
ArithmeticException
Try catch finally throws throw
使用自定义异常一般有如下步骤;
1 通过继承java.lang.Exception类声明自己的异常类
2 在方法适当的位置生成自定义异常的实例,并用throw语句抛出
3 在方法的声明部分用throws语句声明该方法可能抛出的异常
注意:重写方法需要抛出与原方法所抛出异常类型一致异常或不抛出异常
数组
一维数组的声明方式: type var[] 或type[] var
数组对象的创建:
Java中使用关键字new创建数组对象,格式为:数组名 = new 数组元素的类型 [数组元素的个数]
Eg public class test{
Public static void main(String args[]){
Int[] s;
S = new int[5];
For(int i = 0; i < 5; i++){
S[i] = 2*i+1;
}
}
}
注意:数组元素为引用数据类型的数组中的每一个元素都需要实例化.
Public class Test{
Public static void main(String args[]){
Date[] days;
days=new Date[3];
for(int i=0;i<3;i++){
days[i]=new Date(2004,4,i+1);
}
}
}
class Date{
int year; int month; int day;
Date(int y, int m, int d){
Year = y;
Moth = m;
Day = d;
}
}
数组初始化
动态初始化:数组定义与为数组元素分配空间和赋值的操作分开进行.
Eg public class Test{
Public static void main(String args[]){
Int a[];
A = new int[3];
A[0]=3,a[1]=9,a[2]=8;
Date days[];
Days = new Date[3];
Days[0]=new Date(1,4,2004);
Days[1]=new Date(2,4,2004);
Days[2]=new Date(3,4,2004);
}
}
Class Date{
Int year,month,day;
Date(int y,int m,int d){
year=y,month=m,day=d;
}
}
静态初始化:在定义数组的同时就为数组元素分配空间并赋值.
Public class test{
Public static void main(String args[]){
Int a[] = {3,9,8};
Date days[] = {new Date(1,4,2004), new Date(2,4,2004),new Date(3,4,2004)}
}
}
Class Date{
Int year,month,day;
Date(int y,int m,int d){
year=y,month=m,day=d;
}
}
数组元素的默认初始化
数组是引用类型,它的元素相当于类的成员变量,因此数组分配空间后,每个元素也被按照成员变量的规则被隐式初始化.
Public class test{
Public static void main(String args[]){
Int a[] = new int[5];
Date[] days = new Date[3];
System.out.println(a[3]);
System.out.println(days[2]);
}
}
Class date{
Int year,month,day;
Date(int y,int m,int d){
Year=y;
Month=m;
Day=d;
}
}
输出结果:0,null
数组元素的引用
定义并用运算符new为之分配空间后,才可以引用数组中的每个元素,数组元素的引用方式为:arrayName[index]
Index可以为数组元素下标,可以是×××常量或×××表达式.eg a[3] b[i] c[6*i]
数组元素下标从0开始;长度为n的数组的合法下标取值范围为0~n-1
每个数组都有一个属性length指明它的长度,例如
a. length的值为数组a的长度(元素个数)
public class TestArray{
public static void main(String[] args){}
int[] a = {2,4,6,7,3,5,1,9,8};
for(int i=0;i<a. .length;i++){
System.out.println(a[i] + “ ”);
}
For(int i=0;i<args.length;i++){
System.out..println(args[i]);
}
}
Public class TestArgs{
Public static void main(String[] args){
If(args.length<3){
System.out.println(“usage:java Test \”n1\” \”op\” \” n2\””);
System.exit(-1); //非正常退出
}
double d1 = Double.parseDouble(args[0]);
double d2 = Double.parseDouble(args[2]);
double d = 0;
if(args[1].equals(“+”)) d = d1+d2;
else if(args[1].equals(“-”)) d = d1-d2;
else if(args[1].eauals(“×”)) d=d1*d2;
else if(args[1].equals(“/”)) d=d1/d2;
else{
System.out.println(“Error operator!”);
System.exit(-1);
}
System.out.println(d);
}
}
*******************
Public class NumSort{
Public static void main(String[] args){
int[] a = new int[args.length];
//读进来
for(int i=0;i<args.length;i++){
a[i] = Integer,parseInt(args[i]);
}
print(a);
selectionSort(a);
print(a);
}
Private static void selectionSort(int[] a){
int k,temp;
For(int i=0;i<a.length;i++){
k = i;
for(int j=k+1;j<a.length;j++){
If(a[j]<a[k]){
k = j;
}
}
If(k!=i){
temp=a[i];
a[i]=a[k];
a[k]=temp;
}
}
}
Private static void print(int[] a){
For(int i=0;i<a.length;i++){
System.out.print(a[i] + “ “);
}
System.out.println();
}
}
Public class Test{
Public static void main(String[] args){
Date[] days = new Date[10];
Date day = new Date(2004,4,6);
}
Class Date{
Int year,month,day;
Date(int y,m,d){}
}
}
二维数组
可以看成以数组为元素的数组
多维数组的声明和初始化应该按从高维到低维的顺序进行.
Eg int a[][] = new int[3][ ]
A[0] = new int[2];
A[1] =new int[4];
A[2] = new int[3]
数据的拷贝
使用java.lang.System类的静态方法
Public static void arraycopy(object src,int srcPos,object dest,int destPos,int length)
可以用于数组src从第srcPos项元素开始的length个元素拷贝到目标数组从destPos项开始的length个位置.
如果源数据数目超过目标数组边界会抛出IndexOutOfBoundsException异常.
