java基础改进

psvm+tab 在idea中直接生成主方法

java八大基本数据类型

1.整型：byte，short，int，long
2.字符型：char
3.浮点型：float，double
4.布尔型：boolean
5.引用数据类型：只要是new出来的都是引用数据类型。如数组

位运算

1.位运算符直接运算操作数的二进制位
2.移位运算符将操作数的二进制位向左或向右移动
3.带符号，无符号右移的区别在于高位产生的空位补的值不同
4.按位“非”运算的结果位为原操作数对应位取反
5.按位“与”运算的结果位为1时，两个原操作数的对应位同时为1
6.按位“或”运算的结果位为0时，两个原操作数的对应位同时为0
7.按位“异或”运算的结果位为1时，两个原操作数的对应位不同。

运算符

1.简单赋值运算符将右操作数的值设置给左操作数；
2.复合赋值运算符是简单赋值运算符和其他运算符相结合的简写形式
3.自增、自减运算符直接修改操作数的值加1或者减1
4.自增、自减运算的运算结果与操作数位置有关
5.条件运算符根据操作数1的真假决定表达式的值是操作数2或操作数3
6.条件运算符会造成语法短路现象
7.三元运算符

//格式
a>b?a:b
    //首先计算关系表达式的值，如果值为true表达式的值就是运算结果1，如果为false表达式的值就是运算结果2

枚举

1.使用enum关键字声明枚举类型；如声明星期

public enum WeekP{
    MON,TYES,WED,THUR,FRI,SAT,SUN;
}

2.a.枚举可以赋空值
b.引用枚举类型,先写类型标识符,再写值的标识符,中间用逗号间隔
c.枚举可以声明数组

Week w0=null;
Week w1=Week.MON;
WEEK[] WS={MON,TYES,WED,THUR,FRI,SAT,SUN};

3.枚举与字符串之间的转换
(1). toString()返回枚举值的名称
（2）.valueOf()根据名称返回枚举值。

String text = Week.MON.toString();
Week week = Week.valueOf(text);

4.每种枚举类型只能存在有限个值；
5.枚举类型可以声明构造方法、方法、字段
6.枚举不能被继承；
7.枚举可以在swith语句中使用；
8.不能用new关键字构造枚举对象。

if语句

//if格式
if(关系表达式){语句体}
else if(){}
else{}

1.在语句体中，如果只有一句代码，大括号可以省略不写
2.如果对一个布尔类型的变量进行判断，不要用==号

boolean flag =true;
if(flag){
   System.out.println("flag的值为ture")
}

switch语句

//switch语句格式
switch(表达式){
    case 值1:
        语句体1;
        break;
    case 值2:
        语句体2；
        break;
    default:
        语句体n+1；
         break;
}

1.依次和case后面的值进行比较，如果有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
2.如果所有的case后面的值和表达式的值都不匹配，就会执行default里面的语句体，然后结束整个switch语句。
3.case给出的值不允许重复，case后面的值只能是字面量不能是变量。
4.default不一定写在最下面，可以写在任意位置。
5.break不能省略不然会case会穿透

for循环

1.初始化语句只执行一次
2.判断语句为true，循环继续
3.判断语句为false，循环结束。
4.如果将定义的sum放在for循环内语句将会报错，当定义在for循环内时sum只作用在for循环内。即求和的变量不能定义在循环的里面
5.如果把变量定义在循环的里面，那么当前变量只能在本次循环中有效，当本次循环结束的之后，变量就会从内存中消失，第二次循环开始的时候，又会重新定义一个新的变量。

    public static void main(String[] args) {
        int sum=0;
  for(int i=1;i<=5;i++){
      sum+=i;
  }
        System.out.println("1-5之间的和为"+sum);
    }
}

6.求既能被3整除又能被5整除的个数

   public static void main(String[] args) {
        Scanner c=new Scanner(System.in);
        System.out.println("请录入第一个数字：");
        int statr = c.nextInt();
        Scanner b=new Scanner(System.in);
        System.out.println("请录入第二个数字：");
        int statr1 = b.nextInt();
        int j=0;
        if(statr>statr1){
            for(int i=statr1;i<=statr;i++){
                if(i%3==0&&i%5==0){
                    j++;
                }

            }
        }else{
            for(int i=statr;i<=statr1;i++){
                if(i%3==0&&i%5==0){
                    j++;
                }

            }
        }

        System.out.println("既能被3整除又能被5整除的个数为"+j);
    }

while循环

1.格式

初始化语句;
    while(条件判断语句){
        循环体语句；
        条件控制语句；
    }

2.for与while的区别：
(1)for循环中，控制循环的变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了，(知道循环次数或者循环范围).
(2)while循环中，控制循环的变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用。(不知道循环的次数和范围，只知道循环的结束条件)
3.给定一个整数x；如果是回文数打印true否则打印false，回文数是正序（从左向右看）和倒序（从右向左看）都是一样的数；

    public static void main(String[] args) {
        Scanner c=new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int x=c.nextInt();
        int temp=x;
        int num=0;
         while(x!=0){
            int ge=x%10;
            x=x/10;
            //把单当前获取到的数字拼接到最右边
            num=num*10+ge;
         }
        System.out.println(num);
        System.out.println(num==temp);
    }

4.给定两个整数，被除数与除数，将两数相除，要求不用乘法除法和%运算符，得到商和余数。

    public static void main(String[] args) {
        Scanner c=new Scanner(System.in);
        System.out.println("请输入第一个被除数：");
        int x=c.nextInt();
        Scanner m=new Scanner(System.in);
        System.out.println("请输入第二个除数：");
        int a=c.nextInt();
        int count=0;
         while(x>=a){
            x=x-a;
            count++;
         }
        System.out.println("余数为"+x);
        System.out.println("商为"+count);
    }

do…while循环

1.格式

初始化语句；
    do{
        循环体语句；
        条件控制语句；
    }while(条件判断语句);

2.无限循环下面不能写其他语句；
3.continue；结束当次循环。
4.break；结束整个循环。

题目逢7过

1.从任意一个数字开始报数，当你要报的数字包含7或者是7的倍数时都要说过。使用程序打印1-100之间逢7过的数据。

public static void main(String[] args) {
      for(int i =1;i<=100;i++){
          if(i%10==7||i/10%10==7||i%7==0){
              System.out.println("过");
              continue;
          }
          System.out.println(i);
      }
    }

2.输入一个整数判断是否为质数；
题目当中用到了falg做一个标记的思想；通过falg判断执行防止当时质数时重复打印。

   public static void main(String[] args) {
        Scanner c = new Scanner(System.in);
        System.out.println("请录入一个正整数：");
        int x = c.nextInt();
        boolean falg=true;
        for (int i = 2;i<x ; i++) {
            if (x%i==0) {
                falg=false;
                break;
            }
        }
        if(falg){
            System.out.println(x+"是一个质数");
        }else{
            System.out.println(x+"不是一个质数");
        }
    }

对代码就行优化当一个数不是质数的时候假设a*b=x；a，b大于2，且两个数中一个一定是大于平方根，一个一定是小于平方根。

    public static void main(String[] args) {
        Scanner c = new Scanner(System.in);
        System.out.println("请录入一个正整数：");
        int x = c.nextInt();
        int m=0;
        int j;
        for(j=1;j<=x;j++){
            m=j*j;
            if(x==m){
                System.out.println(j+"是"+x+"的平方根");
                break;
            }else if(m>x){
                System.out.println((j-1)+"是"+x+"的平方根");
                break;
            }
        }
        boolean falg=true;
        for (int i = 2;i<=j; i++) {
            if (x%i==0) {
                falg=false;
                break;
            }
        }
        if(falg){
            System.out.println(x+"是一个质数");
        }else{
            System.out.println(x+"不是一个质数");
        }
    }
}
//当System.out.print(x+"不是一个质数");去掉ln的时候可以在同一行显示

3.获取随机数
在小括号当中，书写的是生成随机数的范围这个范围一定时从0开始的到这个数-1结束；

Random r = new Random();
int number=r.nextInt(bound100);
//括号内时随机数的范围

数组

1.数组可以用来存储同种数据类型的多个值，只要隐式转换也可以存储进去。
2.数组定义初始化

//静态初始化
数据类型[]数组名={元素1，元素2，....}
//动态初始化
数据类型[]数组名=new 数据类型[数组长度]
int[]array = new double[5];

3.解释一下地址值的格式含义[D@776ec8df
[，表示当前是一个数组
D 表示当前数组里面的元素时double类型
@ 表示一个间隔符号。(固定格式)
776ec8df 才是数组的真正地址值
4.获取数组的值 int n =arr[0];
5.一旦覆盖原先的数组的值就会改变
6.遍历是取出数组的整个过程。数组长度：arr.length
7.数组默认初始化规律，整数类型:默认初始化值0，小数类型：默认初始化类型0.0，字符类型：默认初始化’/u0000’(空格)，布尔类型：默认初始值false，引用数据类型：默认初始化值null

8.数组常见问题

①当访问了数组中不存在的索引，就会引发索引越界异常。

9.随机打乱数组；

    public static void main(String[] args) {
        int [] arr=new int[]{1,2,3,4,5};
        int count=0;
        for(int i =0;i<arr.length;i++){
            Random r=new Random();
            int m=r.nextInt(arr.length);
          count= arr[i];
          arr[i]=arr[m];
          arr[m]=count;
        }
            for(int i =0;i< arr.length;i++){
               System.out.println(arr[i]);
            }
    }

数据内存图

① 栈:方法运行时使用的内存，比如main方法运行，进入方法栈中执行
②堆：存储对象或者数组，new来创建的，都存储在堆内存
③方法区：存储可以运行的class文件
④本地方法栈：jvm在使用操作系统的功能的时候使用，和我们开发无关
⑤寄存器：给cpu使用，和我们开发无关
总结：①只要是new出来的一定是在堆里面开辟了一个小空间
②如果new了多次，那么在堆里面有多个小空间，每个小空间中都有各自的数据。

总结：当两个数组指向同一个小空间时，其中一个数组对小空间中的值发生了改变，那么其他数组再次访问的时候都是修改之后的结果了

方法

1.方法是程序中最小的执行单元。
2.重复的代码，具有独立功能的代码可以抽取到方法中
3.方法好处：①可以提高代码的复用性
②可以提高代码的可维护性
4.方法的定义格式：

//最简单的方法定义
public static void 方法名(){
    方法体（就是打包起来的代码）
}
//带参数的定义
public static void 方法名(参数1，参数2，.....){
    方法体（就是打包起来的代码）
}
//带返回值方法的定义
public static 返回值类型 方法名(参数){
    方法体;
    return 返回值;
}
//方法调用
方法名();
方法名(参数);//方法调用时，参数的数量与类型必须与方法定义中小括号里面的变量一一对应，否则程序报错。
整数类型 变量名=方法名(实参);//赋值调用
System.out.println(方法名(实参));//输出调用

5.形参：全称形式参数，是指方法定义中的参数
实参:全称实际参数，方法调用中的参数
6.什么时候用返回值方法：在调用处要根据方法的结果，去编写另外一段代码。

7.方法注意事项：

①方法不调用就不执行
②方法与方法之间是平级关系不能互相嵌套
③方法的编写顺序和执行顺序无关
④方法的返回值类型为void，表示该方法没有返回值，没有返回值的方法可以省略return语法不写。如果要编写return，后面不能跟具体的数据。
⑤return语句下面，不能编写代码，因为永远执行不到，属于无效代码

8.return关键字

①方法没有返回值：可以省略不写。如果书写，表示结束方法
②方法没有返回值：必须要写。表示结束方法和返回结果。
③break关键字表示结束循环或者结束swith。

9.方法的重载

①在同一个类中，定义了多个同名的方法，这些同名的方法具有同种的功能。
②每个方法具有不同的参数类型或参数个数，这些同名的方法，就构成重载关系。
③java虚拟机会通过参数不同来区分同名方法。
④如何判断是否是重载：在一个类中，有不同的实参。
⑤下面是定义方法的重载：

//想要调用哪个方法让参数与下面类型对应就可以，可以直接强制转换
public static void main(String[] args) {
            hh((byte)10,(byte)20);
    }
    public static  void hh(int num1,int num2){
        System.out.println(num1==num2);
    }
    public static  void hh(short num1,short num2){
        System.out.println(num1==num2);
    }
    public static  void hh(byte num1,byte num2){
        System.out.println(num1==num2);
    }
    public static  void hh(long num1,long num2){
        System.out.println(num1==num2);
    }

题目：定义一个方法判断数组中的某一个数是否存在，将运行结果返回给调用处。

public static void main(String[] args) {
        int[] arr = {99, 22, 33, 44, 55};
        //调用方法求获取并记录返回值
       boolean flag= hh(arr);
       if(flag==false){
           System.out.println("输入的数在数组当中存在");
       }else{
           System.out.println("输入的数在数组当中不存在");
       }
    }
    public static boolean hh(int []arr) {
        Scanner c =new Scanner(System.in);
        System.out.println("请输入数组当中的一个数");
        int m=c.nextInt();
        boolean flag=true;
        for(int i =0;i< arr.length;i++){
            if(m==arr[i]){
                flag=false;
                break;
            }
        }
        return flag;
    }

定义一个数组将从索引form开始到to结束的值拷贝到新数组当中去。

public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8};
       int[]arr2=copOfrange(arr,3,6);
      for(int i=0;i< arr2.length;i++){
          System.out.print(arr2[i]+" ");
      }
    }
    public static int[] copOfrange(int []arr,int form,int to) {
        int [] arr2=new int[to-form];//定义新数组
        int j=0;//伪造索引的思想
        for(int i =form;i<to;i++){
               arr2[j]=arr[i];
               j++;
        }
        return arr2;
    }

10.方法的内存：

①方法被调用之后就会进栈执行
②栈：先进后出
③当方法全被调用完成后方法将会出栈，跟随的变量也会随之消失。
④引用数据类型内存图

引用数据类型存储的是地址值而不是实实在在的值。
⑤基本数据类型：数据是存储在自己的空间中，特点：赋值给其他变量也是赋的真实的值。
⑥引用数据类型：数据值是存储在其他空间中，自己空间中存储的是地址值。特点：赋值给其他变量，赋的地址值。
⑦传递基本数据类型时，传递的是真实地数据，形参地改变，不影响实际参数的值
⑧传递引用数据类型的时，传递的是地址值，形参的改变将改变对应地址值堆当中的值从发生改变。

综合练习：

1.计算飞机票的价格：

/*选中代码按
ctrl+alt+m自动抽取方法*/
//机票价格按照淡季旺季，头等舱和经济舱收费，输入机票原价，月份和头等舱或经济舱
//按照如下规则计算机票价格：旺季（5-10月）头等舱9折，经济舱8.5折，淡季（11月到来年4月）头等舱7折，经济舱6.5折
public class lx2 {
    public static void main(String[] args) {
        Scanner jpyj =new Scanner(System.in);
        System.out.println("输入机票原价：");
        double j= jpyj.nextInt();
        Scanner mones =new Scanner(System.in);
        System.out.println("输入月份：");
        int m= mones.nextInt();
        Scanner cang =new Scanner(System.in);
        System.out.println("输入头等舱还是经济舱：0头等舱，1经济舱");
        int c= cang.nextInt();
        if(m>=5&&m<=10){
           j=getPrice(j,c,0.9,0.85);
        }else if(m>=1&&m<=4||m<=12&m>=11){
            double xj=getPrice(j,c,0.7,065);
        }else{
            System.out.println("输入月份错误");
        }
        System.out.println("计算后的飞机票票价格为"+j);
    }
    public static  double getPrice(double j,int c,double v0,double v1){
        if(c==0){
            j=j*v0;
        } else if (c==1) {
            j=j*v1;
        }else{
            System.out.println("仓位不合法");
        }
        return j;
    }

2.遍历到数组当中大写跟小写字母

 char []chs = new char[52];
        for(int i =0;i< chs.length;i++){
            if(i<=25){
                chs[i]=(char)(97+i);
            }else{
                chs[i]=(char)(65+i-26);
            }
        }

    }
    System.out.println("计算后的飞机票票价格为"+j);
}
public static  double getPrice(double j,int c,double v0,double v1){
    if(c==0){
        j=j*v0;
    } else if (c==1) {
        j=j*v1;
    }else{
        System.out.println("仓位不合法");
    }
    return j;
}

2.遍历到数组当中大写跟小写字母

```java
 char []chs = new char[52];
        for(int i =0;i< chs.length;i++){
            if(i<=25){
                chs[i]=(char)(97+i);
            }else{
                chs[i]=(char)(65+i-26);
            }
        }