运算符
class Oparator{
/**
1.算数运算符
+(加) -(减) *(乘) /(除) %(取余) =(赋值) ++(前，后加加) --(前，后减减) +(连接符)
*/
public static void main(String[] args) {
//+(加)
int num1 = 12;//给num1赋值赋值
int num2 =24;//给num2赋值赋值
int num3 = num1 + num2;//运算
System.out.println(num3);//结果36
//-(减)
int reduce1 = 3;
int reduce2 = 5;
int result = reduce2 - reduce1;
System.out.println(result);//结果2
// /(除)
double a = 12.2;
double a1 = 2;
double a3 = a/a1;
System.out.println(a3);//结果6.1
// *（乘）
byte b1 = 3;
byte b2 = 5;
//byte b = b1 + b2;报错从int转换到byte可能会有损失
int b = b1 * b2;
System.out.println(b);//结果15
// %（取余）
int c = 30;
int c1 = c%12;
System.out.println(c1);//答案为6
//练习题：三位数字分别指出个位十位和白位
int num4 = 357;
int g = num4%10;
int s = num4%100/10;
int bw = num4/100;
System.out.println("个位数位："+g);//个位数位：7
System.out.println("十位数位："+s);//十位数位：5
System.out.println("百位数位："+bw);//百位数位：3
System.out.println("=====================================================");
//++(自增) --（自减）
}
}
class Add{
//2.赋值运算符 ++(自增) --（自减）
public static void main(String[] args) {
int a = 15;
a++;//相当于a=a+1;或者a+=1；
System.out.println(a);
int b = a++;//先运算再++
int c = ++a;//先++再运算
System.out.println("a="+a+",b="+b+",c="+c);//a=17,b=16,c=18
//使用++或者--数据类型不会改变
//(a++)++错误
//--和++类似一个加一个减，不能重叠使用
/**
赋值运算符=
拓展 += -= %= /= *=
*/
int i = 3;//把3放在i里面，为简单的赋值，
int i1=4;
i+=3;
i1=i1+3;
System.out.println(i1);
System.out.println(i);
byte i3 = 5;
byte i4 = 6;
i3+=5;//这样的赋值计算不会改变数据类型，比i3=i3+5；好用；int类型看不出来，
//i4=i4+5;报错从int转换到byte可能会有损失
System.out.println(i3);
//System.out.println(i4);
//同理其他的也是一样
}
}
class ComparisonOperator{
/**
3.比较运算符
==（比较是否相等） ！=（是否不相等） <(小于) >（大于） <==小于等于 >=(大于等于)
返回的值都是bouble类型，ture false
==和=差距好大
*/
public static void main(String[] args) {
int a = 10;
int b =11;
System.out.println(a==b);//false
System.out.println(a=b);//11 是把b的值11给了a所以结果为11
boolean a1 =true;
boolean b1 =false;
System.out.println(a1==b1);//false
System.out.println(a1=b1);//false 把b1的值赋给了a1，最后输出
//其他比较符用法差不多
}
}
class Logic{
/**
4.逻辑运算符
1.&(逻辑与) 2.&&(短路与) 3.|(逻辑或) 4.||(短路或) （5.^(异同) 6.! (非)）非常少用
*/
public static void main(String[] args) {
//& &&
int a = 0;
int b = 100;
if (a==0&b==100) {
System.out.println("满足要求");//满足要求，表示两个都要满足为ture，其中一个不满足为false，&&和&结果都是一样的
}
//&和&&的不同点
int a1 = 1;
int b1 = 100;
if (a1>10&b1<(b1++)) {
System.out.println(a1);
}
int b3 =99;
System.out.println(b1);//结果为101
if (a1>10&&b1<(b3++)) {
System.out.println(a1);
}
System.out.println(b3); //结果为99
//总结；&逻辑与第一个为false后面的代码还是会继续运行完，所以b1进行了加加的操作
// &&短路与第一个为false时后面的代码不会去执行了，直接跳过，如果为ture后面的代码才会执行
System.out.println("===============================");
// |(逻辑或) ||(短路或)
//满足其中一个都可以为ture
int c = 12;
int c1 = 44;
if (c>0|c1>100) {
System.out.println("满足了c，没有满足c1，");
}
// ||与|的区别
if (c>0||c1>(c++)) {//
System.out.println("使用||的c="+c); //使用||的c=12
}
if (c>0|c1>(c++)) {
System.out.println("使用|的c="+c); //使用|的c=13
}
//总结：当第一个判断成立时|还是会去执行下面的代码，||不会执行了
}
}
class Bit{
/**
5.位运算符
表示在2进制内部去移动
<< 左移
>> 右移
>>> 无符号右移
&。 与
| 或
^ 异或 提取不相同的值
~ 取反 取2进制相反的值（用的少做了解）
*/
//<<左移
public static void main(String[] args) {
int a =3;
System.out.println(a<<3);//结果为24，3*2的3次方
byte b = 4;
System.out.println(b<<2);//结果为16，4*2的2次方
//结论：向左移动几位就是*与2的几次方，
byte c =100;
System.out.println(c<<4);//1600,会自动去换数据类型
//>> 右移 可想和上面的一样只是除与移动位的次方
//>>> 无符号右移
int e = -10;
System.out.println(e>>2);//结果为3
int d = -10;
System.out.println(d>>>2);//结果为1073741821
//& | 这个和逻辑里的不一样，但是一样的相似
//&计算机底层2进制数的计算，两个数的2进制数，都为1时为1，为1和0时为0，0和0是为0,得出来的2进制数为结果
//|计算机底层2进制数的计算，两个数的2进制数，都为1时为1，为1和0时为1，0和0是为0,得出来的2进制数为结果
int a1 = 6;//0110
int b1 = 3;//0011
int c1 = a1&b1;
int c2 = a1|b1;
System.out.println(c1);//结果2 0010
System.out.println(c2);//结果7 0111
}
}
class TernaryOperator{
/**
6.三元运算符
格式：（条件表达式）？表达式1：表达式2；
为ture是执行表达式1，为false时执行表达式2，使用结果为boolean联系
注意：
接收到的值一定要是一个相同类型
能用三元写的代码在判断语句里都可以实现
*/
public static void main(String[] args) {
int a2 = 10;
int b2 =11;
int max = (a2>b2) ? a2:b2;//必须有东西去接收，
//int mix = (a2>b2) ? "zhang":3; 报错：不兼容的类型: 条件表达式中的类型错误int mix = (a2>b2) ? "zhang":3;String无法转换为int
System.out.println(max);
}
}
流程控制：
1.顺序：代码从上往下按照顺序流程走下来
2.分支：作出选择，为true执行if里的，为flash不执行往下走，为boolean类型
3.循环：满足要求时循环要执行的代码块，直到不满足要求跳出循环，为boolean类型
public class IfText {
/**
分支结构1：if.....else
三种用发：1.不满足直接跳过，2.两个选择其中一个执行，3.多个里去从上往下找到满足的跳出，多选1
1：if(条件表达式){
执行表达式
}
2：if(条件表达式1){
执行表达式1
}else{
执行表达式2
}
3.if(条件表达式1){
执行表达式1
}else if(条件表达式2){
执行表达式2
}else if(条件表达式3){
执行表达式3
}
......
else{
执行表达式n
}
*/
public static void main(String[] args){
//测试1
int age = 12;
if (age>=18){
System.out.println("你已经成年了。");//没有输出
}
//测试2
if (0<age&&age<18){
System.out.println("您还未成年");
}else{
System.out.println("您已经成年了");
}
//测试3
if (age<0&&age<120){
System.out.println("输入错误不是您的年龄");
}else if(age<20){
System.out.println("少年时期");
}else if (age<35){
System.out.println("青年时期");
}else if(age<60){
System.out.println("中年时期");
}else if (age<80){
System.out.println("老年时期");
}else{
System.out.println("长命百岁");
}
/**分支结构2
*/
}
}
输入函数Scanner
package 输入函数;
/**
输入函数：Scanner
三步
1.导包import java.util.Scanner;
2.Scanner的实例化Scanner sc = new Scanner(System.in);
3.调用Scanner int a = sc nextInt();
*/
import java.util.Scanner;//导包
public class ScannerText {
//使用方法，有各种类型
public static void main(String[] args){
Scanner sc = new Scanner(System.in);//对Scanner实例化
//练习键盘输出个人信息
System.out.print("请输入你的姓名：");
String name = sc.next();
System.out.print("请输入你的年龄：");
int age = sc.nextInt();
System.out.print("请输入你的性别true(男)/flash(女)：");
boolean gender = sc.nextBoolean();
System.out.print("请输入你的身高：");
double height = sc.nextDouble();
System.out.println(name);
System.out.println(age);
System.out.println(gender);
System.out.println(height);
}
}
switch-case基本用法
package 分支结构;
/*
分支结构2：
switch-case
1.格式
switch(表达式) {
case 常量1：
执行语句1；
//break
可以多个case一起使用
default：
执行语句你；
}
*/
import java.util.Scanner;
public class SwitchTest {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
byte a = sc.nextByte();
switch (a){
case 1:
System.out.println("one");
case 2:
System.out.println("two");
case 3:
System.out.println("three");
case 4:
System.out.println("four");
default:
System.out.println("不是1，2，3，4");
/*
输入2时结果为：
2
two
three
four
不是1，2，3，4
注意：
1.当case进入时后面的case全部都会被执行，遇到break关键字才会跳出或者到代码结束
2.a这个表达式不是条件表达式
3.判断的是==的
4.类型只能是byte，char，short，int，String，枚举类型，这6个类型其中一个不能出现boolean类型
5.default相对与if-else里的else，不过他可以放在任意位置都可以；可不使用
break；是跳出的意思switch-case一般都是和break一起用，没有不影响编译
*/
System.out.print("请输入现在的季节：");
String season = sc.next();
switch (season){
case "春":
System.out.println("春天到了");
break;
case "夏":
System.out.println("夏天到了");
break;
case "秋":
System.out.println("秋天到了");
break;
case "冬":
System.out.println("冬天到了");
break;
default:
System.out.println("没有这个季节");
//brick可有可无
}
}
}
}
for循环
package 分支结构;
/*
分支结构3:
for循环
结构for（1⃣️；2⃣️；3⃣️）{
代码块4⃣️
}
执行顺序1⃣️-->2⃣️满足-->3⃣️-->4⃣️-->2⃣️-->3⃣️-->4⃣️。。。。。。
一般用于循环输入，2⃣️的结果都是ture或者float
*/
import java.util.Scanner;
public class Fortest {
//列题1
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int i=1;
for (System.out.println("我是1");i<=3;System.out.println("我是语句3"),i++){
System.out.println("我是语句4");//看看顺序
}
/*
我是1
我是语句4
我是语句3
我是语句4
我是语句3
我是语句4
我是语句3
*/
//练习2，循环输入1到150是3的倍数后面加a 为5的倍数后面加一个b，为7的倍数后面加一个c，是他们三个的倍数加个abc
/* for (int num1=1;num1<=150;num1++){
if (num1%3==0){
System.out.println(num1+"a");
}else if (num1%5==0){
System.out.println(num1+"b");
}else if (num1%7==0) {
System.out.println(num1 + "c");
}
else if (num1%5==0&&num1%3==0&&num1%7==0){
System.out.println(num1+"abc");
}else{
System.out.println(num1);
}
}//方法不对，不但复杂还达不到效果,因为if-else只能多选一
*/
for(int a=1;a<=150;a++){
System.out.print(a+"--");//不能使用换行ln
if (a%3==0){
System.out.print("a");
}
if (a%5==0){
System.out.print("b");
}
if (a%7==0){
System.out.print("c");
}
System.out.println();//每一次代码块执行完进行换行
}
//列题3，键盘输入循环几次循环体
System.out.print("请输入要循环输出多少次：");
int num2 = sc.nextInt();
System.out.print("请输入要·循环的内容：");
String content= sc.next();
for (int num3=1;num3<=num2;num3++){
System.out.println(content);
/*结果：
请输入要循环输出多少次：2
请输入要·循环的内容：HelloWord
HelloWord
HelloWord
*/
}
//例题四
//打印1到100所有的奇数的和
int num3 = 0;
for (int a=0;a<=100;a++) {
if (a % 2 == 1) {
num3 += a;
}
}
System.out.println(num3);
//列题五
//输入两个数求他们的最大公倍数和最小公约数
System.out.print("请输入第一个正整数：");
int num4= sc.nextInt();
System.out.print("请输入第二个正整数：");
int num5= sc.nextInt();
int num6=(num4>num5)?num5:num4;
int num8=(num4>num5)?num4:num5;
int num7=0;
for (int num=num6;num>=0;num--) {
if (num4 % num == 0 && num5 % num == 0) {
System.out.println("最大倍数为：" + num);
break;
}
}
for (int num9=num8;num9<=num4*num5;num9++){
if (num9%num4==0&&num9%num5==0){
System.out.println("最小公倍数为："+num9);
break;
}
}
}
}
while
package 分支结构;
/*
while循环：
结构：
初始化值1⃣️
while(判断条件2⃣️){
执行语句3⃣️
迭代条件4⃣️
}
执行顺序和for循环一样，2⃣️为boolean类型
for和while都可互相转换
注意4⃣️把你少不然会变死循环,写程序要避免死循环
*/
public class WhileTest {
public static void main(String[] args){
//用while循环0到100的奇数的和
int a = 0;
int b=0;
while (a<=100){
if (a%2==1){
b+=a;
}
a++;//不能忘记
}
System.out.println(b);
System.out.println(a);//101
}
}
do-while
package 分支结构;
/*
do-while循环：
语法：
初始化值1⃣️
do{
循环体2⃣️
迭代条件3⃣️
}while（判断条件4⃣️）;
顺序为1⃣️-->2⃣️-->3⃣️-->4⃣️-->2⃣️-->3⃣️-->4⃣️....-->3⃣️--判断4⃣️不通过直接跳出
和for，while的差别就是do-while不管是去执行一次然后再进行判断。
do-while平时很少用
*/
public class DoWhileTest {
public static void main(String[] args){
//使用do-while输出1到100所有的偶数
int a=0;
do {
if (a%2==0){
System.out.println(a);
//a++;注意 迭代条件不要放在循环体里
}
a++;
}while (a<=100);
}
}
总结练习
package 分支结构;
/*
利用for嵌套输入九九乘法表
*/
public class NineNineTable {
public static void main(String[] args){
int a=1;
int b=1;
for (int i=1;i<=9;i++){
for (int j=1;j<=i;j++){//每次for循环跳出后再进入会重写开始
System.out.print(j+"x"+i+"="+i*j+"|");
}
System.out.println();//容易出错误的，每次内循环结束后要进行换行
}
/*
结果：
1x1=1|
1x2=2|2x2=4|
1x3=3|2x3=6|3x3=9|
1x4=4|2x4=8|3x4=12|4x4=16|
1x5=5|2x5=10|3x5=15|4x5=20|5x5=25|
1x6=6|2x6=12|3x6=18|4x6=24|5x6=30|6x6=36|
1x7=7|2x7=14|3x7=21|4x7=28|5x7=35|6x7=42|7x7=49|
1x8=8|2x8=16|3x8=24|4x8=32|5x8=40|6x8=48|7x8=56|8x8=64|
1x9=9|2x9=18|3x9=27|4x9=36|5x9=45|6x9=54|7x9=63|8x9=72|9x9=81|
*/
}
}
package 分支结构;
//输出100以内所有的质数
public class Test {
public static void main(String[] args){
//boolean a = true;这个要放在循环里面
for (int i=2;i<100;i++){
boolean a = true;
for (int j=2;j<i;j++){
if(i%j==0){
a=false;
}
}
if (a==true) {
System.out.println(i);
}
}
//列题五
//输入两个数求他们的最大公倍数和最小公约数
System.out.print("请输入第一个正整数：");
int num4= sc.nextInt();
System.out.print("请输入第二个正整数：");
int num5= sc.nextInt();
int num6=(num4>num5)?num5:num4;
int num8=(num4>num5)?num4:num5;
int num7=0;
for (int num=num6;num>=0;num--) {
if (num4 % num == 0 && num5 % num == 0) {
System.out.println("最大倍数为：" + num);
break;
}
}
for (int num9=num8;num9<=num4*num5;num9++){
if (num9%num4==0&&num9%num5==0){
System.out.println("最小公倍数为："+num9);
break;
}
}
}
}
package 分支结构;
/*
练习 ：输入任意多个整数，输入0的时候结束，计算出输入的数中的最大值和最小值
*/
import java.util.Scanner;
public class Exercise {
public static void main(String[] args){
Scanner sc =new Scanner(System.in);
int max=0;
int min=0;
int a1=0;
int b=0;
for (int a=0;a==0;a=0){
System.out.print("请输入一个整数：");
int num = sc.nextInt();
if (num>0) {
if (max < num) {
max = num;
} else if (min > num) {
min = num;
}
a1++;
}
if (num<0) {
if (max < num) {
max = num;
} else if (min > num) {
min = num;
}
b++;
}
if (num==0){
break;//break也可以跳出循环
}
}
System.out.println("最大值为："+max);
System.out.println("最小值为："+min);
System.out.println("输入的正数为："+a1);
System.out.println("输入的负数为："+b);
}
}
优化代码提高效率
package 分支结构;
/*
对10000内质数输出查看有多少的优化
新知识点：查看时间函数System.currentTimeMillis();可以利用查看代码执行的时间单位为毫秒
开根号函数Math.sqrt()；获取这个数的根号
*/
public class Optimize {
public static void main(String[] args){
int num1=0;
long b= System.currentTimeMillis();//获取当前时间距离1970-01-01 00.00.00的毫秒数
for (int num=2;num<=100000;num++){
boolean a= true;
for (int j=2;j<=Math.sqrt(num);j++){
if (num%j==0){
a=false;
break;
}
}
if (a==true) {
num1++;
}
}
System.out.println("一共有"+num1+"个质数");
long c= System.currentTimeMillis();//获取当前执行完代码时间距离1970-01-01 00.00.00的毫秒数
System.out.println(c-b);//代码执行时间
//没有优化时候为23346，在判断num%j下加个break；优化不是质数的数不要一个一个都进去时间为2933毫秒
//在加break的同时把num加个根号时间为32，代码执行效率真的挺重要，要有高的吞吐量计算机算法效率一定要高；
}
}
break和continue比较
package 分支结构;
/*
结束语句的比较和作用
break：用于循环还有if-else，while-case，跳出当前循环
Continue：用于循环还有if-else，跳出这一次循环
相同点但是跳出，还有他们后面都不能放东西，编译直接不通过，
*/
public class BreakContinue {
public static void main(String[] args){
for (int i =1;i<100;i++){
// if (i%4==0){
// break;
// }
// System.out.print(i);//123
if (i%4==0){
continue;
}
System.out.print(i);//123567910111314151718192122232526272930.......99
}
//他们两个都是结束靠近自己的for循环里如何结束外外的for呢
for (int i=0;i<200;i++){
for (int j=1;j<100;j++){
if (j%4==0){
break;
}
System.out.print(j);//123123123123123123123123123123.......123
}
}
System.out.println("");
a:for (int i=0;i<200;i++){
for (int j=1;j<100;j++){
if (j%4==0){
break a;//直接指定跳出哪一个
}
System.out.print(j);//123
}
}
}
}
记录资金情况小项目
package Bookkeeping;
/*
做出一个自己的记录自己的收入和开支
*/
import java.util.Scanner;
public class FamilyAccount {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
String fundSituation="";
int total=0;
one: for (;;){
System.out.println("------------------个人收入和开支情况-----------------");
System.out.println("|\t\t\t\t\t\t\t\t\t\t\t\t |");
System.out.println("|\t\t\t\t\t1 收支明细\t\t\t\t\t |");
System.out.println("|\t\t\t\t\t2 登记收入\t\t\t\t\t |");
System.out.println("|\t\t\t\t\t3 登记支出\t\t\t\t\t |");
System.out.println("|\t\t\t\t\t4 退出\t\t\t\t\t\t |");
System.out.println("--------------------------------------------------");
System.out.print("\t\t\t\t\t请选择(1--4)：");
int option = sc.nextInt();
switch (option){
case 1:
System.out.println("------------------当前收支明细记录-----------------");
System.out.println("收支\t\t 账户金额\t\t\t收支金额\t\t说\t明");
System.out.println(fundSituation);
break ;
case 2:
System.out.print("本次收入的金额：");
int money=sc.nextInt();
System.out.print("本次收入说明：");
String cause=sc.next();
total+=money;
fundSituation+=("收入"+"\t\t "+total+"\t\t\t\t"+money+"\t\t"+cause+"\n");
System.out.println("------------------记录完成输入1可查看-----------------\n");
break;
case 3:
System.out.print("本次支出的金额：");
int money_2=sc.nextInt();
System.out.print("本次支出说明：");
String cause_2=sc.next();
if (money_2>total){
System.out.println("您好您的钱不够");
}else {
total-=money_2;
fundSituation+=("支出"+"\t\t "+total+"2\t\t\t\t"+money_2+" \t\t"+cause_2+"\n");
System.out.println("------------------记录完成输入1可查看-----------------");
}
break;
case 4:
two:for (;;) {
System.out.print("是否确定退出y确定n不退出（y/n）");
String yn = sc.next();
char ny=yn.charAt(0);
if (ny =='y'||ny=='Y') {
break one;
} else if (ny=='n'||ny=='N') {
break two;
} else {
System.out.println("输出有错误重新收入");
}
}
default:
System.out.println("输入错误请输入1到4的的数");
}
}
}
}
数组
一维数组
package array;
/*
一.数组的概述
1.理解：数组（Array），是多个相同类型的元素按照一定的顺序排序的集合，使用一个名字命名，
可以通过编号对数据进行管理。
2.概念：
>数组名
>元素
>角标，下标，索引
>数组的长度，元素的个数
3.特点：
>数组是有序排列的
>数组是引用数据类型。不过数组里的元素可以是基本数据类型和引用数据类型；
>创建数组对象在内存里开辟一整块连续的空间
>数组长度一旦确定就不能去修改了，处理方法可以重新开辟一个数组，重新设置长度
4.分类
维数分类：一维数组，二维数组，三维数组，，，，，。。。。。多维
按数据类型分类：引用数据类型，基本数据类型。
5.一维数组
>声明和初始化
>然后调用数组里的元素
>如何获取数组长度
>如何遍历数组元素
>数组元素的默认初始化值
>内存如何分配，内存解析
*/
public class ArrayTest01 {
public static void main(String[] args){
//一维数组
//声明和初始化
//静态初始化，初始化和数组元素赋值同时进行
int[] id;//初始化
id = new int[]{0,1,2,3,4,5,6,7,8,9};//直接赋值，开辟了10个空间
//动态初始化，初始化和元素赋值分开进行的
String[] name=new String[3];//直接开辟一个3个单位的数组，没有值，
//容易出现的写法错误
//int[] arr1=new int[];没有分配空间或者没有给元素赋值
//如何获取数组里的元素
System.out.println(id[0]);
name[0]="张三";
name[1]="李四";
name[2]="王五";
System.out.println(name[2]);
//如何获取数组长度
//利用length方法
System.out.println(id.length);//10
System.out.println(name.length);//3
//如何遍历元素里的值
int i=0;
for (int j=0;j<name.length;j++){
System.out.println(name[j]);
}
for (int j=0;j<id.length;j++){
System.out.println(id[j]);
}
//系统默认初始化值
String[] love=new String[5];
for (int j=0;j<love.length;j++){
System.out.println(love[j]);//null，所以默认为零值，
}
int[] age=new int[5];
for (int j=0;j<age.length;j++){
System.out.println(age[j]);//0,结果为0
}
boolean[] arr1=new boolean[4];
for (int j=0;j<arr1.length;j++){
System.out.println(arr1[j]);//false
}
}
}
二维数组
package array;
/*
二. 二维数组
一维数组里包含了一个数组在计算机底层看没有什么多维数组，和if里的嵌套类似
5.二维数组
>声明和初始化
>然后调用数组里的元素
>如何获取数组长度
>如何遍历数组元素
>数组元素的默认初始化值
>内存如何分配，内存解析
*/
public class ArratTest03 {
public static void main(String[] args){
//一维数组初始化
int[] arry1=new int[]{1,2,3,4};
//二维数组初始化,静态
int[][] arry2=new int[][]{{1,2,3},{2,3,4},{7,8,9}};
//动态初始化
String[][] arry3=new String[3][2];
//获取数组长度
System.out.println(arry2.length);//3 获取外面一层的长度
System.out.println(arry2[0].length);//7 获取数组里的数组的长度
//如何遍历数组元素
//用嵌套循环来遍历
for (int i=0;i<=arry1.length;i++){
for (int j=0;j<arry2[i].length;j++){
System.out.print(arry2[i][j]+" ");
}
System.out.println("");
}
//数组元素的默认初始化值
System.out.println(arry2[1]);
//数组元素的默认初始化值
System.out.println(arry2[0]);//[I@29453f44 地址
System.out.println(arry3[0][1]);//null 内初始值和一维数组默认值一样
String[][] arry5=new String[4][2];
System.out.println(arry5[2]);//[Ljava.lang.String;@5cad8086
//System.out.println(arry4[0][0]);报错，没有指针
//总结：二维数组的初始值外面的是地址，里面的和一维一样。
}
}
练习
package array;
/*
输入几个学生和对应的成绩评出他们最高值，和评分：低于最高分10分为A
低于最高分20分为B
低于最高分30 分为C
*/
import java.util.Scanner;
public class ArratTest02 {
public static void main(String[] args){
int max=0;
Scanner sc=new Scanner(System.in);
System.out.print("请输入学生的个数：");
int num = sc.nextInt();
int[] a=new int[num];
for (int j=0;j<a.length;j++) {
System.out.print("请输入第" + (j + 1) + "个学生成绩");
a[j] = sc.nextInt();
if (max < a[j]) {
max = a[j];
}
}
System.out.println("最高分为："+max);
for (int i=0;i<a.length;i++){
if (max==a[i]) {
System.out.println("恭喜第一名："+a[i]);
} else if (a[i]>=max-10) {
System.out.println("等级为A："+a[i]);
}else if (a[i]>=max-20){
System.out.println("等级为B："+a[i]);
}else if (a[i]>=max-30){
System.out.println("等级为C："+a[i]);
}else {
System.out.println("等级为C："+a[i]);
}
}
System.out.println(max);
}
}
练习2
package array;
//杨辉三角
public class ArrayTest {
public static void main(String[] args){
int[][] yhsj=new int[10][];//创建一个二维数组，确定一维的长度，二维先不确定
for (int i=0;i< yhsj.length;i++){
yhsj[i]=new int[i+1];//利用for循环确定二维数组的长度
for (int j=0;j<yhsj[i].length;j++){
yhsj[i][0]=1;
yhsj[i][i]=1;//利用i的值给确定为一的数赋值
//if(i>1) {
for (int a=1;a<i;a++) {
yhsj[i][a] = yhsj[i - 1][a] + yhsj[i - 1][a - 1];//利用循环和i的值确定对应的值
}
//}
System.out.print(yhsj[i][j]+"\t");//便利所有的元素
}
System.out.println("");//换行
}
}
}
数组的复制和搜索
package array;
//复制，搜索
import java.util.Scanner;
public class ArrayTest05 {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int[] array1,array2,array3;
array1=new int[]{23,34,56,67,34,56,24,582,54};
array2=array1;//将array1的赋值给array2
//修改啊array2里所有的下标为奇数的数
for (int i=0;i<array2.length;i++){
if (i%2!=0){
array2[i]=i;
}
System.out.print(array1[i]+"\t");//23 1 56 3 34 5 24 7 54 array1的值和array2的还是一模一样；说明没有开辟新空间
}
//复制array2到array3
array3=new int[array2.length];
for (int i=0;i<array2.length;i++){
array3[i]=array2[i];
}
System.out.println("");
for (int i=0;i<array3.length;i++){
System.out.print(array3[i]+"\t");
}
//搜索24
int a= sc.nextInt();
int b=0;
for (int i=0;i<array3.length;i++){
if (array3[i]==a){
System.out.println("\n搜索到了下标为"+i);
b=1;
}
}
if (b==0){
System.out.println("\n很遗憾没有搜索到你想要的数");
}
for (int j=1;j<array2.length/2;j++){
}
}
}
求数组最大值，最小值，和，平均数
package array;
/*
求数组的最大值，最小值，和，平均值
*/
public class ArrayTesy06 {
public static void main(String[] args) {
int[] arr = new int[]{34, 34, 56, 76, 34, 45, 56, 23, 67, 87};
int max=0;
int min=0;
int add=0;
//最大值
for (int i = 0; i < arr.length; i++) {
if (arr[0] <= arr[i]) {
max = arr[i];
}
}
System.out.println("最大值为：" + max);
//最小值
for (int i = 0; i < arr.length; i++) {
if (arr[0] >= arr[i]) {
min = arr[i];
}
}
System.out.println("最小值为"+min);
for (int i=0;i<arr.length;i++){
add+=arr[i];
}
System.out.println("和为："+add);
System.out.println("平均值为："+add/arr.length);
}
}
数组的工具类和经见的异常
package array;
import java.util.Arrays;
public class ArrayText {
/*
数组的常用的工具类
异常
1 角标异常
2 空指异常
*/
public static void main(String[] args){
int[] arr1=new int[]{12,23,45,67,675,67,45,67,456,46,56,46};
int[] arr2=new int[]{12,23,45,67,675,67,45,67,456,46,56,46};
int[] arr3=new int[]{34,43,45,65,765,56,56,45,46,56,78,78,67};
//判断两个数组是不是相等
boolean a=Arrays.equals(arr2,arr1);
System.out.println(a);//true 所有的数但是一一对应才相等
//输出数组信息
System.out.println(Arrays.toString(arr1));//为String类型的数
//指定数加入数组
Arrays.fill(arr2,110);//把所有的数改110
System.out.println(Arrays.toString(arr2));//[110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110]
//数组的排序
Arrays.sort(arr1);
System.out.println(Arrays.toString(arr1));//[12, 23, 45, 45, 46, 46, 56, 67, 67, 67, 456, 675]
//在数组找自己想找的数,二分找
int b=Arrays.binarySearch(arr3,45);
System.out.println(b);//2 找不到为负数
if(b<0){
System.out.println("没有找到");
}
}
}
面向对象
简单的面向对象了解
package 对象1;
/*
特点：继承性，封装性，多态性，（抽象性）
一.面向对象两大要素
1.类：对一个事物的描述，是抽象的，概念上的定义
2.对象：是个实实在在存在的东西可以摸到的
属性：成员变量 fidld 域 自带的一种属性
方法：行为 函数 成员方法 method
三大步骤
1.创建类定义属性和方法
2.类的实例化
3.调用创建的类
*/
public class dom01 {
public static void main(String[] args) {
person p1 = new person();
p1.name="张三";
p1.age=20;
p1.isMale=true;
p1.color="yellow";
System.out.println("姓名："+p1.name);
p1.pdan(p1.isMale);
System.out.println("皮肤颜色："+p1.color);
p1.eat();
p1.basketball("晚上");
p1.sleep();
p1.run("会","有时候");
person p2=new person();
System.out.println("*************************************\n");
p2.name="李四";
p2.age=18;
p2.isMale=false;
p2.color="白";
System.out.println("姓名："+p2.name);
p2.pdan(p2.isMale);
System.out.println("皮肤颜色："+p1.color);
p2.sleep();
p2.eat();
p2.makeUp("早上");
p2.run("会","每天");
}
}
class person{
String name;
int age=1;
boolean isMale;
String color;
public void eat(){
System.out.println("我会吃饭");
}
public void sleep(){
System.out.println("我会睡觉");
}
public void basketball(String time){
System.out.println("我会打篮球在"+time+"的时候");
}
public void makeUp(String time){
System.out.println("我会化妆在"+time+"的时候");
}
public void run(String yse,String day){
System.out.println("我"+yse+day+"跑步");
}
public void pdan(boolean a) {
if (a==true){
System.out.println("性别为男");
}else{
System.out.println("性别为女");
}
}
}
设计类
package 对象1;
/*
设计类
属性（成员变量）vs 局部变量
相同点
格式：数据类型 变量名=变量值；
先声明后使用
都有自己对应的作用域
不同点
位置：属性是定义在{}内
局部变量在方法内，方法体内，代码块内，构造器内，内部的变量
权限修饰符：属性可以指明其权限
局部变量不能使用修饰符，也可以说在定义方法事就已经有权限了
初始化值：属性整型0，浮点0.0，布尔false，字符型0或/n0000，引用数据类型null
局部变量没有初始化值，调用前要赋值，特殊的行参掉用方法时候赋值就可以
在内存里的位置：属性加载在堆空间里的
局部变量在栈空间里的
*/
public class Dom02 {
public static void main(String[] args){
man m1=new man();
m1.age=18;
System.out.println(m1.age);
m1.heinht=180;
System.out.println(m1.heinht);
m1.name="zhangsan";
System.out.println(m1.name);
m1.eat();
String newname=m1.getName();
m1.sleap(7);
int newage =m1.getAge(2);
System.out.println(newage);
System.out.println(newname);
}
}
class man{
String name;
int age;
double heinht;
public void eat(){
System.out.println("这个男人会吃饭");
}
public void sleap(int time){
System.out.println("这个男人一天睡觉"+time+"个小时");
}
public String getName(){
return name;
}
public int getAge(int add){
age+=add;
return age;
}
}
练习
package 对象1;
/*
练习打印一个m*n的矩形
*/
public class Dom03 {
public static void main(String[] args){
Dom03 m=new Dom03();
System.out.println("该矩形面积为"+m.medhod(10,6));
}
public int medhod(int m,int n){
for (int i=0;i<m;i++){
for (int j=0;j<n;j++){
System.out.print("*\t");
}
System.out.println("");
}
return m*n;
}
}
package 对象1;
/*
练习：定义Student类，包含三个属性序号（1到20）年级（1到6）成绩（0到100）年级和成绩用随机生成
问题1：打印3年级学生的信息
问题2：使用冒泡排序，把学生通过成绩来排名
*/
import array.ArrayUtil;
import java.util.Arrays;
public class Dom04 {
public static void main(String[] args){
ArrayUtil arr=new ArrayUtil();
int[] arr_1=new int[]{1,23,34,23,2,23,23,2};
System.out.println(arr.max(arr_1));
System.out.println(arr.min(arr_1));
System.out.println(arr.sum(arr_1));
System.out.println(arr.number(arr_1));
System.out.println(arr.find(arr_1,288));
Student[] stus=new Student[20];
for (int i=0;i<stus.length;i++){
stus[i]=new Student();
stus[i].number=i+1;
stus[i].state=(int)(Math.random()*(6-1+1)+1);
stus[i].score=(int)(Math.random()*(100-0+1)+1);
}
for (int i=0;i<stus.length;i++){
System.out.println("序号："+stus[i].number+" 年级："+stus[i].state+" 成绩："+stus[i].score);
}
//问题一
System.out.println("====================================");
for (int i=0;i<stus.length;i++){
if (stus[i].state==3){
System.out.println("序号："+stus[i].number+" 年级："+stus[i].state+" 成绩："+stus[i].score);
}
}
//问题二
System.out.println("====================================");
for (int i=0;i<stus.length-1;i++){
for (int j=0;j<stus.length-1;j++){
if (stus[j].score>stus[j+1].score){
Student temp=stus[j];
stus[j]=stus[j+1];
stus[j+1]=temp;
}
}
}
for (int i=0;i<stus.length;i++){
System.out.println("序号："+stus[i].number+" 年级："+stus[i].state+" 成绩："+stus[i].score);
}
}
}
class Student{
int number;//序号
int state;//年级
int score;//成绩
}
重载
package 对象1;
import java.util.Scanner;
public class Dom05 {
public static void main(String[] args){
Dom05 do5=new Dom05();
Scanner sc=new Scanner(System.in);
int a= sc.nextInt();
int b=sc.nextInt();
String c=sc.next();
double d=sc.nextDouble();
do5.one(a);
do5.one(a,b);
do5.one(c);
//2⃣️
System.out.println(do5.two(a,b));
System.out.println(do5.two(a,d));
System.out.println(do5.two(a,b,50));
}
//简单重载测试1⃣️
public void one(int i){
System.out.println(i*i);
}
public void one(int i,int j){
System.out.println(i*j);
}
public void one(String i){
System.out.println(i);
}
// 2⃣️
public int two(int i,int j){
return (i>j)?i:j;
}
public double two(double a,double b){
return (a>b)?a:b;
}
public int two(int i,int j,int z){
int max=(i>j)?i:j;
return (max>z)?max:z;
}
}
可变形参
package 对象1;
/*
可变形参方法
*/
public class Dom06 {
public static void main(String[] args){
Dom06 m6=new Dom06();
m6.test("zhang");//输出的是地址值说明和数组用法差不多
m6.test("z","w","z","x","x");
m6.test("zwz",22,34,45);
}
//当参数为一个时候先选择一个的
public void test(String str){
System.out.println("one");
}
//可以传多个参数
public void test(String...str){
System.out.println(str);
}
//不能和可变形参构成重载
//public void test(String[] atr){
//}
//报错因为可变形参只能放在最后
//public void test(int...i,String str){}
public void test(String str,int...i) {
System.out.println("放在最后");
}
//因为只能放在最后面所以一个方法里只能出现一个可变形参
}
