Java编程语言

写程序的叫：编译器

程序执行叫:（jvm）虚拟机

Java的特性：

纯面向对象

跨平台

Java的跨平台

 平台：win     mac    Linux

跨平台：

Java程序可以在任意操作系统上运行

通过jvm可以实现跨平台

总结：在需要运行的java应用操作系统，安装一个与操作系统对应jvm（java虚拟机）即可

JRE

是java程序运行环境，包括JVM和核心类库

JDK

是java程序开发工具包，包括JRE和开发工具

工具： 编译工具（javac.exe)    运行工具（java.exe）

Javac.exe负责编译     java.exe负责运行

一：创建自己项目的规则

命名规则：

项目名：首字母小写，第二个单词首字母大写

包名：小写字母

一般公司域名：www.softeem.com==com.softeem

类名：每一个单词首字母都大写

包名：就是文件夹，对类进行分类管理，方便快速查找，起名要见名知意

Src目录：用来存放编写的java代码

二：注释:

说明代码的含义

单行注释：//

多行注释：/*  */

文档注释：/**  */     工具javadoc.exe  生成帮助文档  类似说明书

Public  class  HelloWorld {

/*

*public 表示公开的

*class  类

*HelloWorld 类名

*/

//主函数main 固定格式（程序执行的入口）

Public  static  void  main  (String[] args){

/*

*public 表示公开的

*static 表示静态的

*void 表示无返回的

*main 方法名

* (string[] args) 表示参数

*/

//输出语句

System.out.println(“******”);

}

}

三：输出语句

//+ln系统向外换行打印+输出的内容

System.out.println(“******”);

//不换行打印输出内容

System.out.print(“******”);

四：转义字符

\n是换行

\t 制表符（tab键）

\u000d  表示换行

\b 倒退一个字符

\” 双引号

\\ 反斜杠\

五：变量

如何创建

数据类型  变量名=变量值

1.常用的基本数据类型：

数据类型              关键字

整数                   int

浮点                   double

2.string类型 ：字符串类型

3.拼接：+

String name=”李白”；

System.out.println(“我的名字叫：”+name);

输出结果：我的名字叫：李白

Public  class  demo01 {

Public  static  void  main  (string[] args){

Int min=lnteger.MIN_VALUE;    //获取int的最小值

Int max=lnteger.MAX_VALUE;   //获取int的最大值

Int  age=18;

double  ml=185.2；

String  a=”遇事不决 可问春风”

System.out.println(“年龄：”+age);

System.out.println(“身高：”+ml);

System.out.println(a);

}

}

输出结果是    年龄：18

身高：185.2

遇事不决 可问春风

scanner

1. 什么是scanner

接收键盘输入的   因此称呼为键盘扫描器

1. 如何创建？

Scanner  对象名=new  Scanner(System.in);

1. 如果使用

对象名.next类型（） ;

如果是string 直接next();

1. 关闭键盘扫描器

 in.close

Public  class  demo01 {

Public  static  void  main  (string[] args){

//获取键盘扫描器

Scanner   in=new  Scanner(System.in);

//提示用户输入

System.out,println(“请输入用户名字”)；

//接收键盘输入的信息   并赋值给name

String    name=in.next();

//提示用户输入

System.out.println(“输入年龄”)；

Int   age=in.nextint();

System.out.println(“姓名为：”+name+”\n年龄为：” +age );

//关闭键盘扫描器

in.close;

}

}

第二节课

一：Java数据类型

基本数据类型和引用数据类型

1. Java中的基本数据类型

基本数据类型分八种：（四大类）

整形 ：byte(字节)   short（短字节）   int   long

小数： double  float

判断： boolean        (真，假)

字符：char       （张，李）

2.八大基本数据类型的取值范围：

整形              字节             取值范围

byte               1                 -128到127

short 2 -32768到32767

Int (默认类型)         4            -2147483648到2147483647

long                8

注意：整数默认类型是int ，随意给long值的情况下，如果超出了最大值需要在后面加上L

浮点类型        字节             取值范围

float               4                单精度小数精度六-七位

double             8                 双精度小数精度 十六位

注意：浮点类型的默认是double  ,如果想将一个double给一个float在后面加f

字符       字节             取值范围

char         2                 0-65535  Unicode编码

String(字符串)

char  a=’男’；    string  b=”春风不解”

布尔            字节                 取值范围

boolean            1                true（真）/false（假）

boolean   a=false;

运算符：

算数运算符，逻辑运算符，关系运算符，赋值运算符

算数运算符：

+   加法

-   减法

*   乘法

/   除法

%   取余

++  自加1

--   自减1

在使用加法运算中，不可以与字符串相加，否则作为拼接

Int a=1  int  b=2

String  name=a+”名字”+b+a;

System.out.println(name);

输出结果：1名字21

++a表示自加1  前自增  先运算在赋值

a++ 表示    后自增    先赋值在运算   

在同一个表达式 有多个数据类型

double  d=12+12324L+8.5f+’a’;

boolean不能参与算式运算  其他的都可以

类型的级别

Byte  short  char ----------int-------long--------float---------double(级别最高)

数据类型转换：

分为自动转换和强行转换

1. 自动转换

小范围的数据赋值给大范围的，会自动转换为大范围的数据类型

1. 强行转换

大范围转小范围    写法：（类型）变量名

Int c=1;

Byte d=(byte)c;

Byte e=(byte)128;

int  d=(int)(12+12324L+8.5f+’a’);   //强行转换

比较运算符

1. ==  比较两边是否相等
2. >    大于
3. <     小于
4. <= 小于或者等于
5. >=   大于或者等于
6. !=    不等于

例题：

Public  class  demo01 {

Public  static  void  main  (string[] args){

System.out.println(“请输入钱”);

//获取键盘扫描器

Scanner in=new  scanner(system.in)

Int  a=in.nextint();

System.out.println(“请输入你的名字”);

String  name=in.next();

//charAt();   表示在这个字符在那个位置  从0开始计算

//调用方法  取得  第一个字

Char   cl=name.charAt(0);

Char   ci=(char)(cl+510);

System.out.println(“女方的名字”+ci)；

}

}

第三节课

一：逻辑运算符

&&  (短路与)               两边为true ,结果为true

                          一边为false,结果为false

                         短路的特点，符号左边为false 右边不在运算（短路）

||  （段落或）           两边为true，结果为true

但凡一边为true,结果为true

短路的特点，符号左边为true,结果为true 右边不在运算（短路）

！（取反）                ！false 结果是true

                         ! true结果是false

二：三目运算符

三目运算符的使用格式

条件表达式？   值1   ： 值2

               true      false

Int  a =50>40&&40>20?1:2;

System.out.println(a);

输出结果：1

嵌套：

a=45    b=25  c=60

Int  max=a>b?a>c?a:c ：b>c?b:c;

输出结果为60

三：Ramdom随机数

创建随机数

方法一:

Ramdom   对象名=new  Random();

//创建随机数

Ramdom  rd=new  Random();

//获取随机数   范围为1-20之间

Int  i=rd.nextInt(bound:20)+1;

System.out.println(“获取的随机数为：”+i);

System.out.println(rd.nextln(bound:100));      //写入100的话，范围是0-99

//负数

System.out.println(-rd.nextint());      -----随机出来的是负数

[重点]:

20+rd.nextInt(dound:80)   范围为[20----99]

方法二:

Math.random()

Math.random()     -----------在0-1之间随机生成一个小数

使用方法:

System.out.println(Math.random());

//生成0-10之间的是小数

System.out.println(Math.random()*10);

//生成0-10之间的整数

System.out.println((int)(Math.random()*10));

程序结构:(1)顺序结构,从头到尾 (2)选择结构if else

四:条件语句 if

1：if(条件表达式){

    .........语句

}

2:if(条件表达式) 语句;     单独的if可以不加括号{}

3：if(条件表达式){

     .......语句

}else{

}

4:if(条件表达式){

}else  if(条件表达式){

}else{

}

列题：

if(a>b){

System.out.println(”去攀岩“)；               //if成立执行

}else  if(a==b){                               //if不成立执行else if ,判断if

System.out.println(”去爬山“)；

}else{                                       //判断if不成立，执行下面的else

System.out.println(”去旅行“)；

}

![重点]!

If  else来进行比较字符串

//判断字符串内容是否一致使用equals

比较内容.equals(要比较的内容)

比较内容.equals IgnoreCase(要比较的内容)  作用是可以忽略大小写

例题:

String a=in.next();

String b=in.next();

If(a.equals(b)){

 System.out.println(“正确”);

}

选择结构switch case:

条件比较规律,需要进行分类的时候使用

格式:

switch(整数表达式或者字符串){

case 结果1:  语句1;   break;

case 结果2:  语句2;   break;

case 结果3:  语句3;   break;

...........

      default: 语句;

}

case :针对括号的里面计算内容进行匹配

default :找不到对应的case,去执行default后面的语句

switch映射到对应的case以后,如果加break终止,会一直往下执行下面的case,不管是否满足都会执行

例题:

  Scanner in=new Scanner(System.in);

  //输入年龄

int  a=in.nextInt();

  

  switch(a/10){

      Case 1:

          System.out.println(“儿童”);

Case 2:

          System.out.println(“少年”);

Case 3:

          System.out.println(“中年”);

Case 4:

          System.out.println(“老年”);

      default:

          System.out.println(“你输入有误,请从新输出”);

}

五：循环

for循环    while循环    do.......while循环

一:While循环

语法结构

While(条件表达式或者条件运算){  

}

用法:

1.定义计数器(记录循环次数)

Int  a=0;

2.用计数器构成条件语句

while(a<10){

 3.让计数器逐渐接近条件语句的临界值

a++;

}

2.break:是循环终止的意思

列题：

Public  class  demo01 {

Public  static  void  main  (string[] args){

//计数器

Int  a =0;

While(a<3){

 System.out.println(“循环”)；

a++;

break;}                 -------break终止结束循环

}   }

二:do.......while循环

do{

代码块

}while(条件表达式或者条件运算);

先执行一次代码块,再去判断条件语句,如果成立就循坏执行代码块,直到条件不成为止

案例:用于登陆功能

for循环

格式:

for (表达式1; 条件表达式; 表达式2){

代码块

};

格式说明:

表达式1:一般情况下,表达式1用于定义计算器

条件表达式:一般情况下,用计算器构建条件语句

表达式2:一般情况下,让计算器逐渐接近条件语句的临界值

列题:

Int n=0

for(System.out.print(1);n<3;System.out.print(2) ){

 System.out.print(3);

n++;

}

输出结果为: 132

           32

           32

  

注意:

1.表达式1最先执行,并且只执行一次

2.条件表达式第二个执行

3.如果条件表达式成立,就先执行代码块

4.代码块执行完之后,再去执行表达式2,表达式2执行完之后,再去判断条件表达式,依次循环

for循环嵌套

for(;;){

for(;;){}

}

双重for循环

外层的循环,先执行一次,里层的循环要全部执行完毕

里层的for循环执行完毕之后,才开始外层for循环的下一次循环

列题:

//验证码池子

String codePool=”QWERTYUO1223245姑羡”

//从验证码池子中随机五个字符出来拼接成验证码

//创建随机数

Random rd=new  Random();

//定义一个存放验证码的变量

String  code=””;

//循环五次,每次随机一个字符

for(int i=0;i<5;i++){

//在字符串长度范围内生成随机数,用来从验证码池子中随机抽取字符

[重点]

//获取字符串的长度(字符串中有多少个字符)

//用法  字符串.length()

int  index =rd.nextint(codePool.length());

//随机拿取一个验证码的位数的字符

Char c=code.charAt(index);

[重点]

//每取出一个字符,追加到验证码的末尾

Code+=c;

}

System.out.println(“验证码为:”+code);

//创建键盘扫器

Scanner in=new Scanner(System.in);

//接收输入的内容

String shuru=in.next();

//比较字符串内容是否相等,并且忽略大小写

If(shuru.equalsignoreCase(code)){

System.out.println(“输入正确”);

}

}

 for   (当多重循环时)

1. 可以给循环加标记,加标记的方式  标记名:
2. 在break的时候,使用break 标记名;可以结束指定的循环

列如:

out:for(int i=1;i<=10;i++){

for(int j=1;j<=4;j++){

If(j==3){

//这里的break out;结束指定循环

break out;

}

}

}

While  do  while  for循环:三个循环分别什么时候使用

1. 如果知道具体循环次数的,推荐使用for循环
2. 如果不知道循环次数的,推荐使用while循环
3. 如果要确保循环次数内容至少执行一次,推荐do while循环

数组

Java中的数组:java中可以用来存放多个数据类型相同的数据

定义数组的方式:

方法一:

类型 [] 数组名 =new 类型[长度];

方法二:

类型 [] 数组名={值1,值2,值3........值n};

方法三:

类型 [] 数组名=new 类型[]{值1,值2,值3........值n};

格式一:适用于不清楚数组中具体会存放那些数据时

格式二.格式三:适用于知道数组的具体存放的数据时

使用数组需要注意的问题:

1. 定义数组时,必须指定数组长度.
2. 数组中数据的数据类型必须一致
3. 数组的长度一旦创建(定义)成功,不可改变,改变之后就会产生新的数组

格式:

定义数组的格式一: 

//定义了一个可以存放4个int类型整数的数组

int []  nums=new  int[4];

//定义了一个可以存放7个String类型字符串的数组

String []  names=new  String[7];

定义数组的格式二:

String [] wifes={“姑苏” , ”羡” , ”忘”};

double [] salary={100.0 , 200.0 , 300.0};

定义数组的格式三:

int [] arys=new  int[]{4 , 5 , 6 , 7 };

[注意]:

//直接输出数组,会输出数组在内存中的地址值

//如果想要格式化输出数组内容:   Arrays.toString(数组名)

System.out.println(“数组的内容为:”+Arrays.toString(wifes))

数组中常用的方法:

1.格式化输出数组:  Arrays.toString(数组名)

2.获取数组的长度:  数组名.length

3.获取数组在某个位置(下标)上的元素:  数组名[下标]

4.修改数组中某一个位置上的元素:  数组名[下标] = 值;

5. 数组的排序: Arrays.sort(数组名);                       // 顺序从小到大

6.数组的扩容和缩容:Arrays.copy0f(原数组,扩容或缩容之后的数组的长度)

      如果copy0f之后的数组长度小于原数组的长度,就是缩容

      如果copy0f之后的数组长度大于原数组的长度,就是扩容

      扩容和缩容都是在数组的末尾处进行的

注意:

 扩容和缩容之后,都会产生新的数组,原来的数组就不存在了

注意:

获取字符串的长度:  字符串名.length()

第二条:获取数组的长度:

System.out.println(“数组的长度为:”+数组名.length);

第三条:获取数组在某个位置(下标)上的元素:

注意:

数组是从0开始的

System.out.println(“数组的第3个内容为:”+数组名[2]);

第四条:修改数组中某一个位置上的元素:

其他的数组内容不会发生改变

wifes[3]=”姑苏”;

System.out.println(Arrays.toString(wifes));

数组的遍历(将数组中的元素逐个访问到):

//获取数组第一个元素:
System.out.println(数组名[0]);

//访问数组最后一个元素

方式:

数组名.length-1;

System.out.println(数组名[数组名.length-1]);

遍历for循环(固定格式):

//循环中的i表示 数组的下标;

//要遍历数组 i需要从 0   到   数组名.length-1      逐渐增加

for(int i=0 ;  i<数组名.length-1 ;  i++){

}

第五条:数组的排序

一般是从小到大排序的

格式:  

Arrays.sort(数组名);

例如:

Arrays.sort(数组名);

System.out.println(“排序之后的分数”+Arrays.toString(数组名));

六:数组的长度一旦定义成功,不可改变,改变之后就会产生新的数组

String[] wifes={“姑””苏””羡”};

//不可以这样改变

wifes={“姑””苏””羡””羡”}

数组的扩容和缩容

数组的扩容:在数组中扩充位置

格式:

Arrays.copy0f(原数组,扩容或缩容之后的数组的长度)

wifes=Arrays.copy0f(wifes, newLength:wifes.length+1);     //在末尾扩充一个位置

//如何扩容或缩放的位置是数字,就是代表数字的长度是多少

wifes=Arrays.copy0f(wifes, 2);   

二维数组

Java 中没有严格意义的二维数组,所谓的二维数组就是数组中的数组

(一:)二维数组  (格式):

一:

数据类型[][] 数组名 = new 数据类型[有多少个一维数组]

[每个一维数组中有多少个元素]

二:

数据类型[][] 数组名 = new 数据类型[有多少个一维数组]

[每个一维数组中有多少个元素]{{},{}}

用法:

1. :

int[][] array = new int[2][3];

1. :

int[][] array = new int[][]{{1,2},{3,4},{5,6}};

(二:)输出二维数组中的一维数组:

(1):int类型输出需要加:Arrays.toString();

int[] [] a=new int[][]{{1,1,1},{2,2,2,2},{3,3,3,3,3}};

System.out.println(Arrays.toString(a[1]));

(2):String类型输出需要加:Arrays.toString();

String[][] n=new String[][]{{"姑苏","姑苏"},{"云梦","云梦"}};

System.out.println(Arrays.toString(n[0]));

(3):cher类型正常输出即可

char[][] b=new char[][]{{'a','b'},{'v','n'}};

System.out.println(b[0]);

(三:)输出二维数字中的某个元素:

a[1][1];                 n[1][1];               b[1][2];

(四:)获取二维数组中有几个一维数组

char[][] chars =new char[][]{{'a','b','c'}, {'d','e','f','z'},{'g','h','i'}};

方法:

二维数组名.length;

System.out.println("二维数组的长度"+chars.length);

(五:)获取第一个一维数组中有多少个元素(长度) 

System.out.println("第一个一维数组中有多少个元素"+chars[0].length);

例题:

//二维数组的遍历 -->双重for

// 这个for循环遍历的是有多少个一维数组

for (int i= 0;i<chars.length;i++){

//内循环遍历每个一维数组中有多少个元素呀

for (int j = 0;j<chars[i].length;j++){

System.out.print(chars[i][j]+"\t");

}

System.out.println();

} }

}