java 初始值不确定 通过运算得出_Java基础

Java强类型语言,严格区分大小写,杜绝一切不确定性

类名规范:帕斯卡命名法(所有单词首字母大写)

1.变量

1)什么是变量

java中的变量就是变化数值的载体

2)变量的声明 int x; int a,b,c;

3)变量的初始化 x=3; 合二为一 int x=3; int a=10,b=3,c=33;

4)变量的使用 将变量中的值"取"出来

System.out.println(x);

int y=x+10;

5)注意事项

5.1)变量不能重复声明

5.2)赋值的类型必须匹配

5.3)变量必须声明,赋初值之后才能使用

2.变量的命名

1)规则

字母,数字,_,$组成,数字不能开头

不能是关键字

2)规范

英文

见名知意

驼峰命名法

7/1 PM

java的两种数据类型

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

4个整数

1) byte 1字节 -127~128

2) short 2字节 -32768~32767

3) int 型 4字节 -21亿~21亿(-2^31~2^31-1) 计算结果超过int取值范围会出现溢出现象

4) long (长整型) 8字节 很大(-2^63~2^63-1) 较常用的整数类型 int类型无法保存的时候使用 900多亿亿

如果直接量的值超过了int的范围在该值后面加l或L

使用long型接收System.currentTimeMillis() -->时间偏移量 1970-1-1 00:00:00到现在经过的毫秒数

2个小数

5)float (浮点,单精度) 4字节

接收小数类型数据 直接给float赋值在直接量后加f或F float不经常使用

6)double (双浮点,双精度) 8字节 java中小数默认是double类型

java中常用的小数类型 所有浮点类型运算过程中,计算结果可能产生舍入误差(如0.1+0.2)

2个非数

7)char (字符型) 2字节 0~65535 存储单个任意字符 用''将字符括起来

一个字符实际上就是对应的数字 a--97 A--65 0--48

特殊字符 用转义符\ 比如输出' " \

8)boolean (布尔型) 1字节 表示真假的类型 只有true和false两个取值

二 java的直接量

直接量:直接编写在代码中的数字

java中的直接编写的整数类型是int

数据类型的转换

1)数据类型转换的原因

java中只允许相同数据类型的数据进行计算,而计算结果还是这个数据类型

2)自动类型转换(隐式类型转换)

当两个不同数据类型的数据进行计算时 较小的数据类型会自动转换为较大的数据类型

计算的结果是较大的数据类型

小 大

byte short int long float double

char

byte和short和char的计算最终结果是int

3)强制类型转换(显式类型转换)

当两个数据类型的数据进行计算时 如果想得到的结果是较小类型的数据 可以使用强制类型转换实现

将一个类型的数据转换成指定的另一个类型 产生精度丢失

()

double d=12.9;

int i=(int)d;

7/2 AM

JDK 环境变量搭建

1.计算机(右键)-->属性-->高级系统设置-->高级-->环境变量

2.系统变量:新建变量JAVA_HOME,值为JDK的安装根目录

新建变量CLASSPATH,值为.

3.编辑变量Path,在原内容的末尾添加%JAVA_HOME%\bin

一.用户输入

1)在public class xxx上面编写

import java.util.Scanner;

2)在main方法的第一行

Scanner scan=new Scanner(System.in);

3)使用scan实现用户输入为变量赋值

double weight=scan.nextDouble();

int age=scan.nextInt();

运算符和表达式

1)什么是表达式

表达式就是数学中的算式的概念

只要是计算,就是表达式

2)算数运算符

+ - * / %

2.1)java中也遵循先乘除后加减的运算优先级

相同优先级遵循从左往右计算

2.2)手动修改优先级

使用(),而且可以()嵌套使用

2.3)计算除法,注意除数不能是0

如果除数是0会发生异常

2.4)%号 求模运算,取余数

也是除法运算,只是结果就是除法得到的余数

1.判断某个数能否被另一个数整除

2.将一个数字的某一位取出.

小结:数和数算得数

3)关系运算符

> < >= <= == !=

小结:数和数算得真假

4)逻辑运算符

&&(与) ||(或) !(非)

&&:左右两边必须同时为true,结果才为true

||:左右两边只要有一边为true,结果就为true

左边 右边 && ||

true true true true

true false false true

false true false true

false false false false

!:将true变false,将false变true

小结:真假和真假算得真假

逻辑运算符的短路特性

当 && 左边是false时,右边的表达式就不运行了

当 || 左边是true时,右边的表达式就不运行了

5)赋值运算符

=

功能:将=右边的值(或变量的值),赋给=左边的变量

复合赋值运算符

+= -= *= /= %=

int x=10; x+=5; //x=15

int x=10; x+=5.2; //x=15,因为x+=5.2等价于x=(int)(x+5.2);如果是x=x+5.2会报错!

//因为x+5.2是int+double=double,结果再赋值给int的x会出错!

-------->面试题知识点(内部包含一个隐式的强制类型转换)

6)字符串连接符

+

"Hello World"+123----->"Hello World123"

功能:将字符串和变量或数值进行连接

7)自增自减运算符

++ --

一个变量和自增自减运算符连接

效果就是当前变量的值自增1或自减1

运算符在变量右侧时,变量会先自增或自减,但表达式会取自增或自减之前的值

运算符在变量左侧时,变量会先自增或自减,而且表达式会取自增或自减之后的值

8)条件运算符(三目运算符)

? : ?:

当一个判断的真或假来决定一个变量的值时就可以使用三目运算符

Java中的程序结构

1)顺序结构:编写的每行代码一定会执行一次

2)分支结构:编写的代码可能会执行一次

3)循环结构:编写的代码可能会执行多次

分支结构

根据某个条件的真或假,决定是否运行某段代码

1)单分支

if语句

if () {

//当条件为真时运行的代码

}

{}可以省略,但是不写{}只对一行代码生效,所以不建议省略

闰年:能被4整除并且不能被100整除或者能被400整除 y%4==0 && y%100!=0 || y%400==0

2)双分支

当某个条件满足时运行指定代码A,当某个条件不满足时运行指定代码B

if-else语句

if(){

//条件为真运行这里的代码

} else{

//条件为假运行这里的代码

}

7.3 AM

多分支结构

1)if-else-if(多重if)

语法格式

if(条件1) {

//条件1为真时运行

} else if(条件2) {

//条件1为假,条件2为真时运行

} else if(条件3) {

//条件1,2为假,条件3为真时运行

} else {

//条件1,2,3均为假时运行

}

1.1)else if的数量是不限的

1.2)else 是可以省略的

1.3)多重if结构只能运行其中的一个代码块

1.4)判断条件的顺序是有要求的

2)switch 结构

运行效率高,使用更灵活

2.1)语法结构

switch ([整数表达式]) {

case [常量1]:

//当整数表达式值为常量1时运行

break;

case [常量2]:

//当整数表达式值为常量2时运行

break;

......

default:

//没有任何常量匹配整数表达式时运行

}

整数表达式:最终结果是整数的算式,通常情况下,可能是变量

整数表达式只能是byte,short,char,int类型 JDK1.7之后支持String

2.2)break 关键字

功能:终止switch代码的运行,继续运行switch{}之后的内容

2.3)switch每个case里没加break会出现case穿透,switch的{}里是顺序结构

3)多重if和switch结构的小结

多重if优点:特别适合于判断一个值在一个范围的情况

switch结构优点:使用灵活,结构简单.运行效率高,特别适合于等值判断时

(整数表达式在编译时已经选择了运行哪个case,不用一个个判断)

循环结构

编写的代码可能被执行多次

1)什么是循环

程序中反复执行相同或相似代码的现象

1.1)循环的要素

1.循环次数(循环变量)

2.循环条件

3.循环操作

4.变量更新

代码冗余:重复的很多相同或相似的代码.导致程序维护困难

2)while 循环结构

while (条件) {

//条件为真时运行的代码

}

7.4 AM

随机数的生成:

import java.util.Random;

public class Randomdemo {

public static void main(String[] args) {

// 生成随机数

Random ran=new Random();

// int num=ran.nextInt(10); //0~9

int num=ran.nextInt(99)+1; //1~100

System.out.println(num);

}

}

循环结构(下) 循环也叫迭代

1)do-while 循环

do{

//条件为真时运行的代码,至少运行一次

}while(条件);

2)while和do-while的区别

while循环是先判断,后执行,如果初始条件不满足一次都不执行

do-while循环是先执行,后判断,如果初始条件不满足,也会执行一次 while比do-while多判断一次

3)for循环

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

//循环操作

}

3.1)通常情况下:

表达式1:编写循环变量的定义和赋值(可以编写多个变量)

表达式2:编写循环条件

表达式3:编写变量的更新

3.2)表达式注意事项

1.三个表达式均可不写,两个分号必须有.表达式2(循环条件),省略后默认为true

2.表达式1可以利用声明多个变量的语法

3.表达式3可以用,分割运行多个语句

4)循环结构小结

4.1)循环次数固定:首选for循环

4.2)循环次数不确定:

一定会至少执行一次的:do-while

有可能一次都不执行的:while

4.3)while和for都是先判断后执行的

do-while是先执行后判断

5)循环中的流控语句

5.1)break

switch结构中使用break,效果:终止switch结构运行,运行之后的语句

循环结构中也可以使用break,效果:终止循环结构,运行循环结构之后的语句

5.2)continue

只能使用在循环结构中,效果:跳过本次循环没有运行的内容,直接进入下次循环

6)循环嵌套

6.1)循环结构中包含着另一个完整的循环结构

6.2)循环嵌套可以嵌套在任意层次

6.3)while/do-while/for 可以相互嵌套

6.4)我们将先出现的循环结构称为外层循环,在这个循环结构中出现的循环称为内层循环

6.5)内层循环中若出现break或continue,作用的是内层循环

6.6)外层循环循环一次,内层循环循环一遍

7.5

数组

1)什么是数组

数组就是一组相同数据类型数据的集合

一个变量保存多个数据 (一种容器)

2)为什么需要数组

程序中操作多个(相同类型)变量不方便,使用数组能简化这些繁杂冗余的操作

优点:可以自动给元素从0开始编号,方便操作这些元素,该编号又称下标/角标/索引.可以统一管理

3)数组的构成

3.1)数组名

3.2)数组元素(数组里面的数据)

3.3)一个数组数据的容量称为:数组长度

3.4)数组中每个元素都有编号称为数组下标

4)数组特征

4.1)数组的长度是固定的

4.2)数组中只能保存相同数据类型的数据

4.3)数组元素是有默认值的

(0(整数&char)/0.0/false/null)

5)数组的声明

int[] arr; ------>官方推荐 int arr[];-------->可以用,但不推荐

6)数组的初始化

arr=new int[5]; //arr初始化为一个int类型长度为5的数组

声明的类型和初始化的类型必须一致

数组中的元素采用默认值

声明和初始化合二为一 int[] arr=new int[5];

注意事项:

注意1.

int[] arr2;

arr2 = {1,2,4,5};//编译错误!这种定义数组的格式要求声明的同时要赋初值

注意2.

int[] arr=new int[5]{1,2,4,5,6};//编译错误!java是强类型语言,严格区分大小写,杜绝一切不确定性

//如果中括号中填写的数值与大括号中元素总数不一致,会出现不确定性

7)数组元素的赋值

[]

arr[0]=6;

输出/使用元素的值

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

8)初始化同时赋值

int[] arr={8,2,7,6,3}; double[] arr={5.6,3.3,5.3,6.7};

声明和赋值分开:

int[] arr;

arr=new int[]{3,4,5,2};

9)数组的输出/使用

9.1)数组名是不能直接输出(输出不是想要的内容,是引用)

9.2)可以通过数组名.length获得数组长度

9.3)数组元素的下标范围

0~数组长度减1 0~arr.length-1

9.4)从数组中使用下标访问元素时,避免下标越界

9.5)要想访问数组中所有的元素,需要结合循环结构对数组进行遍历

int[] arr={1,3,4};

System.out.println(arr[3]}; //编译正确,运行错误,ArrayIndexOutOfBoundsException,下标越界异常

arr.length;//"."代表的,.length代表长度,表示访问arr数组的长度

System.out.println(arr);//[I@12de3245 句柄

9.6)遍历

a.可以通过循环输出数组下标进行遍历

b.可以通过调用静态方法实现数组遍历 System.out.println(Arrays.toString(arr));

10)数组是引用数据类型

10.1)认识引用

当两个数组名引用同一个数组时,数组A对元素的修改会影响数组B的内容

原因就是数组A,B引用相同

10.2)要想修改数组A不影响数组B,就需要保证他们不是相同的引用,使用数组复制来完成

11)数组复制

11.1)什么是数组复制

就是在目标数组中复制源数组的数据内容的操作,而且两个数组引用不相同

11.2)数组复制的实现

11.2.1)编写代码复制---->不推荐 定义新数组B,用循环遍历将数组A的元素复制到数组B中,即完成了数组的复制

11.2.2)System.arraycopy();

System.arraycopy( 1 , 2 , 3 , 4 , 5 ) //通过类名打点调用静态方法,实现数组复制

1.源数组 2.源数组复制起始位置 3.目标数组 4.目标数值起始位置 5.复制的元素个数

11.2.3)Arrays.copyOf(); 需要import java.util.Arrays;

Arrays.copyOf( 1 , 2 ); 1.源数组 2.复制的个数

这个方法特别适合于对现有数组的扩容和缩容的操作

12)数组排序

12.1)什么是排序

将数组中的数据按照从大到小或从小到大方式进行排列

12.2)排序的好处

根据某个条件进行排序后,方便我们观察使用数据

12.3)如何对数组进行排序

12.3.1)使用系统提供的Arrays.sort() 只提供升序排序的功能 静态方法调用

静态方法-----类名打点调用的

程序=算法+数据结构

7.8

方法

1)什么是方法

java程序中,处理一个功能或业务的代码块

2)为什么要用方法

2.1)将处理不同业务的代码从程序入口中分离出来,降低代码的复杂度

2.2)每个方法专心的编写自己的业务,不和其他业务干扰

2.3)各种方法在main方法中调用,方便团队开发

2.4)方法可以编写一次,调用多次

3)方法的定义

3.1)无参数无返回值的方法

在public class XXX的{}中

public static void 方法名(){

//方法代码(方法体)

}

3.2)无参数有返回值的方法

public static 方法名() {

//方法体

return ;

}

返回值类型:这个方法运算结果的数据类型

return关键字:

1.返回方法的结果,结果的数据类型必须匹配方法的声明

有返回值的方法必须通过return返回

2.运行到return关键字时,方法直接终止

无返回值的方法也可使用return,但是只是终止方法的含义(终止return后面语句的执行)

3.3)有参数无返回值的方法

public static void 方法名(){

//方法体

}

有参数的方法,需要在方法定义时编写参数列表

参数列表的格式

方法名(参数类型1 参数,参数类型2 参数,...)

方法定义时声明的参数,称之为形式参数(形参),在方法中把形参看做是已经被赋值的变量

3.4)有参数有返回值的方法

public static 方法名() {

//方法体

return ;

}

结合了有返回值和有参数方法的注意事项

4)方法的调用

4.1)无参数无返回值的方法:

在方法中:

方法名();

4.2)无参数有返回值的方法:

在方法中:

变量=方法名(); //这个变量的类型必须和返回值类型匹配

4.3)有参数无返回值的方法

在方法中:

方法名();

带参数的方法,需要在调用时传入参数

参数列表的形式

方法名(参数1,参数2,...),调用方法时,参数列表称之为 实际参数(实参)

传入的参数的类型/个数/顺序必须和方法定义时的匹配

4.4)有参数有返回值的方法

在方法中:

变量=方法名(); //参数列表(实参)与形参匹配,这个变量的类型必须和返回值类型匹配