java基础---01

数据类型

基本数据类型

数值类型

整数(byte，short，int，long)
浮点数(float，double)
字符(char)

非数值类型

布尔(boolean)

引用数据类型

类(class)
接口(interface)
数组([])

数据类型内存占用和取值范围

数据类型              关键字                 内存占用          取值范围
整数                    byte                       1                    -128~127
                          short                      2                    -32768~32767
                          int                          4                  -2的31次方到2的31次方-1
                          long                        8                  -2的63次方到2的63次方-1
浮点数                 float                        4                  负数：-3.402823E+38到-1.401298E-45。正数：4.9000000E-324到1.797693E+308
字符                    char                        2                  0~65535
布尔                    boolean                    1                  true,false
# E+38表示是乘以10的38次方，同样E-45表示乘以10的负45次方

定义变量

变量定义格式：
      数据类型   变量名=变量值；
基本数据类型：
      byte，short，long，int，float，double，char，boolean
变量的使用：
      取值格式：变量名
      修改值格式：变量名=变量值

public class VariableDemo1{
  public static void main(String[] args) {
      //定义int类型
      int a = 10;
      System.out.println(a);
      //定义float类型
      float f = 13.14F;   # 需要加一个F
      System.out.println(f);
      //定义long类型
      long l = 100000000000L;   # 需要加一个L。为了防止类型过大
      System.out.println(l);
      //定义double
      double d = 13.14;
      System.out.println(d);
      // 定义byte类型
      byte b = 10;
      System.out.println(b);
      // 定义short类型
      short s = 100;
      System.out.println(s);
      // 定义char类型
      char c = 'ss';
      System.out.println(c);
      //定义boolean类型
      boolean bb = true;
      System.out.println(bb);
  }
}

类型转换

public class ConversionDemo {
  public static void main(String[] args) {
    //自动类型转换
    double d = 10;
    System.out.println(d);

    //定义byte类型的变量
    byte b = 10;
    short s = b;
    int i = b;
  
    //这是不可以的，类型不兼容
    //char c = b;

    //强制类型转换
    int k = (int)88.88  # 如果不加int，float转换int会报错。
  }
}

算术运算符

+，-，*，/，%
除法得到的是商，取余得到的是余数
整数相除只能得到整数，要想得到小数，必须有浮点数的参与

字符的+操作

public class OperationDemo {
  public static void(String[] args){
    //定义两个变量
    int i = 10;
    char c = 'A'; //'A'的值是65
    c = 'a';  # a对应的ascil码的值
    c = 'o';  # o对应的acill码的值
    // char ch = i + c;
    // char类型会被自动提升为int类型
    int j = i + c;  # 做运算时其实是用字符对应的ascill码的值做运算
    System.out.println(j);  

   //字符串和int类型做拼接
  System.out.println('itheima' + 666)

  System.out.println('heima' + 6 + 66)  #当字符串在前面时会直接拼接，不会做运算处理  heima666
  System.out.println(1+99+'heima')  # 当int在前时，先做运算，再做后面字符串的拼接   100heima
  }
}

i++和++i的区别

  int i = 10;
  int j = i++;
  System.out.println("i:" i);       # 11 
  System.out.println("j:", j)      # 10
  分析：会先把i赋值给j，然后打印的时候i自增+1，所以打印的i结果为11，j打印的结果为之前i没有自增的值为10；
  
  int j = ++i;
  System.out.println("i:" i);       # 11
  System.out.println("j:", j)      # 11
  分析：i先会自增+1，然后再把i赋值给j，打印的i结果为11，j打印的结果也为11；

三元运算

 a>b?a:b   # a是否大于b，大于则输出a，否则输出b

数据输入

Scanner

1.导包
import java.util.Scanner
2.创建对象
Scanner sc = new Scanner(System.in);
3.接收数据
int i = sc.nextInt();

分支语句

if语句

if(关系表达式){
  语句体1;
}else if{
  语句体2;
}else{
  语句体3;
}

switch

switch(表达式){
  case值1：
    语句体
    break;
  case值2：
    语句体
    break;
  ...
  default:
    语句体;
    break;
}

do...while

do {
  循环体语句;
}while(条件判断语句);

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

Random

1.导包
import java.util.Random
2.创建对象
Random r = new Random();
3.获取随机数
int number = r.nextInt(10);  # 获取数据的范围：[0,10] ，包括0不包括10

数组

1.格式一
数据类型[]  变量名
int[] arr
2.格式二
数据类型  变量名[]
int arr[]

动态初始化数组

初始化时只指定数组长度，由系统为数组分配初始值
数据类型[] 变量名 = new 数据类型[数组长度]
int[] arr = new int[3]

数组元素访问

数组名[索引]   # 索引下标为0开始

定义方法的通用格式

public static 返回值类型 方法名(参数){
  方法体;
  return 数据;
}
# 注意：明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果有，写对应的数据类型。
明确参数：主要是明确参数的类型和数量

方法重载

方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
1.多个方法在同一个类中
2.多个方法具有相同的方法名
3.多个方法的参数不相同，类型不同或者数量不同

比较两个数字是否相同的方法重载

public static void main(String[], args){
  //调用方法
  System.out.println(compare(10,20));
  System.out.println(compare((byte)10,(byte)20));
  System.out.println(compare((short)10,(short)20));
  System.out.println(compare((long)10,(long)20));
}
public static boolean compare(int a, int b){
  return a == b;
}
public static boolean compare(byte a, byte b){
  return a == b;
}
public static boolean compare(short a, short b){
  return a == b;
}
public static boolean compare(long a, long b){
  return a == b;
}

方法参数传递

1.方法参数传递(基本类型)
public static void main(String[] args){
  int number = 100;
  System.out.println('调用change之前:' + number);   # 100
  change(number);
  System.out.println('调用change之后:' + number)   #100
}
public static void change(int number){
  number = 200;
}
上面传递number的值100到change方法中，然后将将number重新赋值，并不影响main方法中的number原来的值。所以两次打印的结果都为100；
2.方法参数传递(引用类型)
对于引用类型的参数，形式参数的改变，影响实际参数的值
public static void main(String[] args){
  int[] arr = {10, 20, 30};
  System.out.println('调用change之前:' + arr[1]);   # 20
  change(arr);
  System.out.println('调用change之后:' + arr[1])   #200
}
public static void change(int[] arr){
  arr[1] = 200;
}
上面传递arr的值到change方法中，然后将arr下标为1的索引对应的值重新赋值，影响main方法中的arr中原来的值。所以两次打印的结果不一样；

案例：数组遍历

需求：设计一个方法用于数组遍历，要求遍历的结果在一行上显示，例如：[11,22,33,44,55]
public class ArrFor {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55};
        // 调用方法
        change(arr);
    }
    public static void change(int[] arr){
        System.out.print('[')    # 不换行打印
        for(int i=0;i<arr.length;i++){
            if(i==arr.length-1){
            System.out.print(arr[i]);
    }else{
            System.out.print(arr[i]+",");
    }

        }
        System.out.println(']')
    }
}