java基础阶段复习1

环境配置
JAVA_HOME:jdk的路径(jdk下载网址：http://www.oracle.com)
Path:要把jdk的目录路径，添加到path变量

java的运行工作原理
java源代码文件(.java)-->java字节码文件(.class)-->运行结果
.java-->.class:编译期(通过javac命令将java的源文件编译为字节码文件)
.class-->运行结果：运行期(先启动java虚拟机，不同的操作系统有不同的jvm,因此java跨平台,再通过JVM加载.class字节码文件，并加载main方法执行程序)

jdk jre jvm 的关系
jdk（开发工具包）:Java Development Kit 是针对java开发员的产品，是整个Java的核心，包括了Java运行环境JRE,java工具和java基础类库。
jre（运行环境）:Java Runtime Envirment Kit是针对运行JAVA的运行环境，包含JVM和java的核心类库。
jvm（Java虚拟机）:java Virtual Machine,java虚拟机的缩写，是整个java实现跨平台的最核心的部分，能够运行以java语言写作的软件程序。
jdk有不同系统的版本，所以jdk是跨平台的

java的一次编写,处处执行是怎样实现的?
java程序会被编译成字节码组成的class文件,这些字节码可以运行在任何平台,因此java是平台独立的.

标识符
由字母,数字,下划线(_),$组成,不能有空格和其他字符,以及不能出现关键字.
不能由数字开头
严格区分大小写
见名知意

八种数据基本类型
byte(1),short(2),int(4),long(8),float(4),double(8),char(2),boolean(1)

练习1(输入个人信息):
public class Test1{
    public static void main(String[] args){
    System.out.println("姓名:");
    String name = new Scanner(System.in).nextLine();
    
    System.out.println("性别:");
    String sex = new Scanner(System.in).nextLine();
    
    System.out.println("年纪:");
    int age = new Scanner(System.in).nextInt();
    
    System.out.println("您输入的个人信息是:");
    System.out.println("姓名:");
    System.out.println("性别:");
    System.out.println("年纪:");
    }
}

练习2(圆的面积):
public class Test2{
   System.out.println("请输入圆的半径:");
   double r = new Scanner(System.in).nextDouble();
   System.out.println(3.14*r*r);
}

练习3(变量的交换):
public class Test3{
    System.out.println("请输入变量a:");
    int a = new Scanner(System.in).nextInt();
    
    System.out.println("请输入变量b:");
    int b = new Scanner(System.in).nextInt();
    
    int t = a;
    a = b;
    b = t;
    System.out.println(a);
    System.out.println(b);
}

引用类型
引用类型是一个对象类型,其值是指向内存空间的引用,就是地址.

基本类型字面值规则
整数字面值是int(4)类型,如果值超出int范围,则需要做转型处理.
byte(1),short(2),char(2)三种比int小的整数,在自身范围内可以直接赋值.
浮点数字面值时double;浮点数转成整数会直接舍弃小数点后6位.
字面值后缀:L,D,F
字面值前缀:二进制(0b);16进制(0x);8进制(0);char类型16进制(u

基本类型的类型转换
计算结果的类型与运算中的最大类型保持一致
byte(1),short(2),char(2)三种比int小的整数,计算时会自动转为int.
有long类型时,都会转为long类型.
char类型相加,提升为int类型.
整数运算溢出:可以添加后缀;
浮点数运算不精确的解决方法:
1.直接去除整数;
2.四舍五入(Math.round());
3.向上取整(Math.floor());
4.向下取整(Math.ceil());
5.StringBuffer,StringBuilder

基本类型之间的转换
数字类型之间可以互相转换,从小到大自动转换,从大到小需要强制转型.
byte-->short-->int-->long
char-->int
int-->float/double/long

小转大:隐式转换
int a = 9;
long b = a;

大转小:显式转换
int x = 10;
byte b =(byte)x;

运算符
&:短路与,a&b,a与b同时为真时结果才为真,有一个为false均为false.不管左边是什么结果都要继续执行右边
&&:逻辑与,有一个为假即为假,不再继续判断,左边是假,右边忽略不执行.直接判断为真
|:短路或,a|b,a与b中有一个为真即为真,不管左边是什么结果都要继续执行右边.
||:逻辑或,有一个为真即为真即为真,不再继续判断.左边是真,右边忽略不执行,直接判断为真.

流程控制
switch:jdk1.7之前只能判断byte,short,char,int,之后可以判断string.从成立的case无条件的穿透所有的case包括default直到结束,或者是遇到break,如果所有的条件都不成立的话就执行case.

switch(变量或表达式){
case1:
case2:
case3:
default;
}

练习1:数字匹配
public class Test{
public static void main(String[] args){
    int i = 3;
    switch(i){
          case1:
          System.out.println("1");
          break;
          case2:
          System.out.println("2");
          break;
          case3:
          System.out.println("3");
          break;
          default:
          System.out.println("default");
        }
    }
}
break:中 断,跳出循环
countine:结束本轮循环进入下一轮循环

for循环:

for(变量赋值;执行条件;变量修改){
    代码
}

练习1:打印正方形
for(int i = 1;i<5;i++){
    for(int j=1l;j<5;j++){
    System.out.println("*");
    }
    System.out.println();
}

练习2:打印倒三角
for(int i = 5;i>1;i--){
    for(int j = 0;j<i;j++){
    System.out.print("*");
    }
    System.out.print();
}

练习3:打印99乘法表
public class Test3{
    public static void main(String[] args){
    test();
    }
    private static void test(){
    for(int i = 1;i<=9;i++){
        for(int j=1;j<=i;j++){
        System.out.println(i+"*"+j+"="+i*j+" ");
           }
        System.out.println();
        }
    }
}

if分支

单分支:
if(判断条件){
代码 
  }

多分支:
if(判断条件){
    代码1
  }else{
   代码2
    }

嵌套分支:
if(判断条件1){
  代码1
}else if(判断条件2){
  代码2
}else if{判断条件3}{
  代码3
}else{
  代码4 
}

练习1:输入年号,判断平年闰年
public class Test1{
public static void main(String[] args){
System.out.println("年号:");
int y = new Scanner(Syetem.in).nextInt();
String r = "平年";
if(y%4==0){
if(y%100!=0){
    r="闰年";
    }
  }
  if(y%400==0){
  r="闰年";
  }
}

练习2:商品打折
接收输入的原价,满1000打9折,满2000打8折,满5000打5折.
public class test2{
    public static void main(String[] args){
    System.out.println("输入总原价");
    double price = new Scanner(System.in).nextDouble();
    double nowprice = f(price);
    System.out.println(nowprice);
    }
    public static double f(double p){
    if(p>5000){
      p=p*0.5;
    }else if(p>2000){
      p=p*0.8;
    }else if(p>1000){
      p=p*0.9;
    }else{
      p=p;
    }
    return p;
}

练习3:统计学员得分
>90:优秀
80-90:良好
70-80:中等
60-70:及格
<60:不及格
public class test3{
public static void main(String[] args){
    double score = new Scanner(System.in).nextDouble();
    if(score>=100||score<=0){
    System.out.println("请输入0-100范围内的数");
    }
    if(score>=90 && score<=100){
    System.out.println("优秀");
    }else if(score >= 80 && score<90){
    System.out.println("良好");
    }else if(score >=70 && score<80){
    System.out.println("中等");
    }else if(score >=60 && score<70){
    System.out.println("及格");
    }else if(score < 60){
    System.out.println("不及格");
      }
    }
}

练习4:产生一个随机数,和用户一直在输入的数字比较.
public class test4{
    public static void main(String[] args){
    find();
    }
    private static void find(){
    
    int i = new Random().nextInt(100)+1;
    System.out.println("请猜1-100以内的数字:");
    int a = new Scanner(System.in).nextInt();
    while(true){
    if(a>i){
    System.out.println("猜大了");
    }else if(a<i){
    System.out.println("猜小了");
    }else{
    System.out.println("猜对了");
    break;
            }
        }
    }

}

三种循环的区别
for:知道循环次数
while/do...while:当循环次数不确定时
while:先判断，再执行，不符合规则，不执行代码
do while:先执行，再判断。代码至少被执行一次。

方法
被命名的代码块，方法可以含参也可以不含参。

修饰符 返回值 方法名（参数）{
    方法体；
}
public static void f(){

}

练习1:
public class test1{
    public static void main(String[] args){
    f1(9);
    }
    private static void f1(int a){
    return 10*a;
    }
}

方法的重载
方法的重载是指在一个类中有多个同名的方法，但每个方法都有不同的参数（参数的类型，个数，顺序不同）。程序在调用方法时，可以通过传递不同个数和类型的参数和决定具体使用哪一个方法。

练习：
public class test{
    public static void main(String[] args){
    int a = 3;
    int b = 9;
    String name = "jack";
    f1();
    f2(a);
    f3(a,b,name);
    }
    private static void f1(){
        return 0;
    }
    private static void f2(int a){
        return a*a;
    }
    private static void f3(int a,int b,String name){
        return a+b+name;
    }
}

数组
数组Array是用于存储多个相同类型的数据的集合。想要获取数组中的元素，可以通过元素的下标来获取，下标是从0开始的。
创建数组：

动态初始化：int[] a = new int[5];

静态初始化：int[] b = new int[]{1,2,3,4,5};
           int[] c = {2,3,4,5,6};

练习1：
public class Test1(){
    public static void main(String[] args){
    f1();
    }
    private static void f1(){
    //静态初始化创建数组
    int[] i = new int[]{1,2,3,4,5};
    System.out.println(Arrays.toString(i));
    
    //动态初始化创建数组
   char[] j = new char[4];
    j[0] = "c";
    j[1] = "h";
    j[2] = "a";
    j[3] = "r";
    System.out.println(Arrays.toString(j));    
    }
    //获取数组的长度
    System.out.println(j.length);
}

练习2：创建随机数组
public class Test2{
    public static void main(Stirng[] args){
    f();
    }
    private static void f(){
    int[] a = new int[5];
    for(int i = 0;i < a.length;i++){
    a[i] = new Random().nextInt(100)+1;
        }
        System.out.println(Arrays.toString(a));
    }
}

数组工具类Arrays
Arrays.toString(数组)：将数组连接成字符串
Arrays.sort(数组)：数组排序
Arrays.copyOf(数组，新的长度)复制数组长度为一个指定长度的新数组。
System.arraycopy(原数组，原数组起始位置，目标数组，目标数组起始位置，复制的数量):不会创建新的数组，但是目标数组要事先存在。
Arrays.binarySearch(数组，目标值)：二分法查找，在有序数组中查找目标值下标。

冒泡排序
相邻位置比较，从小到大排序，如果小就往前换，i代表从头到尾遍历数据。

升序：
public class Test1{
    public static void main(String[] args){
    int[] arr = new int[]{31,23,43,65,17,89,54,76};
    int[] arrnew = f1(arr);
    System.out.println(Arrays.toString(arrnew));
    }
    public static int[] f1(int[] a){
    //外循环控制比较次数
    for(int i = 0;i<a.length-1;i++){
    //内循环控制比较大小，循环次数和外循环一样
        for(int j = 0;j<a.length-1;j++){
            if(a[j]>a[j+1]){
            int t = a[j];
            a[j] = a[j+1];
            a[j+1] = t;
            }
        }
    }
    return a;
    }
}

降序：
public class Test2{
    public static void main(String[] args){
        // f1();
        int[] arr = new int[] {1,2,4,2,1,8,9,3,2,4};
        int[] newarr = f2(arr);
        System.out.println(Arrays.toString(newarr));

    }
    private static int[] f2(int[] arr) {
        //外循环控制次数
        for(int i = 0;i<arr.length-1;i++) {
            //内循环控制大小
            for(int j = 0;j<arr.length-1;j++) {
                if(arr[j]<arr[j+1]) {
                    int t = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = t;
                }
            }
        }
        return arr;
    }

变量
一般通过三部分来描述变量.变量类型,变量名,变量值.
变量的使用原则:就近原则.

局部变量
定义在方法里,局部代码块中,方法运行完内存就释放完了.

成员方法里
定义在类里方法外.作用域是在整个类中,类消失了,变量才释放.

public class Test1{
int a = 9;//成员变量
    {
    int x = 8;//局部变量
    }
    public static void main(String[] args){
    int sum = 10;//局部变量
    }
}