注释

//单行注释

/* 多行注释*/

关键字

public，class,static全部都是小写，代码块中全部都是小写

常量

一个不变的数值 ，

字符串常量 “我是程昊” 字符常量 “A”

空常量 null（不能直接输出）

整数常量

小数常量

数据类型

  1. 基本数据类型

    数值型

    整数（byte 1 -128~127，short 2,int 4,long 8）

    浮点数（float 4, double 8） java中浮点数默认的是double，3.14和1e2都是double型可以用（float）强制转换

    字符（char 2）

    非数值型

    布尔（boolean 1）

2.引用数据类型

类（class）

接口（interface）

数组（[ ]）

标识符

小驼峰命名

首个单词小写，后面单词首字母大写 firstNumber

大驼峰命名

首个单词首字母大写，后面单词首字母也大写 GoodStudent

  1. 由数字，字母，下划线，美元符号
  2. 不能以数字开头
  3. 不能是关键字
  4. 区分大小写

类型转换

数据范围（精度）从小到大

自动类型转换，把低精度数转换为高精度数

byte-short-int-long-float-double

char-int-long-float-double

强制类型转换，把高精度转换为低精度

算数运算符

加+ 减- 乘* 除/(得到商 ) 取余%

字符的 + 操作

多个类型的基本数据运算时，整个算数表达式的类型会自动进行提升

  1. byte,short,char类型将被自动提升到int类型

  2. 整个表达式的类型自动提升到表达式最高等级的数，等级顺序：byte,short,char–>int–>long–>float–>double

字符串 + 操作

1
2
3
System.out.println("fuck"+"you");  //fuckyou
System.out.println("fuck"+666); //fuck666
System.out.println(99+1+"you");  //100you

赋值运算符

符号 作用 说明
= 赋值 a=10,将10赋值给变量a
+= 加后赋值 a+=b,将a+b的值给a
-= 减后赋值 a-=b，将a-b的值给a
*= 乘号赋值 a*=b，将a * b的值给a
/= 除后赋值 a/=b，将a/b的商给a
%= 取余后赋值 a%=b，将a/b的余数给a 
1
2
3
short a=10;
a+=10;
a=(short)a+10;//等价

拓展的赋值隐含了强制类型转换

自增自减运算符

1
2
i++;  //先赋值，在运算
++i;  //先运算，再赋值

关系运算符

符号 说明
== a==b,判断a和b的值是否相等，成立为true，不成立为false
!= a!=b,判断a和b的值是否不相等，成立为true，不成立为false
> a>b，判断a是否大于b,成立为true,不成立为false
>= a>=b,判断a是否大于等于b，成立为true，不成立为false
< a<b,判断a是否小于b，成立为true，不成立为false
<= a<=b,判断a是否小于等于b，成立为true，不成立为false

逻辑运算符

  1. 运算符 & 且

  2. 运算符 | 或

  3. 运算符 ^ 异或（相同为true不同为false）

  4. 运算符 ！ 非

  • 逻辑&，无论左边真假，右边都要执行
  • 短路&&，左边为真，右边则执行。左边为假，右边不执行
  • 逻辑 | ，无论左边真假，右边都要执行
  • 短路 ||，左边为真右边不执行，左边为假右边执行

三元运算符

格式：关系运算符？表达式1：表达式2；

1
int max=a>b?a:b;

数据输入

1
2
3
import java.util.Scanner;
Scanner sc=new Scanner(System.in);
int i=sc.nextInt();

流程控制

  1. 顺序结构，从上到下依次执行

  2. 选择结构 

    1
    2
    3
    if(){
       }else if(){
      }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    switch(表达式){
        case 值1:
        case 值4：
            语句1;
            break;
        case 值2:
            语句2;  //如果没有break后面的语句都会执行，default也会执行
        case 值3:
            语句3;
        default:
            语句4;
            
    }

  3. for循环

    1
    2
    3
    for(初始条件;判断语句;条件控制){
        循环语句;
    }

水仙花

1
2
3
4
5
6
7
8
9
for(int i=100;i<1000;i++) {
			double bai=Math.pow(i/100,3);
			double shi=Math.pow(i/10%10, 3);
			double ge=Math.pow(i%10, 3);
			if(bai+shi+ge==i)
			{
				System.out.println(i);
			}
		}

  1. while循环

    1
    2
    3
    while(条件判断){
        
    }

  2. do..while

    1
    2
    3
    do{
        
    }while(条件判断);

    语句break，结束整个循环

    语句continue,结束当前一次循环

Random

1
2
3
import java.util.Random  //导包
Random r=new Random();//创建对象
int num=r.nextInt(10);//获取数据范围[0,10),左闭右开

猜数字

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.Random;
import java.util.Scanner;
public class text {
	public static void main(String[] args) {
		Random random=new Random();
		int num=random.nextInt(10);
		Scanner sc=new Scanner(System.in);
		int gass=0;
		for(int i=0;i<3;i++) {
		System.out.println("请输入一个0-9的整数");
		gass=sc.nextInt();
		if(gass==num) 
			{System.out.println("猜对了");
			break;
			}
		else if(gass>num)
			System.out.println("猜大了");
		else if(gass<num)
			System.out.println("猜小了");
		}
		if(gass!=num)
		System.out.println("次数用尽，真正的数是："+num);
	}
}

idea

代码补全：psvm主方法，sout打印输出，ctrl+alt+L规格化

elipse补全：syso，main

数组

数组（array）是一种用于多个相同类型数据的存储模型

定义数组：int[] arr=new int[3]; 为arr分配地址

整数默认值为0，浮点数为0.0，布尔数为false，字符为空字符，引用为null

数组静态初始化

int [ ] arr=new int [ ]{1,2,3} 等价于

简化初始化 int [ ] arr={1,2,3}

数组常见操作

arr.length 数组元素的个数

1
2
3
for (i=0;i<arr.length;i++){
    System.out.println("arr[i]");
}

内存分配

栈内存

储存局部变量，声明的对象“Person p”

堆内存

实例化”new Person()”,“new int[2]” new出来的内容

多个数组指向相同，如何一个数组修改了堆内存的值，另一个的数组值也改变

方法

用一定功能的代码集，先创建再调用

public static void 方法名(数据类型 变量名1，数据类型 变量名2)；

形参和实参

形参：方法定义中的参数

实参: 方法调用时传入的参数

方法注意事项

  • 方法不能嵌套定义

  • void表示无返回值，可以省略return，也可以单独写return后面不加数据

方法重载

  • 多个方法在同一个类中
  • 多个方法名相同
  • 多个方法的参数不同，类型不同，或者数量不同
  • 与返回值无关，返回值不同不是方法重载
1
2
3
4
5
6
7
8
public class main{
    public static float fn(int a){   //参数不同
    }
    public static int fn(int a,int b){//方法重载 
    }
    public static int fn(float a){
    }
}

方法参数传递（基本类型）

1
2
3
4
5
6
7
public static void main (String[] args){
    int num=12;
    change(num);//无法改变num的值，因为都在栈内存，num还是12
}
public static void change(int num){
    num=20;
}

方法参数传递（引用类型）

1
2
3
4
5
6
7
public static void main (String[] args){
    int[] num={12,23,34};//num在栈内存
    change(num);//引用
}
public static void change(int[] num){
    num[1]=100;
}

数组最大值

1
2
3
4
5
6
7
8
9
public static int getMax(int[] arr){
    int max=arr[0];
    for(int i=1;i<arr.length;i++){
        if(max<arr[i]){
            max=arr[i];
        }
    }
    return max;
}