# 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 修饰符的作用范围

访问修饰符 本类 同包 子类 其他
private
default
protected
public

# 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;
    1. 创建对象
    Scanner s = new Scanner(System.in);//s 为对象名
    1. 使用对象
      对象名。成员方法名
    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. 导包
    a
    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();
    1. 根据字符数组创建字符串
    Char[] chars = {'A','B','C'};
    String str2 = new String(charsnum);
    1. 根据字节数组创建字符串
    byte[] bytesnum ={97,98,99};
    String str3 = new String(bytesnum);
    System.out.println(str3);// 打印的是其字节码对应的字符
    1. 直接创建(本质上也是创建了对象,只不过 jvm 帮你了!)
    String str4 = "lesuit";
  • 字符串比较

    • ‘==’ 是对对象的地址值进行比较,若比较其内容,可以使用 public boolean equals (Object obj) 进行比较
    • 任何对象都能用 object 进行接收
    • equals 方法具有对称性,a.equals (b) 和 b.equals (a) 效果一样
    • 比较的一个是常量一个是字符串时,字符串应该放在前面 (“abc”.equals (Str)),否则会报错,出现空指针异常
      例如:
    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
    // 获取字符串长度
    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 (),需要方法父类的构造方法)
    • 抽象类中,不一定包含抽象方法,但是有抽象方法必定有抽象类(未包含抽象方法的抽象类,目的就是不想让调用者创建该类对象,通常用于某些特殊的类结构设计)
    • 抽象类的子类,必须重写抽象父类中所有的抽象方法
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
    • 必须赋值
    • 常量名必须大写,多个单词用下划线分隔开

请我喝[茶]~( ̄▽ ̄)~*

Peter Pan 微信支付

微信支付

Peter Pan 支付宝

支付宝