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)有参数有返回值的方法
在方法中:
变量=方法名(<参数列表>); //参数列表(实参)与形参匹配,这个变量的类型必须和返回值类型匹配
原文：https://www.cnblogs.com/hello4world/p/12089098.html