Java第一模块

输出

System.out.println();//可以用sout来快速打出
System.out.print();//不换行
int a=10;
System.out.println(a);//输出变量不用加引号
System.out.println("我今年"+a+"岁");//用变量加字符显示
String name;
name="张三";
System.out.println("我叫"+name);
System.out.println("面积="+a*b);
``````
- 输入
```java
Scanner scanner = new Scanner(System.in);//创建了一个scanner变量用于接受外部输入的数据，记住格式就行
String name;
name = scanner.nextLine();//读取一整行，包括回车符
scanner.nextLine();//吃掉回车符
c = scanner.nextLine().charAt(0);//先读取一整行，再读取第一个字母,读取第几个
i = scanner.nextInt();//读取第一个整数
f = scanner.nextFloat();//读取第一个单精度浮点数
d = scanner.nextDouble();//读取第一个双精度浮点数
b = scanner.nextBoolean();//读取下一个布尔类型

基本数据类型
分为字符型、数值型和逻辑型
大小：1个二进制位 1个字节（8个二进制位） 1kb=1024个字节 1Mb=1024Kb 1Gb=1024Mb
unicode编码一个字符都是由两个字节来存储

//字符型
char ch="好";//也可以用单引号，存放一个汉字或者一个字母（只要是一个字符就用char不管什么语言）
String name="你好";//只能用双引号，存放多个字符
String PSW="123456";
//数值型
//用合适的类型可以节约空间
byte bit=127;//只能存-128~127的整数，也就是一个字节（8个二进制位，最高位是符号位，所以只有2^7个）
short s=10000;//分配两个字节的空间，16个二进制位 -3万到+3万
int a=666;//四个字节 -21亿到+21亿
long l=888888888888;//八个字节空间
//低于21亿用int比较好，因为速度快
//图片视频声音用byte

//浮点型
float f=1.11111f;//在数字后面加上f，单精度浮点型，分配四个字节空间，精确到小数点后6位
double d=2.22222;//八个字节空间，超过21亿，小数位后15位
//double 速度快，用的多

//逻辑类型
boolean isStudent;
isStudent =true;
isStudent =false;//只能存true或false
//数值类型的计算
byte b1=100;
byte b2=100;
byte b3;
b3=b1+b2;//存在的问题1.超界了2.加完其实是int型，因为在做运算的时候自动转换成int类型了
b3=(byte)(b1+b2);//强制类型转化的，但是溢出了

算术运算符

int a=1,b=2,c;
c=a+b;
c=a-b;
c=a*b;
c=a/b;//除法如果接受的是整型那么会舍去小数部分
double c;
c=a/b;//接受者是浮点型就是显示小数
c=a%b;//取余数
c++;//自增1，先c再自增
++c；//自增1，先自增,注意与其他运算符的搭配，
a=c++;//a=c
a=++c;//a=c+1
//++在前优先级最高，++在后优先级最低
c--;
--c;//同 理

关系运算符

// >大于 <小于 >=大于等于 <=小于等于 !=不等于 ==等于

int a=3,b=4;
System.out.println(a>b);//返回的是true 或 false

逻辑运算符

//&&并且 ||或 
String username="jack",pwd="123456";
System.out.println(username =="jack"&& pwd=="123456");
//按顺序判断，如果&&前面的表达式是false则后面的表达式不执行
int a=3,b=4;
System.out.println(a<0&&++b>0);
System.out.println(b);//b=4
//按顺序判断，如果||前面已经是true了，后面也不执行
//取反!
System.out.println(!(a>b));
char ch='b';
System.out.println(!(ch>='a'&&ch<'z'));//字符也可以比较，因为最终都是转化成数字存放
//这里表达的是如果ch不在里面返回true
System.out.println(ch-1);//结果是97，小写字母ASCII码97-122
System.out.println((char)(ch-1));//结果是a

//三目运算符
int a=3,b=4,c;
c=a>b?a:b;//成立c=a,不成立c=b
String username="zhangsan";
c=username == "zhangsan"? a+3:b+3;//用于二选一的情况

// 没有 a<b<c这种连续比较结构，要用&&来表示

赋值运算符

1
2
3

// += -= *= /= %=
a+=3;// a=a+3;相当于自己对自己运算然后赋给自己
//同理

优先级
算术运算符>关系运算符>逻辑运算符>条件运算符>赋值运算符
以下是优先级从高到低：
++ – 在前 !
* / %
+ -
> < >= <=
== !=
&&
||
?:
*= /= %=
+= -+
++ – 在后

例题

//求输入一个数，然后让他倒序输出
//第一次思考结果
Scanner scanner=new Scanner(System.in);
		int a=scanner.nextInt();//a=123456  
		for (int i = 0; i < 5; i++) {//问题在于不知道怎么求整型的长度
			System.out.print(a%10);
			a = (a-(a%10))/10;//使其少一位		
		}
//优化后的解法
int a=scanner.nextInt();//a=123456 
int b=(a+"").length();//注意空白符要用双引号，先转化成字符串型再计算长度再转化成整型
for (int i = 0; i <b; i++) {//
System.out.print(a%10);
a = a/10;//因为整型除法会自动舍弃最低位	
}
```q

- if语句
```java
int a=5,b=4,c;
//选择结构
if(a>b)
{
    c=a;
    System.out.println(c);//如果结构里面跟两条及以上的语句要加花括号，只有一条则不需要
}
    
else
    c=b;

//单分支
if(a>5)
    System.out.println(a);
//多分支
float score;
Scanner scanner=new Scanner(System.in);
score=scanner.nextFloat();
if(score>=0&&score<=100)

    if(score>=85&&score<=100)
        System.out.println("优秀");
    else if(score>=60&&score<85)
        System.out.println("及格");
    else
        System.out.println("不及格");//可以不加花括号，因为if else可以看做一个整体

else//嵌套
    System.out.println("输入的分数不合法");

小知识点

字符串判断相等
字符串判断是否相等不用==
而是例如：username.equals(“xiaomi”);
单个字符char类型还是可以用==

随机数

Random r = new Random();
double d1 = r.nextDouble(); // 生成[0,1.0]区间的小数
double d2 = r.nextDouble() * 7; // 生成[0,7.0]区间的小数
int i1 = r.nextInt(10); // 生成[0,10)区间的整数
int i2 = r.nextInt(18) - 3; // 生成[-3,15)区间的整数
long l1 = r.nextLong(); // 生成一个随机长整型值
boolean b1 = r.nextBoolean(); // 生成一个随机布尔型值
float f1 = r.nextFloat(); // 生成一个随机浮点型值

if else选择结构的石头剪刀布游戏

while(true) {
		Random r=new Random();
		int Robot=r.nextInt(2);
		Scanner scanner=new Scanner(System.in);
		System.out.println("请输入0到3的一个整数，0表示石头；1表示剪刀，2表示布");
		int Player = scanner.nextInt();
		if(Robot==Player)
			System.out.println("你和电脑打平了");
		else if(Player<0||Player>2)
			System.out.println("输入不合法");
		else
			if(Robot==0)
				if(Player==1)
					System.out.println("你输了，电脑出石头你出剪刀");
				else 
					System.out.println("你赢了，电脑出石头你出布");
			else if(Robot==1)
				if(Player==0)
					System.out.println("你赢了，电脑出剪刀你出石头");
				else 
					System.out.println("你输了，电脑出剪刀你出布");
			else 
				if(Player==0)
					System.out.println("你输了，电脑出布你出石头");
				else 
					System.out.println("你赢了，电脑出布你出剪刀");
		//如果只要知道输赢，那么只要把平的和赢得列出来，else就是输的（反过来也一样）
        	
		
		}

switch选择结构

//如果条件只是判断相等而不是范围的话，就可以用switch比较方便
//例如通过数字选择分支
switch(x)
{
    case 1:System.out.println("存款");break;
    case 2:System.out.println("取款");break;
    case 3:System.out.println("查询");break;
    case 4:System.out.println("退出");break;
    default:System.out.println("出错");break;

}
//case 后面只能跟 整型和字符型
String beverage;
switch(beverage)
{
    case "可乐":System.out.println("3块");break;
    case "雪碧":System.out.println("1块5");break;
}
//不加break的情况，就是输出结果都一样，就省略
switch(m)
{
    case 1:
    case 3:
    case 5:
    case 7:
    case 8:
    case 10:
    case 12:System.out.println("31天");break;
    case 4:
    case 6:
    case 9:
    case 11:System.out.println("30");break;
    case 2:
        if(y%4==0&&y%100!=0||y%400==0)//嵌套，可以嵌套if else或switch等等都行
            System.out.println("29天");
        else
            System.out.println("28天");
        break;
}

for循环

for(int i=1;i<=100,i++)
{
    //要循环的内容
}
/*
第一个变量是循环变量的初始化，相当于一个计数器
第二个是来判断循环的条件是否满足，满足继续，不满足结束
第三个是用来改变循环变量的值，如果不写就会死循环
第一个只执行一次
第二个会多执行一次，多出的那次是条件不满足的
第三个执行满足条件次，最后那次是条件不满足的
*/
for(int i=3;i>=1;i--){
    System.out.println(i)
}//用负数循环

//for循环的变体
int i=3;//初始化放外面
for(;i>=1;){
    System.out.println(i);
    i--;//减减放里面
}
for(int i=0;i<=5;i++)
{
    if(i==3)
        continue;//结束本次循环，继续下次循环
    System.out.println(i);
    if(i==4)
        break;//直接结束for循环
}
for(char ch='a';ch<='z';ch++)
{
    System.out.println(ch);

}
//不确定循环次数条件下的for循环
//石头剪刀布，赢两局才获胜
Scanner scanner=new Scanner(System.in);
int scoreP=0,scoreR=0;//放在外面不然每次会清零
for(;;)	//相当于死循环，用里面的break来退出循环
{	
System.out.println("请出拳：0表示石头，1表示剪刀，2表示布");
int player=scanner.nextInt();

Random r=new Random();
int robot=r.nextInt(3);
System.out.println(robot);
if(player==0&&robot==1||player==1&&robot==2||player==2&&robot==0)
{
    System.out.println("你赢了");
    scoreP++;
}
else if(player<0||player>2)
    System.out.println("请输入一个正确的数：0-2之间");
else if(player==robot)
    System.out.println("平了");
else {
    System.out.println("你输了");
    scoreR++;
}
if(scoreP-scoreR>=2)
{
    System.out.println("你战胜了电脑，比分是："+scoreP+":"+scoreR);
    break;
}
if(scoreR-scoreP>=2)
{
    System.out.println("你输给了电脑比分是："+scoreP+":"+scoreR);
    break;
}
}

嵌套for循环

//一个break是退出本层的for循环
//continue继续本轮循环，跳过一步
//对1234进行排列组合，不能重复
public static void main(String[] args) {
		// TODO Auto-generated method stub
		for (int i = 1; i <=4; i++) {
			for (int j = 1; j <=4; j++) {
				for (int p = 1; p <=4; p++) {
					for (int k =1; k <=4; k++) {
						if(i!=j&&i!=p&&i!=k&&j!=p&&j!=k&&p!=k)
							System.out.println(1000*i+100*j+10*p+k);//更好的用i+""+j+""+p+""+k
					}
				}
			}
		}
}
//运用了穷举法+筛选的策略
//之前想用print来把每位都给打印出来，发现太难实现了

//一对小兔子，每三个月生一对小兔子，则24个月后有多少对兔子
//先分析，1 1 2 4 6 10...成斐波拉契数列的规律，即后面的数取决于前面两个数的和
//所以用迭代法，即设置多个变量进行不断迭代
int a=1;
int b=1;
int c = 0;
for (int i = 3; i <=24; i++) {
    c=a+b;
    a=b;
    b=c;
}
System.out.println(c);

while 循环

int i=1;
whilie(i<=10)
{   
    System.out.println(i);
    i++;
}//相当于把赋初值和改变循环变量放在外面了
//一般用于死循环，不确定循环次数的，退出用break;
while(true)
{
    //存款
}
do{
System.out.println(i);//先执行再判断，也就是至少会执行一次
i++;
}while(i<=10)

数组

//用于方便存放多个类型一样的数值
int[] arr=new int[5];//长度为5的int类型的变量
//数组名为首地址，此例为arr为第一个变量的地址
//用偏移量找其他数值，arr[0]就是第一个，arr[1]就是第二个元素
//又称为下标
arr[0]=1;
arr[1]=2;
arr[2]=3;
arr[3]=4;
arr[4]=5;
for(int i=0;i<=4;i++)
    System.out.println(arr[i]);
//定义方式二
int[] brr=new int[]{1,2,3};//先赋值，不定义的话会有默认初值
//int 0;float 0.0f;String null;char "";boolean false
brr.length//数组的长度
String [] name=new String[]{"小米", "三星","苹果"};//字符串类型数组
//查找标记flag
String[] name=new String[]{"a","b","c"};
Scanner scanner=new Scanner(System.in);
String search;
search = scanner.nextLine();
boolean flag=false;
for(int i=0;i<=name.length;i++)
{
    if(search.equals(name[i]))
       {
        System.out.println("找到了，下标为："+i);
       flag=true;
       }       
}
if(flag=false)//放在外面，最后执行
    System.out.println("没找到")；
//排序算法
//冒泡排序
for(int i=a.length-2;i>=0;i--)//可以画图找找规律 321
    {
        for(int j=0;j<=i;j++)
        {
            if(a[i]>=a[i+1])
            {
                int t=a[i];
                a[i]=a[i+1];
                a[i+1]=t;
            }
        }
    }

二维数组

int[][] a=new int[4][3];//四行，三列
int[][] b=new int[][]={{1,1,1},{2,2,2}.{3,3,3}};
//输出
System.out.println(b[0][0]);
for(int i=0;i<=b.length;i++)//先按行算
{
    for(int j=0;j<b[i].length;j++)
    {
        System.out.print(b[i][j]); 
    }
    System.out.println();//换个行
}
//三角数组
int[][]a=new int[3][];
a[0]=new int[]{1,2};
a[1]=new int[]{1,2,3};
a[2]=new int[]{1,2,3,4};

函数

//函数public static 返回类型 函数名（参数列表）
public static int jiecheng(int n)//返回类型为int型，参数为形参，不返回就是void
{
    int ji=1;
    for(int i=n;i>=1;i++)
        ji=ji*i;
    return ji; //如果有返回值那么就用return返回，否则就不用写
}  
//调用
jiecheng(5);//实参
//解决了代码重用的问题
//如果一个函数里面有多个return语句，则遇到第一个就结束
//如果有多个if语句，必须保证能遇到return，否则会报错（建议删掉几个if）
public static swap(int a, int b)
{
    int c=a;
    a=b;
    b=c;
}
int a=3;
int b=4;
swap(a,b);
//结果a和b的值不变
//原因是函数里的a和b是形参，不会影响实参，只是把值给传进去了而已
//基本数据类型都是传值调用，然而数组是传址调用，改变变量本身
//对象名也是地址
//函数里调用其他函数，完全没问题，不过调用的得包括被调用的参数，且被调用的写在上面
//函数自己调用自己，即递归调用
public static void login(){
String uname,pwd;
Scanner scanner=new Scanner(System.in);
System.out.println("请输入用户名：");
uname =scanner.nextLine();
System.out.println("请输入密码：");
pwd =scanner.nextLine();
if(uname.equals("admin")&&pwd.equals("666"))
    System.out.println("登录成功");
else{
    System.out.println("用户名或密码出错");
    login();
}
    
}
//阶乘
public static int jiecheng(int n)
{

    if(n>1)
        return n*jiecheng(n-1);
    else 
        return 1;
}
//数组比大小
public static double max(double []scores)
{
    double m=scores[0];
    for(int i=1;i<scores.length;i++)
    {
        m=m>scores[i]?m:scores[i];
    }
    return m;
}

Lilic的博客

Java第一模块

优先级
算术运算符>关系运算符>逻辑运算符>条件运算符>赋值运算符
以下是优先级从高到低：
++ – 在前 !
* / %
+ -
> < >= <=
== !=
&&
||
?:
*= /= %=
+= -+

下一篇：JAVA知识列表

Lilic的博客

Java第一模块

优先级 算术运算符>关系运算符>逻辑运算符>条件运算符>赋值运算符 以下是优先级从高到低： ++ – 在前 ! * / % + - > < >= <= == != && || ?: *= /= %= += -+

下一篇：JAVA知识列表

优先级
算术运算符>关系运算符>逻辑运算符>条件运算符>赋值运算符
以下是优先级从高到低：
++ – 在前 !
* / %
+ -
> < >= <=
== !=
&&
||
?:
*= /= %=
+= -+