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()方法。
网友评论