java基础混合

01 成员变量与局部变量的区别

• 代码案例：

  public class demo01{
      String name ; //成员变量
  
      public void partA(){
          int num =15; //局部变量
          System.out.println(num);
          System.out.println(name);
      }
      public void partB(int c){//方法的参数就是局部变量
  
      //参数在方法调用时，必然会被赋值
      System.out.println(c);
      int age;//局部变量，没赋值不可用
      System.out.println(name);//可在partB中调用成员变量，但不能调用partA的局部变量num
      }
  }
  

  02 关于java修饰符的作用范围

03 this关键字

• this
  当方法的局部变量和类的成员变量重名的时候，采用“就近原则”，优先使用局部变量；
  如果需要访问本类的成员变量，使用格式： this.成员变量名

• 关于this的知识

  • 通过谁调用的方法谁就是this
  • 使用this可以区分成员变量和局部变量
  • this不能用于静态方法中（静态方法的对象已经实例化！）
  • 在构造方法中使用时，必须置于构造方法的第一行

04 构造方法

• 什么是构造方法？
  构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法
• 构造方法的格式

   public 类名称(参数类型 参数名称){
       方法体
   }
  

• 注意：

  1. 构造方法的名称必须和所在的类名称完全一样，大小写也必须一样
  2. 构造方法不要写返回值类型（void也不行）
  3. 构造方法不能return一个具体的返回值
  4. 如果没有编写任何构造方法，那么编译器会默认创建一个无参构造方法，方法体什么都不做
  5. 构造方法也可以进行重载（重载：方法名称相同，参数个数\顺序\类型不同）

  • 代码展示：

    public class teacher{
        private String name;
        private int age;
        //无其他任何构造方法创建时，会默认创建一个构造方法
        public teacher(){
    
        }
        public teacher(){
            //无参的构造方法
            System.out.println("这是一个构造方法！");
        }
        public teacher(String name, int age ){
            //有参的构造方法
            this.name=name;
            this.age= age;
        }
        //get/set构造器
        public void setName(String name){
            this.name= name;
        }
        public String getName(String name){
            return name;
        }
        public void setAge(int age){
            this.age= age;
        }
        public int getAge(int age){
            return age;
        }
    }
    

  • 一个标准的类所需的部分
  1. 所有的成员变量都需用private关键字修饰
  2. 为每一个成员变量编写getting\setting构造器
  3. 编写一个无参的构造方法
  4. 编写一个有参的构造方法

05 Scanner类的使用

• 通过使用Scanner类，实现键盘输入功能

• 使用步骤：

  1. 导包

     import java.util.Scanner;
     

  2. 创建对象

     Scanner s = new Scanner(System.in);//s为对象名
     

  3. 使用对象
     对象名.成员方法名

     int num = s.nextInt();//键盘输入一个整型，并赋值给num变量
     

06 匿名对象

• 匿名对象的基本了解

  • 匿名对象就是只有右边的对象，没有左边的名字和赋值运输符

  new 类名();

  new person().name ="大司马";
  new person().showName();//此时的匿名对象为全新的，不可引用上次的对象变量
  

  • 匿名对象只能使用唯一的一次，下次在使用必须创建一个新的对象
  • 如果确定有一个对象只需使用唯一一次，则可以使用匿名对象

• 键盘输入与传参

  • 使用匿名对象进行键盘输入

    int num = new Scanner(System.in).nextInt();
    System.out.println(num);
    

    • 对比一般键盘输入

      Scanner sc = new Scanner(System.in);
      int num2= sc.nextInt();
      System.out.println(num2);
      

  • 使用匿名对象传参

    public class demo01{
      public static void main (String[] args){
          methoddemo(new Scanner(System.in));
      }
      public static void methoddemo(Scanner sc){
        int i = sc.nextInt();
        System.out.println(i);
      }
    }
    

  • 使用匿名对象用返回值键盘输入

     public class demo01{
      public static void main (String[] args){
        Scanner sc = methodreturn();
        int num = sc.nextInt();
        System.out.println("输入的值为："+num);
      }
      public static void methodreturn){
        return new Scanner(System.in);
      }
    }
    

07 Random类

• Random类用来生产随机数字
• 使用步骤
  1. 导包

     import java.util.Random;
     

     2.创建对象

     Random r = new Random();
     

     3.使用

     int num = r.nextInt();
     

• 有范围的生成随机数

  int n=5;
  Random r= new Random();
  int result = r.nextInt(n);//范围为[0,n)
  int result2 = r.nextInt(n)+1;//范围为[1,n+1)
  

  08 字符串String类

• String类概述

  • java.lang.String类表示字符串
  • String类为final类型是不可修改的，也不能被继承，一旦创建了String对象，他的值就无法改变，如果需要对字符串进行修改，则需要使用StringBuffer或StringBuilder类

• 字符串的特点

  • 字符串的内容永不改变
  • 字符串可以共享使用
  • 底层原理是byte[]字节数组
• 三种创建方式
  1. 使用无参构造，创建一个空字符串，无任何内容

     String str1 = new String();
     

  2. 根据字符数组创建字符串

     Char[] chars = {'A','B','C'};
     String str2 = new String(charsnum);
     

  3. 根据字节数组创建字符串

     byte[] bytesnum ={97,98,99};
     String str3 = new String(bytesnum);
     System.out.println(str3);//打印的是其字节码对应的字符
     

  4. 直接创建（本质上也是创建了对象，只不过jvm帮你了！）

     String str4 = "lesuit";
     

• 字符串比较

  • ‘==’ 是对对象的地址值进行比较，若比较其内容，可以使用public boolean equals(Object obj)进行比较
  • 任何对象都能用object进行接收
  • equals方法具有对称性，a.equals(b)和b.equals(a)效果一样
  • 比较的一个是常量一个是字符串时，字符串应该放在前面(“abc”.equals(Str))，否则会报错，出现空指针异常
    例如：
    ```java
    String str1 = “Hello”;
    String str2 = “Hello”;
    char[] arr = {‘H’,’e’,’l’,’l’,’o’};
    String str3 = new String(arr);
    String str4 = “hello”;

  System.out.println(str1.equals(Str2));//显然为true
  System.out.println(str2.equals(Str1));//true
  System.out.println(str1.equals(Str3));//true
  System.out.println(str1.equals(Str4));//false

  String str5 = “black”;
  System.out.println(“black”.equals(str5));//true,推荐使用
  System.out.println(str5.equals(“black”));//虽然也为true但会出现空指针异常
  ```

• 字符串的获取

  • 常用方法：

    1. public int length(),获取字符串当中含有字符的个数，获取字符串长度
    2. public String concat(String str),将当前字符串和参数字符串拼接成为新的字符串
    3. public char charAt(int index),获取指定索引位置的单个字符（从0开始）
    4. public int indexOf(String str),查找参数字符串在本字符串中首次出现的位置，如果没有返回-1
       ```java
       //获取字符串长度
       int stringlen = “abcderfhijkouys”.length();
       System.out.println(“字符串的长度：”+stringlen);
       //拼接字符串
       String str1 = “hello”; //hello
       String str2 = “world”; //world
       String str3 = str1.concat(str2); //helloworld

    //查找单个字符
    String str4 = “hello”;
    char ch = str4.charAt(1);
    System.out.println(str4+”的第一个字符是”+ch);
    //查找参数字符串在原字符串出现的第一次的索引位置
    String str6 = “nothingisimpossiblenothing”;
    int index = str6.indexOf(“ing”);
    System.out.println(index);//4
    ```

• 字符串的截取方法
  • public String substring(int index)，截取从参数位置一直到字符串结尾，返回新的字符串
  • public String substring(int begin,int end),截取从begin开始end结束的字符串 [begin,end)

    String str1 = "helloworld";
    String str2 = str1.substring(5);//world
    string str3 = str1.substring(3,6);//low
    

• 字符串的常用转换方法
  • public char[] toCharArray(),将当前字符串拆分成字符数组作为返回值
  • public byte[] getBytes(),获取当前字符串底层的字节数组
  • public String replace(CharSequence oldString,CharSequence newString),将所有出现的原字符串替换为新字符串，返回替换之后的新字符串

    //转换为字符数组
    char[] chars = "Hello".toCharArray();
    System.out.println(chars[0]); //H
    System.out.println(chars.length); //5
    //转换为字节数组
    byte[] bytes = "abc".getBytes();
    for(int i = 0;i<bytes.length,i++){
    System.out.println(byte[i]);
    }
    //内容替换
    String str1= "what the fuck";
    Sting str2= str1.replace("fuck","****");
    System.out.println(str1);//what the fuck
    System.out.println(Str2);//what the ****
    

• 字符串分割方法
  • public String[] split(String regex),按照参数的规则，将字符串切分成若干部分
  • split方法的参数其实是一个正则表达式，要按照“ . ”进行切分，必须写成”\.“

    String str1 ="what a beautiful world";
    String[] arr1 = str1.split(" ");//逢遇到空格就切割形成新的字符串
    for(int i = 0; i<arr1.length;i++){
    System.out.println(arr1[i]);
    }
    

09 Arrays工具类

• java.util.Arrays是一个与数组相关的工具类，里面提供了大量的静态方法，用来实现数组场景的操作
• public static String toString(数组名),将参数数组变成字符串[元素1，元素二….]

• public static void sort(数组名)，按照默认升序对数组的元素进行排序（若元素为数值，则sort默认升序；若元素为字符串，则sort默认按照字母升序，若为自定义类型，需要通过Comparable接口支持）

  int[] intArray = {10,20,45};
  String intStr = Arrays.toString(inArray);
  System.out.println(intstr);
  
  int[] arr1 = {1,5,89,63,12};
  Arrays.sort(arr1);
  System.out.println(Array.toString(arr1));
  
  String[] arr2 = {"aaa","bbb","ccc"};
  Arrays.sort(arr2);
  System.out.println(Arrays.toString(arr2));
  
  //倒序遍历
  String str = "ahsdhancaciosihd";
  char[] chars = str.toCharArray();
  Arrays.sort(chars);
  for(int i =chars.length-1;i>=0;i--){//IDEA快捷键：数组名.forr
     System.out.println(chars[i]);
  }
  

10 Math工具类

• java.util.Math类是数学相关的工具类，提供大量静态方法，完成与数学相关的操作
  • public static double ads(double num)，获取绝对值
  • public static double ceil(double num),向上取整
  • public static double floor(double num),向下取整
  • public static long round(double num),四舍五入

11 抽象类与抽象方法

• 抽象方法
  就是加上abstract关键字，然后去掉大括号，直接分号结束
• 抽象类
  抽象方法的所在类，必须是抽象类，在class前加abstract关键字

• 注意：

  • 不能直接创建new抽象类对象
  • 必须用一个子类来继承抽象父类
  • 创建子类对象时进行使用
  • 抽象类不能创建对象，如果创建，编译无法通过而报错，只能创建其非抽象子类的对象（假设创建了抽象类的对象，调用了抽象类的方法，而抽象方法没有具体的方法体没有意义）
  • 抽象类中，可以有构造方法，是供子类创建对象时初始化父类使用的（子类的构造方法中，有默认的super()，需要方法父类的构造方法）
  • 抽象类中，不一定包含抽象方法，但是有抽象方法必定有抽象类（未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计）
  • 抽象类的子类，必须重写抽象父类中所有的抽象方法
    ```java
    public abstract class Person{
    //抽象方法，无方法体
    public abstract void eat();
    //普通方法
    public void eating(){

  }
  }
  ```

12 接口（interface）

• 接口概述

  • 接口就是多个类的公共规范
  • 接口是一种引用数据类型
  • 接口都可以定义抽象方法
  • 接口不能直接使用，必须有一个实现类来实现接口

• 格式：
  public abstract 返回值类型 方法名（参数列表）;

• 使用步骤

  • public class 实现类名 implements 接口名{ }
  • 接口的实现类必须重写接口的所有抽象方法（去掉abstract，加上方法体）
  • 创建实现类对象，使用
• 接口默认方法
  • 格式：
    • public default 返回值类型 方法名（参数列表）{ }
  • 使用方法
    1. 接口的默认方法，可以通过接口实现类对象直接调用
    2. 也可以被接口实现类进行覆盖重写
• 接口静态方法
  • 格式：
    • public static返回值类型 方法名（参数列表）{ }
  • 使用方法
    • 通过接口名，直接调用其中的静态方法
      • 接口名.静态方法名（参数）;
• 接口私有方法
  • 使用场景
    • 需要抽取一个公有方法，来解决两个默认方法之间代码重复的问题（公有方法不能让实现类使用）
  • 普通私有方法：解决多个默认方法之间重复代码问题
    • private 返回值类型 方法名（参数）{ }
  • 静态私有方法：解决多个静态方法之间重复代码问题
    • private static 返回值类型 方法名（参数）{ }
• 接口的常量
  • 格式
    • public static final 数据类型 常量名 = 数值；

      public static final int OUT_OF_BUSS = 12;
      

• 关于常量
  • 可以省略 public static final
  • 必须赋值
  • 常量名必须大写，多个单词用下划线分隔开