Java新手入门
Java初学导入
导言:
java作为一门面向对象的语言,虽然语法相对简单,没有C中的指针等繁琐概念,但因为库多,初学者可能对类与对象等概念觉得比较陌生,本文将以介绍Java的语言为主,附带简单介绍一些面向对象的概念和其他一些功能。
Java概念
Java——Sun公司于1995年5月23日推出
Java特点:简单性、面向对象、安全性、平台独立(java源程序运行于JVM中,执行字节码文件)
test.java——>javac——>test.class——>java——>字节码
语言基础
标志符与关键字
- 标志符:字母、下划线、美元符、数字组成——规定第一个字符不能是数字(注:标志符也区分大小写)
- 关键字:全小写 不可作为普通标志符
数据类型
- 基本类型:
整数类型:长整型(后缀L/l) 短整型 基本int
浮点数类型:float型(后缀F/f) double型
字符类型:char
布尔类型 - 引用类型:数组 接口 类
常量
符号常量——先申明后使用
final [修饰符] 类型标志符 常量名=(直接)常量
变量
以实际设置变量为例子
int a;double b;char c;
运算符与表达式
运算符
- 算数运算符:
单目:++、--、-等
双目:+、-、*、/、%int j=5,x; 情况一 x=j++; //x=5;j=6; 情况二 x=++j; //x=6;j=6;
- 算数运算符:> < >= <= == !=
- 逻辑运算符:&& || !
- 位运算:~ & | ^ >> << >>>
- 赋值运算符:= += 等
- 条件运算符: _ ? _ : _
- 括号运算符
表达式
- 优先级 :仅仅单目操作、条件运算符、赋值运算符从右到左
- 数据类型转换:byte -> short -> int -> long -> float -> double
低类型到高类型:自动 反之则需要强制转换
基本控制结构
顺序
选择
if语句
if() ____ ;
[else _____;]
嵌套if
if() ____ ;
[else if() _____;]
switch语句
switch()
{
case _ : _____; [break;]
```
[default:____;]
}
循环
while语句
while(){ }
do while
do{
___;
}while();
for语句
for(;;) _;
跳转语句
break; //跳出此循环,并中断
continue; //跳出此循环,并跳入下一个循环
方法
声明:[修饰符] 类型标识符 方法名([参数表]){
声明部分;
语句部分;}
注意:方法不能嵌套,即不能在方法中再声明其他方法。
参数传递:传数组时,传递地址;传单个数字时,仅传值(改变形参时,不改变实参)
递归:自身调用自身结构;
数组
一维数组:声明+初始化
1.先声明再初始化
int[] score;
score=new int[10];
2.声明同时初始化
int[] score=new int[10];
3.赋初值类型
int[] score={1,2,10};
多维数组:
同一维数组
int[][] score;
score=new int[][];
另一种方法
int[][] score=new int[3][4];
求数组的列数/行数
求行数:数组名.length
求列数:数组名[行数].length
非矩阵化数组:允许各个行列元素个数不一致
例如:
int[][] c=new int[3][];
c[0]=new int[1]; //c[0]有一个元素
c[1]=new int[3]; //c[0]有三个元素
c[3]=new int[5]; //c[0]有五个元素
数组的基本操作
- 引用
- 复制(for循环,单值复制;整体复制)
- 输出:for循环单值输出
数组参数
java中,允许方法的参数是数组。
- 形参中,数组名后的括号不能省略,括号个数和数组的维数相等。形参里可不用给出具体的数字。
- 实参中,数组名后不用括号。
- 数组名做实参时,传地址,而非值,即形参和实参具有相同的存储单元。
//例子
class test{
main(){
int c[]={1,2,3};
sum(c);
}
public int sum(int x[]){
函数体;
}
}
字符串
字符串使用
字符数组
char[] country={'C','h','i','n','a'};
字符串
String country="China";
声明
String s;s=new String("China");
String s="China";
字符串操作
求字符串长度
int length(); //s.lenth()==5 数组的length不用加()
某个下标对应的字符
char charAt(int index);
//比如:s.charAt(0)=='C',s.charAt(3)=='n'
求某个字符第一次出现的位置
int indexOf(char ch);
//比如:s.indexOf('i')==2
从index位开始,子串str第一次出现的位置;无对应字串则return -1。
int indexOf(String str,int index);
截取子串
subString(int index1,int index2);
//例如:s.subString(1,3)=='hin'
比较
equals(object obj);
equalsIgnoreCase(String str);
CompareTo(String str);//对比,返回0则二者相等;返回正值则str大;(|返回值|=|不对等的字符差|)
转换:其他数据类型转换成字符串
String.valueOf(123)=>"123"
字符串=>其他数据类型
Boolean.parseBoolean("true")=>true
Integer.paeseInt("123")=>123
类与对象
面向对象
类:封装性、继承性、多态性
对象:类的实例化
类的声明
[修饰符] class 类名 [extends 父类名][implements 接口]{ }
class——关键字;
extends——继承;
implements——接口;
修饰符——访问权限(public)、final或者abstract
对象的创建和使用
<u>类名 对象名</u> = <u>new 类名(参数表)</u>
声明 实例化
使用:对象名.成员变量
对象名.方法名(参数表)
构造方法:类中的成员方法名和类名相同
特点:
1.无返回值,不能有void
2.不可直接调用,仅在new时调用
3.类中可声明多个构造方法,但各构造方法的参数表不能相同
class Traingle{
int x,y,z;
public Traingle(int i,int j,int k){
x=i;y=j;z=k;
}
}
对象销毁
finalize()方法,基本格式:
public void finalize(){方法体}
类的封装
访问权限 | 本类 | 本类所在的包 | 其它包中的子类 | 其它包中的非子类 |
---|---|---|---|---|
public | √ | √ | √ | √ |
protected | √ | √ | √ | × |
缺省 | √ | √ | × | × |
private | √ | × | × | × |
类成员——有static
1、类成员变量——有static修饰
实例成员变量——无static修饰
2、每个对象的每个成员变量有各自的存储单元,而系统为类成员变量分配一个存储单元,所有对象共享一个类成员变量。
3、实例成员仅仅通过对象引用;类成员变量属于类,可通过类名和对象名访问。
类成员方法——同上。
类的继承与多态机制
类的继承
父类/超类
子类
一个子类只能继承一个超类——单继承
声明子类
[修饰符] class 类名 extends 父类名{ }
原则:1、子类继承父类的成员变量(实例/类)
2、继承父类出构造方法外的成员方法。
3、不能继承构造方法。
4、子类可重申父类成员。
对父类成员的访问权限:
子类对父类:private——无访问权限
public、protected——√
缺省——同一包中 √ 其他包中 ×
习惯:
public void setXXX(int a){x =a ;} //给成员变量赋值
public int getXXX(){return xxx ;} //取值
引用父类成员:当且仅当子类声明与父类同名的成员才可使用
supper.成员变量名; supper.成员方法名(参数表)
supper(参数)——子类首句,引用父类的构造方法
引用当前对象:this
多态
重载——同类中多个方法有相同方法名,却有不同参数表。
覆盖——子类可重新定义父类方法体。
final类/成员
final类:不允许被继承
final方法——子类不可重写
final成员变量
接口与包
接口
定义:一组常量和抽象方法的集合,抽象方法只声明方法类,而无方法体。
抽象类和方法:
1、声明抽象方法
[权限] abstract 类型 方法名(参数);
注意:构造方法不能声明为抽象方法
2、声明抽象类
[权限] abstract class 类名{类体}
注意:1、抽象类中可以不含抽象方法,但类中有抽象方法的类必声明为抽象类。
2、抽象类不能实例化,即不能创建对象。
3.抽象类的子类必须覆盖每个抽象方法后才可实例化,否则应该声明为抽象类。
接口声明:
[public] interface 接口 [extends 父接口]{
(常量)成员变量表;
(抽象)成员方法表;
}
成员变量声明
[public] [static] [final] 类型 成员变量名=常;
成员方法声明
[public] [abstract] 类型 成员方法名(参数表);
实现
[public] class 类名 implements 接口名表{ 类体 } //多个接口间用“,”
包
声明:package 包名(或 包名.子包名) //声明自身所在的包
使用包中的类:
包名.类名 或 包名.接口名
导入包中的类:
import 包.类名/接口名/*
异常处理
计算机直接检测
程序员加入处理异常的功能
处理方式
try...catch...finally 对异常捕获处理
throws和throw抛出异常
try{可能出现异常的代码}
catch(异常类名1 异常的对象名1){
异常类名1 对应的异常处理代码
}
[finally{必须执行的代码}]
throw new 异常类名(信息) ——语句
抛出异常选项:
[修饰符] 类型 方法名([参数表]) throws{
声明语句
}
自定义异常类
class 自定义异常类名 extends Exception{异常类体}
输入输出
java.io包
1、输入/输出类库
以流的方式来处理,流是输入输出的数据序列
输入输出流类:
InputStream:继承方法:read()、定位指针、close()
OutputStream:write()、flush()、close()
非流类:Reader、Writer
2、标准输入
System.in——inputStream类的对象
3、标准输出
System.out——PrintStream类对象
4、标准错误
各类错误信息输出到标准错误设备,即显示器。
多线程
生命周期
新生:new,Thread类及其子类创建线程对象后即处于新生状态
↓调用start()
就绪:等待分配CPU
↓run()
运行:执行代码
↓
阻塞:sleep()等方法让出CPU,并且暂时中止自己的运行,静茹阻塞状态
↓
死亡:调用stop()或destroy()
两种实现多线程的方法
1、用Thread类实现多线程
2、用runnable接口实现多线程
线程等待
join():一个线程结束,再运行其他线程
线程同步
共享内存变量的方法,再前面加synchronized修饰符
例:对sub()加上synchronized同步限制,所以在1线程结束sub()方法前,2线程无法进入sub()方法。