Java学习
整数类型：
byte 1个字节，short 2个字节， int 3个字节，long 8个字节。
浮点类型：
float 4个字节，double 8个字节，
字符类型：
char 2个字节
银行业务不能用浮点数进行比较，用BigDecimal（数学工具类）
所有的字符本质上还是数字。
转义字符： \t 制表符 空格
\n换行
类型转换：由 低到 高
byte,short,char,int, long,float,double，不同类型要转换为同一类型在运算
变量
数据类型 变量名=值；
"" +a+b 字符串连接符（把两个数字连接）
a+b+"" 正常值运算
三元运算符：
x ? y : z
如果x=true,则结果为y,否则结果为z;
用户名交互 Scanner
语法：
//从键盘输入
Scanner scanner = new Scanner(System.in);
System.out.println("请输入内容");
String str = scanner.nextLine();
System.out.println("输出的内容" + str);
//关闭数据流
scanner.close();
例题：
//输入很多数字，并求其总和 平均数，每输入一个输入按回车键确认，通过输入非数字来结束进程
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数字：");
//计算和
double sum = 0;
//统计输入了多少个数据
int i = 0;
//通过循环判断是否还有数据输入，并在里面进行求和统计
while (scanner.hasNextDouble()){
double x = scanner.nextDouble();
//递增运算
i = i+1;
//看输入了多少个数字累加求和
sum = sum+ x;
System.out.println("你输入了第" + i + "个数据，当前结果是sum=" + sum);
}
System.out.println("个数的和为" + sum);
System.out.println("个数的平均值为" + (sum / i));
scanner.close();
}
流程控制
顺序结构，选择结构，if结构，switch选择结构
equals:判断字符串是否相等
关于idea反编译：在项目找到文件路径，用此电脑打开，把.class文件拷贝到idea里
//计算0-100之间奇数和偶数的和
int o=0;
int e=0;
for (int i = 0; i <= 100; i++) {
if (i%2!=0){
o+=i;
}else {
e+=i;
}
}
System.out.println("奇数的和" + o);
System.out.println("偶数的和" + e);
}
while循环
while(布尔表达式){
//循环内容 }
while和do-while区别
while：先判断后执行
do-while：先执行后判断（保证至少循环一次）
break：用于强行退出循环，在switch 语句
continue：用于终止某次循环，跳过循环尚未执行语句，接着进行下一次是否执行循环的判定
例题:
//用while或者for循环输出1-1000之间能被5整除的数，并且每行输出3个
for (int i = 0; i <= 1000; i++) {
if (i%5==0){
System.out.print(i + "\t");
}
if (i%(5*3)==0){
System.out.println();
}
}
//print输出完不换行
//println输出完会换行
}
//打印99乘法表
for (int j = 1; j <= 9; j++) {
for (int i = 1; i <= j; i++) {
System.out.print(j+"*"+i+"="+(j*i) +"\t");
}
System.out.println();
}
}
方法
语句的集合，在一起执行一个功能
方法的调用
调用方法：对象名.方法名（实参列表）
当方法返回一个值时，方法调用通常被当作一个值，例如：
int larger =max( 30,40)
如果方法返回值是void，方法调用一定是条语句。
System.out.println("hello,world");
方法的重载
重载就是在一个类中，有相同的函数名称，但形参不同的函数。
方法重载规则：
方法名必须相同
参数列表必须不同（个数不同，类型不同，参数排列顺序不同）
方法的返回类型可以相同也可以不同
仅仅返回类型不同不足以成为方法的重载。
double max = max(10.00,30.00);
System.out.println(max);
}
//比大小（方法的重载）
public static double max(double num1,double num2){
double result = 0;
if (num1==num2){
System.out.println("num1==num2");
return 0;//终止方法
}
if (num1>num2){
result = num1;
}else {
result = num2;
}
return result;
}
//比大小
public static int max(int num1,int num2){
int result = 0;
if (num1==num2){
System.out.println("num1==num2");
return 0;//终止方法
}
if (num1>num2){
result = num1;
}else {
result = num2;
}
return result;
}
递归
正常A方法调用B方法
递归：A方法调用A方法，就是自己调用自己。
递归结构：
递归头：什么时候不调用自身方法，如果没有头，将陷入死循环。
递归体：什么时候需要调用自身方法。
数组
数组就是相同类型数据的有序结合
数组描述的是相同类型的若干个数据，按照一定先后排列组合而成
其中，每一个数据称作一个数组元素，每个数据元素可以通过下标来访问他们。
int[] nums;//声明一个数组
nums = new int[5];//创建一个数组
//给数组元素赋值
nums[0]=1;
nums[1]=2;
nums[2]=3;
nums[3]=4;
nums[4]=5;
//计算所有元素的和
int sum=0;
//获取数组长度：arrays.length
for (int i = 0; i <nums.length ; i++) {
sum =sum+nums[i];
}
System.out.println("总和为：" + sum);
}
基本特点：
1.长度是确定的，数组一旦被创建，大小是不能改变的。
2.元素必须是相同类型，不允许出现混合类型。
3.数组的元素可以是任何数据类型，包括基本类型和引用类型。
4.数组变量属于引用类型，数组可以看成是对象，数组中每个元素相当于该对象成员变量。
数组本身就是对象，Java中对象是在堆中的，因此数组对象本身是在堆中的。
//静态初始化：创建+赋值
int a[]={1,2,3,4,5,6,7,8};
System.out.println(a[0]);
//动态初始化：包含默认初始化
int[] b = new int[10];
b[1] = 10;
b[2] = 20;
System.out.println(b[1]);
System.out.println(b[2]);
小结：
数组是相同类型数据的有序结合
数组也是对象，数组元素相当于对象的成员变量
数组长度是确定的，不可变的，如果越界，则报错：ArrayIndexOutofBounds
数组的使用
int[] arrays ={1,2,3,4,5};
//打印全部元素
for (int i = 0; i <arrays.length ; i++) {
System.out.println(arrays[i]);
}
System.out.println("===========================");
//计算所有元素的和
int sum = 0;
for (int i = 0; i <arrays.length ; i++) {
sum=sum+arrays[i];
}
System.out.println("sum=" + sum);
System.out.println("===========================");
//查找最大元素
int max=arrays[0];
for (int i = 1; i <arrays.length ; i++) {
if (arrays[i]>max){
max = arrays[i];
}
}
System.out.println("max=" + max);
}
反转数组
public static void main(String[] args) {
int[] arrays ={1,2,3,4,5};
int[] reverse =reverse(arrays);
printArray(reverse);
}
//反转数组
public static int[] reverse(int[] arrays){
int[] result = new int[arrays.length];
//反转的操作
for (int i = 0,j=result.length-1;i <arrays.length ; i++,j--) {
result[j] = arrays[i];
}
return result;
}
//打印数组元素
public static void printArray(int[] arrays){
for (int i = 0; i <arrays.length ; i++) {
System.out.println(arrays[i] + "");
}
}
多维数组
public static void main(String[] args) {
//[4] [2] 4行2列
// 1,2 array[0]
// 2,3 array[1]
// 3,4 array[2]
// 4,5 array[3]
int [][] array= {{1,2},{2,3},{3,4},{4,5}};
for (int i = 0; i <array.length ; i++) {
for (int j = 0; j <array[0].length ; j++) {
System.out.println(array[i][j]);
}
}
}
//打印数组元素
public static void printArray(int[] arrays){
for (int i = 0; i <arrays.length ; i++) {
System.out.println(arrays[i] + "");
}
}
}
冒泡排序
//1.比较数组中两个相邻的元素，如果第一个数比第二个数大，则他们交换位置
//2.每一次比较都会产生一个最大或者最小的数
//3.下一轮则可以减少一次排序
//4.依次循环，直到结束
public static void main(String[] args) {
int[] a ={1,2,3,35,466,30,14,32,245,};
int[] sort=sort(a);//调用完我们自己写的排序方法以后，返回一个排序后的数组
System.out.println(Arrays.toString(sort));
//toString方法的作用是返回一个对象的字符串表示
}
public static int[] sort(int[] array){
//临时变量
int temp = 0;
//外层循环，判断这个要走多少次
for (int i = 0; i <array.length-1 ; i++) {
//内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置
for (int j = 0; j <array.length-1-i ; j++) {
if (array[j+1]>array[j]){
//两个数交换需要通过第三个临时变量
temp=array[j];
array[j] =array[j+1];
array[j+1]=temp;
}
}
}
return array;
}
浙公网安备 33010602011771号