- 扩展
- 浮点数
float 和 double 不要用于比较
浮点数的特点：有限、离散、舍入误差、接近但不等于
例如：
public class Demo01 {
public static void main(String[] args) {
float f=0.1f;
double d=1.0/10;
System.out.println(f==d);//false
float a=12121212122f;
double b=a+1;
System.out.println(a==b);//true
}
}
- 类型的转换
- 自动转换
从低到高：
byte,short,char -> int -> long -> float -> double - 强制转换
从高到低：
（类型）变量名 - 注意：
（1）不能对布尔值进行转换
（2）转换时需要注意内存溢出问题或精度问题
（3）操作过大时，需要注意溢出问题
public class Demo02 {
public static void main(String[] args) {
int i = 10;
byte b=(byte) i;//强制转换
System.out.println(b);
int money=10_0000_0000;
int year=20;
long add= (long)money*year;//在计算时已经出现了问题，需要计算过程转变为long类型才可以正常显示
System.out.println(add);
}
}
二、变量和常量
- 变量
（1） 类变量 -----static
随类的出现而出现，随类的消失而消失，可以直接访问
初始值为0、0.0、null，false
（2）实例变量
从属于对象，初始值为0、0.0、null，false
（3）局部变量
必须进行生声明和初始化
public class Demo04 {
static double salary;//类变量
String name;//实例变量
public void method(){
int a=0;//局部变量
}
public static void main(String[] args) {
System.out.println(salary); //0.0 直接访问类变量
Demo04 demo04= new Demo04();
System.out.println(demo04.name);//null 访问实例变量
}
}
- 常量 -----final
static final double salary=500;三、命名规范
- 类成员变量：首字母小写和驼峰原则 -----monthSalary
- 局部变量：首字母小写和驼峰原则 -----monthSalary
- 常量：大写字母和下划线 -----MONTH_SALARY
- 类名：首字母大写和驼峰原则 -----MonthSalaty
- 方法名：首字母小写和驼峰原则 -----monthSalary()
javadoc命令是用来生成自己的API文档
- 相关参数：
@author 作者名
@version 版本号
@since 需要的jdk版本
@param 参数名
@throws 异常抛出情况
@return 返回值情况
Scanner scanner = new Scanner(System.in);//扫描所输入的内容
例如：
next() 与 nextLine()
next() 所输出的是所输入的内容中空格前的内容
nextLine() 所输出的是回车之前的所有内容
package com.zhang.scanner;
import java.util.Scanner;
public class Demo03 {
public static void main(String[] args) {
//创建扫描机器
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数据：");
String str = scanner.nextLine();//输出想要的类型的内容，这里为nextLine()类型的内容
System.out.println("用户输入的数据为："+str);//如果输入的是hello world，则输出为hello world；使用next()，则输出的是hello
scanner.close();
}
}
六、结构
- 顺序结构：从上到下的结构
- if 选择结构
（1）单选择结构
if (布尔值表达式){
// 布尔值为真将输出的内容
...
}
（2）双选择结构
if (布尔值表达式){
// 布尔值为true
}else{
//布尔值为false
}
（3）多选择结构(有一个if是true，其他的就都不执行)
if (布尔值表达式1){
...
}else if(布尔值表达式2){
...
}else if(布尔值表达式3){
...
}else{
...
}
- switch 选择结构
switch (expression){
case value :
...//执行语句
break;//防止向下穿透
case value :
...//执行语句
break;//防止向下穿透
default :
//其他情况
}
- 循环结构
（1）while 循环（先判断后执行）
（2）do…while 循环（先执行后判断）
（3）for 循环
for ( 初始化 ; 布尔表达式 ; 更新){
...
}
// 增强 for 循环（主要用于遍历数组和集合对象）
for ( 声明语句 : 表达式 ){
...
}
七、break、continue
- break：用于任何循环体中的主体部分，强行退出循环，不执行循环中剩余的部分
- continue：用于循环语句中，终止某次循环，跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定
修饰符 返回值类型 方法名（参数类型 参数值）{
...
方法体
...
return 返回值 ;
}
-
修饰符：定义了该方法的访问类型，可选
-
参数类型：当方法被调用时，传递值给参数；分为形式参数和实际参数
- 形参：在方法被调用时用于接收外界输入的数据
- 实参：调用方法时实际传给方法的数据
-
方法体：定义该方法的功能
-
方法的重载：
-
方法名称必须相同
-
参数列表必须不同（个数、类型、参数排序顺序不同等）
-
方法的返回值可以相同也可以不同
-
只有返回值类型不同不足以成为方法的重载
- 在声明方法中，在指定参数类型后加一个省略号（…）
- 注意：一个方法中只能定义一个可变参数，他必须是方法的最后一个参数，任何普通的参数必须在他之前声明
public static void main(String[] args) {
//调用可变参数的方法
printMax(1,23,46,8,2,56,13,852);
printMax(new double[]{2,452,6,5,23,5,2,3});
}
//输出最大值
public static void printMax(double...numbers){
if(numbers.length==0){
System.out.println("没有找到数");
return;
}
double result=numbers[0];
//排序
for (int i=1;i
if (numbers[i]>result){
result=numbers[i];
}
}
System.out.println("最大值为"+result);
}
十、递归
- 递归方法就是自己调用自己，用于求解一些小规模问题的计算，大大减少程序的代码量。
//阶乘
public static void main(String[] args) {
System.out.println(f(5));
}
public static int f(int a){
if (a==0||a==1){
return 1;
}else if(a<0){
System.out.println("请输入正数");
return 0;
}else {
return a*f(a-1);
}
}
十一、数组
- 一维数组
- 数组的声明
int[] arrary ;//首选方法 或 int arrary[] ;//效果相同，但不是首选方法
- 静态初始化数组
int[] a = { 1 , 2 , 3 , 4 , 5 } ;
- 动态初始化数组
int[] arrary = new int[10] ; arrary[0]=...;
- 二维数组
int[][] arrarys = new int[2][3] ;// 二行三列的数组
- Arrays工具类
- 常用功能：
- 给数组赋值：通过fill方法
public static void fill(int[] a , int val) //将指定的int值分给指定的int数组的每个元素 //a - 要填充的数组 //val - 要存储在数组的所有元素中的值
public static void fill(int[] a , int fromIndex , int toIndex , int val) //将指定的int值分配给指定的int数组的指定范围的每个元素。 要填充的范围从索引fromIndex扩展到索引toIndex ，排他。（如果fromIndex==toIndex ，要填充的范围是空的。） //a - 要填充的数组 //fromIndex - 要用指定值填充的第一个元素（包括）的索引 //toIndex - 要用指定值填充的最后一个元素（排除）的索引 //val - 要存储在数组的所有元素中的值
- 对数组排序：通过sort方法
public static void sort(int[] a) //按照数字顺序排列指定的数组
- 比较数组：通过equals方法
public static boolean equals(int[] a1 , int[] a2) //如果两个指定的int数组彼此包含相同数量的元素、所有对应的元素对都相等相等 ，则返回true
- 查找数组元素：通过binarySearch方法对排序好的数组进行二分查找法操作
import java.util.Arrays;
public class Demo02 {
public static void main(String[] args) {
int[] a = {56,1,48,64,2,6,78,81,};
System.out.println(Arrays.toString(a));//[56, 1, 48, 64, 2, 6, 78, 81]
Arrays.sort(a);
System.out.println(Arrays.toString(a));//[1, 2, 6, 48, 56, 64, 78, 81]
Arrays.fill(a,2,4,0);//在2<=x<4之间填充0
System.out.println(Arrays.toString(a));//[1, 2, 0, 48, 56, 64, 78, 81]
}
}
- 冒泡排序
public class Demo03 {
public static void main(String[] args) {
int[] a={1,265,254,951,5,25,3852,};
System.out.println(Arrays.toString(a));
sort(a);
System.out.println(Arrays.toString(a));
}
public static int[] sort(int[] a){
//外层循环，判断走多少次
for (int i=0;i
//内层循环，两两比较
for (int j=0;j< a.length-1-i;j++){
if (a[j]>a[j+1]){
int temp=a[j+1];
a[j+1]=a[j];
a[j]=temp;
}
}
}
return a;
}
}
- 稀疏数组
public class Demo04 {
public static void main(String[] args) {
int[][] a1=new int[5][5];//定义数组
a1[1][1]=1;
a1[2][2]=2;//赋值
System.out.println("原始数组：");
//遍历a1
for(int[] a:a1){
for (int b:a){
System.out.print(b+" ");
}
System.out.println();
}
//创建稀疏数组
System.out.println("稀疏数组为：");
//判断数组中非0元的个数数
int sum=0;
for (int i=0;i< 5;i++){
for (int j=0;j<5;j++){
if (a1[i][j]!=0){
sum++;
}
}
}
//稀疏数组的第0行
int[][] a2=new int[sum+1][3];
a2[0][0]=5;
a2[0][1]=5;
a2[0][2]=sum;
//稀疏数组的其他行
int count=0;
for (int i=0;i
for (int j=0;j
if (a1[i][j]!=0){
count++;
a2[count][0]=i;
a2[count][1]=j;
a2[count][2]=a1[i][j];
}
}
}
//遍历稀疏数组
for(int[] a:a2){
for (int b:a){
System.out.print(b+" ");
}
System.out.println();
}
}
}
