java

java简介：

Java是Sun Microsystems于1995年推出的高级编程语言

1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言。希望用于控制嵌入在有线电视交换盒、PDA等的微处理器

1994年将Oak语言更名为Java（互联网发展）

2009年，被oracle收购

Java 既安全、可移植，又可跨平台，而且人们发现它能够解决Internet 上的大型应用问题

java的技术平台

JavaSE：Java Platform，Standard Edition（标准版）

　　Java中最通行的版本，包含Java核心类和GUI（图形用户界面）类

　　适合于开发桌面系统和低端商务应用系统。

JavaEE：Java Platform，Enterprise Edition（企业版）

　　包含开发基于Web的应用程序的类和接口，如Servlet、JSP、JDBC、EJB、JMS以及Enterprise JavaBeans等

　　为企业提供电子商务构架及Web服务的解决方案，领域涉及：办公自动化OA、客户关系管理CRM、企业资源计划ERP、营销管理、财务管理……等等，几乎你能够想到的所有应用。

JavaME：Java Platform，Micro Edition（微型版）

　　对传呼机、移动电话、掌上电脑、汽车导航系统、医疗设备、信息家电或其他无线设备等产品提供优化的运行时环境

　　是移动商务最佳的应用典范

特点

1. java是面向对象的编程语言（c语言：面向过程的编程语言）

2.可以跨平台

3.半编译半解释的语言

java中的关键字

关键字是由Java语言保留的、Java的开发和运行平台认识、并能正确处理的一些单词。关键字是在Java语言和Java的开发和运行平台之间的约定，只要按照这个约定使用了某个关键字，Java的开发和运行平台就能够识别它，并正确的处理它。

　　注意：

　　　　Java中的关键字也是随着版本的变化不断变动中的，不是一成不变的。

　　　　Java中所有的关键字都是小写。

　　　　Java中的goto、const是保留字，而非关键字。

　　　　表示类的关键字是class。

　　java关键字列表：

类、接口和枚举类型声明	class、extends、implements、interface、enum
包引入和包声明	import、package
基本数据类型	boolean、byte、char、double、float、int、long、short
某些数据类型的可选值	true、false、null
流程控制	break、return 、continue、switch、case、default、do、while、for、if、else
异常处理	try、catch、finally、throw、throws
修饰符	abstract、final、native、private、protected、public、static、synchronized、transient、volatile
操作符	instanceof
创建对象	new
引用	this、super
方法返回类型	void
保留关键字	const、goto

程序需注意的问题

　　1.程序的主类名与文件名必须一致。

　　（一个java文件中可以有多个类，只有一个类可以用public修饰，这个就是主类）

　　2.区分大小写（java是大小写敏感的语言）

　　3.main方法是程序的入口，有且只能有一个。

　　main方法前面的修饰词：public static void，缺一不可，(String[] args)固定的

　　4.每条语句都必须以分号结尾

　　5.代码中，除了要输出的内容和注释外，其他的都是英文状态下的。

　　6.一些成对的符号：{}, [], (), "", ''，必须成对出现。

　　7.代码的规范性：添加适当的注释

　　8.代码的可读性：适当的缩进

包

作用：

　　允许类组成较小的单元（类似文件夹），易于找到和使用相应的文件

　　防止命名冲突

　　更好的保护类、数据和方法

导入：　　

　　import 包名.类名;

变量

1.变量：

　　本质就是一块内存区域，用来存数据。在程序运行期间，值可以发生改变。

2.变量名：

　　命名规则：

　　　　1）只能由数字、字母、下划线、$组成，但是不能以数字开头

　　　　2）区分大小写

　　　　3）不能是关键字或保留字

　　　　4）长度没限制

　　　　5）中文的也可以（不推荐使用）

　　命名规范：

　　　　1）见名知意

　　　　2）骆驼命名法：name, stuAge

数据类型

1) 整型

类型名	大小(字节)	范围
byte	1(8bit)	-128~127
short	2(16bit)	-32768~32767
int	4(32bit)	-2147483648~2147483647
long	8(64bit)	-9223372036854775808~9223372036854775807

　　bit: 二进制位

　　byte: 字节，一个字节=8个二进制位

　　注意：

　　　　<1> long的数据后面一般要加L或l

　　　　<2> 数字可以是十进制、八进制（以0开头）、十六进制（以0x开头）的

　　变量的使用：

　　　1.声明：告诉计算机分配空间

　　　　数据类型变量名;

　　　2.赋值

　　　3.使用

　　　顺序不可更改。

2）浮点型：float, double

类型名	大小（字节）	范围
float	4(32bit)	-3.4E38 ～ 3.4E38
double	8(64bit)	-1.7E308 ～1.7E308

　　注意：

float类型的数据后面一定要加F或f，double类型的数据可以加D或d，（小数默认就是double类型的）
浮点型的数据都是近似值

3）字符型

　　char：2个字节，可以表示一个字符（数字、字母、符号、汉字）

　　注意：值必须用单引号引起来。

　　转义序列符：

　　\n：回车

　　\t：制表位（tab键）

　　\”, \’, \\

4）布尔类型

　　表示逻辑上的真或假。

　　boolean，取值：true， false

5）引用数据类型

　　string：字符串

　　不是基本的数据类型

　　可以表示多个字符，必须用双引号引起来。

类型的转换

1. 自动类型转换：

　　两种类型兼容，目标类型大于源类型：

　　byte-->short --> int --> long --> float -->double

　　char-->int

2. 强制类型转换：

　　两种类型兼容，目标类型小于源类型（会丢失精度）

　　格式：（目标类型）（要转换的表达式）

运算符

1. 赋值运算符：=

　　将等号右边的值赋值给左边的变量。

　　复合赋值运算符：+=, -=, *=, /=, %=

2. 算术运算符：

　　二元（双目）运算符：+, -, *, /, %

　　　　注意：除法：如果两边都是整数，则做整除运算

　　一元（单目）运算符：++，--

　　++：做前缀：先自增1，再取值

　　　　做后缀：先取值，再增1

3. 关系运算符：>, <, >=, <=, ==, !=

　　比较的结果是boolean

4. 逻辑运算符：&&, || , !

&&（并且）	a>3 && a<9	只有当两个表达式都成立时，结果才会真
\|\|（或者）	a>3 \|\| a<1	只要有一个表达式成立，结果就为真。
！（取反）	!(a>3)	取反

注意：&&，||，如果第一个表达式能判断整个式子的结果，第二个式子就不参与运算了

5. 位运算符

　　数值中的操作：

　　　　| 按位或（两数据对应位都是0，则该位为0，否则为1）

　　　　& 按位与（两数据对应位都是1，则该位为1，否则为0）

　　　　^ 按位异或（两数据对应位相反，则该位为1，否则为0）

　　　　<< 左移位

　　　　>> 右移位（左侧填充符号位）

　　　　>>> 无符号右移位

　　　　~ 按位取反（1变0 , 0变1）

　　　　（按位运算，必须先转成二进制的补码）

　　注意：&，|也可以用于逻辑运算，但是必须从头运行到尾

6.其他

　　运算符的优先级：高--->低

运算符	描述	结合性
()	圆括号	自左向右
!, ++, --,~ （一元）	逻辑非,递增, 递减，按位取反	自右向左
*, /, %	乘法,除法,取余	自左向右
+, -	加法,减法	自左向右
<<, >>,>>>	按位移动操作	自左向右
<, <=, >, >=	小于,小于等于,大于,大于等于	自左向右
= =, !=	等于,不等于	自左向右
&, \|, ^	位操作（&高于\|高于^）	自左向右
&&	逻辑与	自左向右
\|\|	逻辑或	自左向右
?:	条件运算符	自右向左
=,+=, *=, /=, %= ,-=	赋值运算符,复合赋值运算符	自右向左

　　（），一元，算术，关系，逻辑，赋值

条件结构

if else

1. 一种情况：

　　if(条件){

　　　　条件满足做的事情

　　}

2. 两种情况：

　　if(条件){

　　　　条件满足做的事情

　　}else{

　　　　条件不满足做的事情

　　}

3. 键盘输入：

　　创建对象：Scanner in=new Scanner(System.in);

　　需要导入包：import java.util.*;

　　　　int age=in.nextInt();

　　　　float height=in.nextFloat();

　　　　double weight=in.nextDouble();

　　　　String name=in.next();

　　　　char sex=in.next().charAt(0);

　　注意：输入之前一定要有提示。

switch

　　switch(变量){

　　　　case 值1:

　　　　　　语句块1;

　　　　　　break;

　　　　…….

　　　　default:

　　　　　　语句块;

　　　　　　break;

　　}

switch需要注意的问题：

　　1）switch可以判断整型（long除外）、char、String、枚举（jdk7.0开始）

　　2）只能做等值判断，不能做区间的判断

　　3）case后面值的类型必须与switch括号里变量的类型一致

　　4）case后面的值不允许重复

　　5）case块、default块的顺序可以改变

　　6）break的作用：结束switch语句

	多重if	switch
相同点	都能表示多种情况
不同点	能表示所有的多种情况	只能针对特定类型（byte,short,int,char, String, Enum）做等值判断

条件运算符

语法：

　　条件表达式?结果1:结果2;

　　int max=a>b?a:b;

while

语法：

　　while(循环的条件){

　　　　重复做的事情

　　}

特点：先判断，后执行。

如果条件一开始就不满足，循环一次也不执行。

do while

语法：

do{

　　重复做的事情

　　} while(循环的条件);

特点：先执行，后判断。

如果条件一开始就不满足，循环至少执行一次。

for

1. 语法：

　　for(表达式1; 表达式2; 表达式3){

　　　　操作

　　}

　　for(初始状态A; 循环的条件B; 循环变量的改变C){

　　　　操作D

　　}

　　执行顺序：A, B, D, C, B, D, C, B,D,C, ….. ,B

　　特点：先判断，后执行

　　适合于循环次数确定的循环。

注意：三个表达式都可以省略，分号不能省。

流程控制语句

1. break：能用于switch语句和循环语句。

　　循环：结束整个循环，跳到循环后面的语句去执行。

2. continue：只能用于循环语句。

　　结束本次循环，继续下一次循环。（跳过本次循环剩下的语句，继续执行下一次循环）

　　对于for循环：跳到表达式3继续执行。

　　对于while，do-while循环：跳到条件继续执行。（注意死循环）

数组

1. 数组：是一个特殊的变量，存储相同数据类型的一组数。

　　通过整型下标访问每一个数据，下标从0开始。

　　是引用数据类型的。

2. 使用：

　　//1)声明

　　　　int[ ] arr;

　　//2)分配空间

　　　　arr=new int[3];

　　//3)赋值

　　　　arr[0]=11;

　　　　arr[1]=12;

　　　　arr[2]=13;

　　　　arr[3]=14;

　　//4)使用

　　　　System.out.println(arr[0]+arr[1]);

注意：数组的长度必须>=1，可以是常量、变量、表达式，但是必须要有确定的值。

如果数组下标越界，会抛出以下异常：java.lang.ArrayIndexOutOfBoundsException

动态的求数组的长度：数组名.length

3.jvm的存储：

　　栈区：存放基本类型的数据，引用类型的地址

　　堆区：存放引用类型的实际数据

4. 给数组赋值：

　　1）单个赋值

　　2）循环赋值

　　3）边声明边赋值：

　　　　int[ ] a={11,12,13,14};

　　　　int[ ] b=new int[ ]{21,22,23,24,25};

　　　　int[ ] c; c=new int[ ]{31,32,33};

　　4）用已知数组给赋值：（慎重使用）

注意：数组是引用类型的，可以不赋值，系统会自动初始化（初始化成本类型的零值）

6. for循环的另外一种形式（for each循环）

　　for(变量：数组或集合){

　　　　操作

　　}

方法

完成某个功能的语句块。

1. 方法的基本格式：

　　public 返回值类型方法名(参数类型1 参数名1, 参数类型2 参数名2,…){

　　　　完成该功能的语句块

　　}

2. 参数：

　　方法声明时的参数称为形参（形式参数），

　　格式：参数类型1 参数名1, 参数类型2 参数名2,…

　　如果没有就空着。

　　public static void add(int a,int b){

　　　　int c;

　　　　c=a+b;

　　　　System.out.println("add(): "+a+" + "+b+" = "+c);

　　}

　　方法调用时给的值叫做实参（实际参数），可以是常量、变量，但是必须要是确定的值。

　　调用时，将实参的值传递给形参，所以形参与实参必须对应一致。

　　add(2,4);

3. 返回值类型：

　　1）没有返回值，返回值类型写void。

　　　　调用时直接调用方法名，例如：add(2,4);

　　2）有返回值，返回值类型与“return 值;”中的值的类型一致。

　　　　方法体中必须要有“return 值;”语句。

　　调用：需要用同类型的变量保存返回值，例如：int a=add(2,4);

　　return：表示方法调用结束，返回到主调方法。

　　　　1）”return ; ” 仅表示返回主调方法，不带值。

　　　　2）”return 值;” 表示返回主调方法，并带回值。

　　return 不能返回多个值。

4.方法重载：overloading

　　在同一个类中，方法名相同，参数列表不相同的多个方法。【同名不同参】

　　注意：

1. 参数列表不同：参数类型、个数、顺序至少有一项不同。
2. 与返回值类型、访问修饰符无关。
3. 方法调用时，根据参数列表来匹配。

5.可变参数：

　　public static void add(int a,int... args){

　　　　在方法中，将可变参数当成数组使用。

　　}

　　注意：一个方法最多只能有一个可变参数，并且必须放在末尾。

　　可变可以代表0个或多个参数。

6.递归调用：

　　直接的或间接的调用自己。（一般情况不建议使用）

比如求8的阶乘：

结果：

接口 interface

1. 语法：

　　public interface 接口名{

　　　　//数据成员，全部都是常量

　　　　[public] [final] 数据类型常量名=值;

　　　　//方法，全部都是抽象方法

　　　　[public] [abstract] 返回值类型方法名(参数列表);

　　}

　注意：

接口的访问修饰符：只能是public或默认的
数据成员（常量）默认由public、final、static修饰，所以可以省略

　　　如果public final static不写，系统会自动补上

方法都是由public、abstract修饰的，如果不写，系统自动补上

2.类实现接口：implements

3. 一个类可以实现多个接口

4. 接口也可以实现扩展：一个接口可以有父接口、子接口，继承也用关键字extends

　　一个接口可以有多个父接口

5. 抽象类与接口的区别（abstract class 与interface的区别）

抽象类	接口
都包含抽象方法都不能实例化，都必须通过子类去实现才有意义。
常量、变量	常量
抽象方法、非抽象方法	抽象方法
可以包含私有成员	全部都是public
一个类只能继承一个父类	一个类可以实现多个接口

6．instanceof ：检测对象的类型

　　格式：对象 instanceof 类型

　　只要是对象能自动转成该类型，就返回true，否则返回false

引用类型的转换

1. 自动转换：类型的自动提升

　　子类->父类，子接口->父接口，类->所实现的接口

　　注意：转换后，只能调用父类或接口中有的方法。

2. 强制转换：

　　类型自动提升后，可以强制转换回原类型或原类型的父类型

异常处理

java中的异常处理机制：

　Throwable的子类：

　　Error：错误，严重的错误，一般没有办法解决，所以也不解决

　　Exception：异常、例外，一般行的问题，一般情况可以提前预计到，或能处理

异常处理：try, catch, finally, throw, throws

1. 异常的处理

　　try{//有可能抛异常的代码及会受影响的代码

　　　　B (有可能抛异常)

　　}catch(类型 e){

　　　　//异常的处理

　　}finally{

　　　　//无论发生什么情况，都会执行

　　}

三种情况：

正常情况：A, B, C, E, F
出现异常，但可以捕获：A, B, D, E, F
出现异常，捕获不了：A, B, E,中断

注意：try后面可以有多个catch块：

　　顺序：先子类后父类

　　执行：最多只能执行一个catch块。

e.printStackTrace(); 打印错误的详细堆栈信息。

2. 手动抛出异常：throw

　　格式：throw 异常的对象;

　　用于程序员自定义的异常

3. 声明方法有可能抛出异常：throws

　　格式：public void a( )throws 异常类型{ }

Exception异常可以分为两个类：

　　运行时异常（runtimeException）：系统不强迫处理。

　　　　如：ArithmeticException，IndexOutOfBoundsException，NullPointerException，ClassCastException，……..

　　检查异常（checked Exception）：系统要求必须处理

类

一、Object：

位于包：java.lang

1. toString( )：返回该对象的字符串形式。

　　默认返回：类名@hashcode

　　如下需要，可以重写。

　　public String toString( )

代码实现：

创建Student：

public class Student {
    private int num;
    private String name;
    private int age;
    //
    public Student(int num, String name, int age) {
        this.num = num;
        this.name = name;
        this.age = age;
    }
    //
    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

创建测试类：

public class Test {
    public static void main(String[] args){
        Student student = new Student(12,"小明",18);
        System.out.println(student);
    }
}

结果：

Student中重写tostring方法：

public class Student {
    private int num;
    private String name;
    private int age;
    //
    public Student(int num, String name, int age) {
        this.num = num;
        this.name = name;
        this.age = age;
    }
    //
    @Override
    public String toString() {
        return "Student{" +
                "num=" + num +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    //
    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

则结果为：

2. hashCode( )：返回该对象的哈希码值

　　哈希码值：通过将该对象的内部地址转换成一个整数来实现的

　　如果两个对象有相同的哈希码，它们的内存地址不一定相同；但是，如果两个对象地址相同，哈希码一定相同。

　　一般不建议重写。

比如student2和student3的地址相同，则哈希码相同：

public class Test {
    public static void main(String[] args){
        Student student1 = new Student(12,"小明",18);
        Student student2 = new Student(13,"小华",19);

        Student student3 = student2;
        System.out.println(student1.hashCode());
        System.out.println(student2.hashCode());
        System.out.println(student3.hashCode());
    }

结果：

3. equals( )：判断两个对象的内容是否相同。

　　默认的，如果两个对象地址相同，返回true，否则，返回false。

　　一般重写的话采用自动生成的（一般equals( )和hashcode( )一起重写）

注意：

　　==：对于基本类型，比较的是数值是否相等，对于引用类型，比较的是地址是否相同。

　　equals：比较引用类型的内容是否相同。

4. clone( )：创建并返回此对象的一个副本

　　类要实现Cloneable接口，重写clone()方法。

5. finalize( )：垃圾回收时，调用此方法。

　　System.gc( );　　通知垃圾回收器回收

二、String类

位于java.lang包（默认导入的包）

由final修饰的，不能做为父类

1. 创建：

　　String s1="hello";

　　String s2=new String("hello");

三、正则表达式

Regular Expression

正则表达式定义了字符串的模式。

正则表达式可以用来搜索、编辑或处理文本。

正则表达式并不仅限于某一种语言，但是在每种语言中有细微的差别。

　　1.概念：能完成对字符串的一些判断【非逻辑性】

　　2. 作用：验证字符串是否合法

　　3. String的matches()方法

基本的正则表达式符号：

（API：字符类、预定义字符类、Greedy数量词）

字符类：

[abc]	a、b 或 c（简单类）
[^abc]	任何字符，除了 a、b 或 c（否定）
[a-zA-Z]	a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]]	a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]]	d、e 或 f（交集）
[a-z&&[^bc]]	a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]]	a 到 z，而非 m 到 p：[a-lq-z]（减去）

预定义字符类：

.	任何字符（与行结束符可能匹配也可能不匹配）
\d	数字：[0-9]
\D	非数字： [^0-9]
\s	空白字符：[ \t\n\x0B\f\r]
\S	非空白字符：[^\s]
\w	单词字符：[a-zA-Z_0-9]
\W	非单词字符：[^\w]

Greedy 数量词

X?	X，一次或一次也没有
X*	X，零次或多次
X+	X，一次或多次
X{n}	X，恰好n次
X{n,}	X，至少n次
X{n,m}	X，至少n次，但是不超过m次。

注意：

　　1）\d使用时应该是：”\\d”,\需要使用转义序列符。

　　2）.代表任意字符，如："."，如果要判断是否包含小数点，应该用"[.]"

　　判断是否有中文：String reg = "[\\u4e00-\\u9fa5]+";//是否包含一个或多个中文

posted on 2021-09-05 16:46 tom和mt 阅读(167) 评论(0) 收藏举报

刷新页面返回顶部