Java新手入门

Java初学导入

导言：

​ java作为一门面向对象的语言，虽然语法相对简单，没有C中的指针等繁琐概念，但因为库多，初学者可能对类与对象等概念觉得比较陌生，本文将以介绍Java的语言为主，附带简单介绍一些面向对象的概念和其他一些功能。

Java概念

Java——Sun公司于1995年5月23日推出
Java特点：简单性、面向对象、安全性、平台独立(java源程序运行于JVM中，执行字节码文件)

test.java——>javac——>test.class——>java——>字节码

语言基础

标志符与关键字

• 标志符：字母、下划线、美元符、数字组成——规定第一个字符不能是数字（注：标志符也区分大小写）
• 关键字：全小写 不可作为普通标志符

数据类型

1. 基本类型：
   整数类型：长整型（后缀L/l） 短整型 基本int
   浮点数类型：float型(后缀F/f) double型
   字符类型：char
   布尔类型
2. 引用类型：数组 接口 类

常量

​ 符号常量——先申明后使用

final [修饰符] 类型标志符 常量名=(直接)常量

变量

以实际设置变量为例子
int a;double b;char c;

运算符与表达式

运算符

1. 算数运算符：
   单目：++、–、-等
   双目：+、-、*、/、%

   int j=5,x;
   情况一
   x=j++; //x=5;j=6;
   情况二
   x=++j; //x=6;j=6;
   

2. 算数运算符：> < >= <= == !=
3. 逻辑运算符：&& || ！
4. 位运算：~ & | ^ >> << >>>
5. 赋值运算符：= += 等
6. 条件运算符： _ ? _ : _
7. 括号运算符

表达式

1. 优先级 ：仅仅单目操作、条件运算符、赋值运算符从右到左
2. 数据类型转换：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

对象的创建和使用

​ 类名 对象名 = new 类名(参数表)
​ 声明 实例化
使用：对象名.成员变量
​ 对象名.方法名(参数表)
构造方法：类中的成员方法名和类名相同
特点：
​ 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()方法。