Java复盘

一、常用语法

基础语法

​ 1、输入: Scanner sc = new Scanner(System.in);

​ int/String 变量名 = sc.nextInt(); //a为接收字符的变量

基础思想知识

• 链式编程:调用一个方法的时候,不需要变量接受它的结果,可以继续调用其他方法

  ​ eg sb.append(“aaa”).append(“bbb”);

  ​ eg:String result = new StringBuilder(str).append(str).reverse().toString(); 字符串反转

技巧

idea快捷操作

​ 1、psvm : public static void main(String[] args) {}

​ 2、sout : System .out.println();

• 快捷键

  • 快速生成构造方法:alt+insert
  • 格式化代码 ctrl + alt + L

• 好用方法

  • 按住鼠标滚轮或者按alt 可以垂直勾选
  • 快速生成标准Javabe类 ptg插件安装后 鼠标右键
  • 显示对象的参数 ctrl + p Dog g1 = new Dog(); 在括号里按快捷键 会显示带参构造的参数.
  • fori ; arr.fori 快速生成 数组的遍历for循环 str.length().fori 集合遍历list.fori
  • ctrl + shift + t : 用循环体等包裹代码

常用方法

• 注意事项:

  • 遍历对象数组的使用get set方法 要进行非空判断否则为存满可能报错

• • 键盘录入：

    Sanner sc = new Sanner(System.in);
    int a = sc.nextInt(); //用变量a接收输入的整数
    /*
    	nextDouble();接收小数
    	next(); 接收字符串
    	
    	遇到空格,制表符,回车就停止接收.这些符号后面的就不会接收了,后面的会传给下一个next**接收
    */
    
    /*
    	第二套
    	nextLine();接收字符串
    	可以接收空格制表符,遇到空格才停止接收数据
    */
    
    //混用 先用nextInt 再用nextLine 会导致下面nextLine接收不到数据  输入123 其实是123+回车 , 回车被下面的nextLine接收了 学完类型转换再用第二套
    

  • 跳出到外面循环(System.exit(0); //停止虚拟机运行)

    //给外面循坏起个名字 ,然后在里面跳到外面循环
    while (true) {
                System.out.println("-----------------欢迎来到mikotokoruk学生管理系统-------------------");
                System.out.println("1:添加学生");
                System.out.println("5:退出");
                System.out.println("请输入您的选择：");
                Scanner sc = new Scanner(System.in);
                String choose = sc.next();
                switch(choose){
                    case "1" -> System.out.println("添加学生");
                        System.out.println("退出");
                        break;  //这里break只跳出Switch
                    }
                    default -> System.out.println("无此选项");
                }
            }
    
    loop: while (true) { //给外面循坏起个名字 ,然后在里面跳到外面循环
                System.out.println("-----------------欢迎来到mikotokoruk学生管理系统-------------------");
                System.out.println("1:添加学生");
                System.out.println("5:退出");
                System.out.println("请输入您的选择：");
                Scanner sc = new Scanner(System.in);
                String choose = sc.next();
                switch(choose){
                    case "1" -> System.out.println("添加学生");
                        System.out.println("退出");
                        break loop;  //调出到loop外面
                    }
                    default -> System.out.println("无此选项");
                }
            }
    

  • 生成随机数:

    Random r = new Random();
    int number1 = r.nextInt(100);   //生成[0,100)间的整数,不包括100
    int number2 = r.nextInt(100)+1; //生成1-100间的整数
    

  • int number = r.nextInt(arr.length); //生成0-索引最大值的随机索引

    //小于零值为零 否则还是那个值
    remainBlood = remainBlood < 0 ? 0 : remainBlood;
    

  • 随机挑选数组中的元素

    //eg
    String[] boyfaces= {"风流俊雅","气宇轩昂","相貌英俊","五官端正","相貌平平","一塌糊涂","面目狰狞"};
    
    Random r1 = new Random();
    int index = r1.nextInt(boyfaces.length);//生成其索引的随机数
    String face = boyfaces[index];
    
    

  • 判断数组中有多少元素的方法

    public static int getCount(Student[] arr){
        int cnt=0;
        for(int i = 0; i<arr.length; i++){
            if(arr[i] != null);
            cnt ++;
        }
        return cnt;
    }
    

  • 将数组扩大一位(不实用 后面用ArrayList对象)

        //创建一个新数组 长度为老数组加一
        //之前元素拷贝到新数组中
    public static Student[] createNewArr(Student[] arr){
        Student[] newArr = new Student[arr.length+1];
        for(int i = 0; i<arr.length; i++){
            newArr[i] = arr[i]; 
        }
        return newArr;
    }
    

  • 打印对象数组元素的信息

    //注意非空才打印
    public static void printArr(Student[] arr){
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]!=null){
                System.out.println(arr[i].getId()+","+arr[i].getName()+","+arr[i].getAge());
            }
        }
    }
    

  • 字符串反转

    String result = new StringBuilder(str).append(str).reverse().toString();
    

基础技巧

• 判断大小写字母

  • if(c >= 'a' && c <= 'z')//小写
    if(c >= 'A' && c <= 'Z')//大写
    

• 字符型数字转换为整型

  • char c = '2';
    //利用ASCII码表进行转换
    //'0' --->  48
    //'1' --->  49
    //'2' --->  50
    int num = c - 48;
    

• 获取整数中每一位数(取模得到最右边一位 然后除10)

  • //得到money中每一位数字  eg 123 从右获取 3 2 1
    /*
    123 第一次 ge = 3 moeny =12
        第二次 ge = 2 moeny =1
        第三次 ge = 1 moeny =0 跳出循环
     */
    while(true){
        int ge = money % 10;//123%10 = 3     12%10 = 2
        System.out.println(ge);   //第一次输出3 第二次输出2 第三次
        money = money / 10;  //但是当其等于0的时候没有必要再除
        if(money == 0){
            break;
        }
    }
    

• 反拿反拼

  //得到money中每一位数字  eg 123 从右获取 3 2 1  并转换为大写字符串
  /*
  123 第一次 ge = 3 moeny =12
      第二次 ge = 2 moeny =1
      第三次 ge = 1 moeny =0 跳出循环
   */
  String moenyStr = "";
  while(true){
      int ge = money % 10;//123%10 = 3     12%10 = 2
  	moenystr = moneystr + ge; //得到的是321
     	moenystr = ge + moneystr; //得到的是123
      money = money / 10;  //但是当其等于0的时候没有必要再除
      if(money == 0){
          break;
      }
  }
  
  

易错

• 循环中定义的变量 只在循环内生效 解决办法 在循坏外定义不赋值 循环里面赋值

面向对象

子类中用继承

//可手动写子类的带参构造
public Student(String name,int age){
    super(name,age);
}

常用基础知识

常用的

• souf(System.out.printlf(“”)😉 输出语句

  • eg
    System.out.printlf("你好,%s","张三");
    System.out.printlf("你好,%s %s","张三","李四");
    //只有输出没有换行
    

​ 字符与数字用加号连接 eg：“个位是”+ge

​ 字符+字符/字符加数字 先通过ASCII码表查询到对应数字再计算

​ 1+‘a’ 结果98

​ 1+“a” 结果“1a"

​ 只要有字符串出现进行相加就是拼接操作并产生新字符串

​ ‘a’ ----- 97

​ ‘A’ ----- 65

​ && 和 & 、||和|的运行结果都是一模一样的。

​ 但是短路逻辑运算符可以提高程序的运行效率。

关系表达式 ？ 表达式1 ：表达式2 ；

• 计算关系表达式的值。
• 如果关系表达式的值为真，那么执行表达式1。
• 如果关系表达式的值为假，那么执行表达式2。

​ int max = a > b ? a : b ;

` //格式：关系表达式 ？ 表达式1 ： 表达式2 ；
//注意点：
//三元运算符的最终结果一定要被使用。
//要么赋值给一个变量，要么直接输出。
int max = a > b ? a : b ;
System.out.println(max);

        //格式：关系表达式 ？ 表达式1 ： 表达式2 ；
        //注意点：
        //三元运算符的最终结果一定要被使用。
        //要么赋值给一个变量，要么直接输出。
       int max =  a > b ? a : b ;
        System.out.println(max);
	    System.out.println(a > b ? a : b);

​

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

package a01switch选择语句;

import java.util.Scanner;

public class SwitchDemo2 {
    public static void main(String[] args) {
        //1.键盘录入一个整数表示星期
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数表示星期");
        int week = sc.nextInt();

        //2.书写一个switch语句去跟week进行匹配
        switch (week){
            case 1:
                System.out.println("跑步");
                break;
            case 2:
                System.out.println("游泳");
                break;
            case 3:
                System.out.println("慢走");
                break;
            case 4:
                System.out.println("动感单车");
                break;
            case 5:
                System.out.println("拳击");
                break;
            case 6:
                System.out.println("爬山");
                break;
            case 7:
                System.out.println("好好吃一顿");
                break;
            default:
                System.out.println("输入错误，没有这个星期");
                break;
        }
    }
}

jdk12
int number = 10;
switch (number) {
    case 1 -> {
        System.out.println("一");
    }//只有一行代码大括号可省略
    case 2 -> System.out.println("二");
    case 3 -> System.out.println("三");
    default -> System.out.println("其他");
}

利用JDK12简化代码书写
switch (week) {
    case 1, 2, 3, 4, 5 -> System.out.println("工作日");
    case 6, 7 -> System.out.println("休息日");
    default -> System.out.println("没有这个星期");
}

case穿透

不写break会引发case穿透现象

不写break程序会继续执行下一个case语句体（尽管不满足那个case条件）；

应用：多个case语句体重复，可用case穿透简化代码

• switch和if第三种格式各自的使用场景

当我们需要对一个范围进行判断的时候，用if的第三种格式

当我们把有限个数据列举出来，选择其中一个执行的时候，用switch语句

比如：

​ 小明的考试成绩，如果用switch，那么需要写100个case，太麻烦了，所以用if简单。

​ 如果是星期，月份，客服电话中0~9的功能选择就可以用switch

数组

​ 可以存储同种数据类型多个值的容器

​ 定义 1.int [] array (常用) 2.int array []

​ 1. 静态初始化: 数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3，元素4…}; eg:int[] arr = new int[] {11,22,33};

​ 常用简化: 数据类型[] 数组名 = {元素1，元素2，元素3，元素4…}; eg:int[] array = {1,2,3,4,5}

​

int[] arr = {1,2,3,4,6};
System.out.println(arr);//这里输出的是地址值
System.out.println(arr[1]);

​ 想正常访问要加索引 (从0开始的)

2. 动态初始化 eg:int[] arr = new int[3]; 手动指定数组长度 其他没有赋值都是默认值

数组常用技巧

获取数组长度(用length属性)

​ arr.length 就是数组长度

数组常用操作

• 求最值 求和 交换数据 打乱数据(用0,1,2…等索引与随机索引交换元素)

练习6：***交换数据 (***两个指针一起双向奔赴)

需求：定义一个数组，存入1,2,3,4,5。按照要求交换索引对应的元素。交换前：1,2,3,4,5交换后：5,2,3,4,1

//1.定义数组存储数据
int[] arr = {1,2,3,4,5};
//2.利用循环去交换数据
for(int i = 0,j = arr.length - 1; i < j; i++,j--){
    //交换变量i和变量j指向的元素
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}
//当循环结束之后，那么数组中的数据就实现了头尾交换
for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i] + " ");
}

打乱数据

• int number = r.nextInt(arr.length); //生成0-索引最大值的随机索引
• 因此随机的生成为[0-所填数)

方法

程序中最小的执行单元 用:重复高,有独立功能 好处:复用性,可维护性

定义与调用

定义写在main方法外面 调用写在里面

//定义
public static void 方法名 (   ) {
	// 方法体;
}

//调用
方法名();

//带参数 参数格式  数据类型 变量名 eg int a
public static void 方法名 (参数1) {
	方法体;
}

public static void 方法名 (参数1, 参数2, 参数3...) {
	方法体;
}

• 注意 return关键字 无返回值可不写 有返回值必须写 return下面不执行 写在方法里面

方法重载

多个方法在同一个类中,有相同方法名,参数不同数据类型不同

• *同一个类中,方法名相同,参数不同的方法.(与返回值无关) 一定注意参数是指形参 方法括号里面的

public class MethodDemo {
	public static void fn(int a) {
    	//方法体
    }
    public static int fn(double a) {
    	//方法体
    }
}

//不构成  不在同一个类
public class MethodDemo01 {
    public static void fn(int a) {
        //方法体
    }
} 
public class MethodDemo02 {
    public static int fn(double a) { /*错误原因：这是两个类的两个fn方法*/
        //方法体
    }
}

面向对象

三种类

• Javabean类:用来描述一类事物的类.比如Student,Teacher

• 测试类:用来检查其他类是否书写正确,带有main方法,程序主入口

• 工具类:帮我们做一些事情的类

  • eg

    //私有化成员变量不让外界创建这个类 方法都定义为静态
    public class ArrUtil{
    	private ArrUtil(){
        }    
        
        public static void getMax(){}
    }
    

想干什么都是找一个个东西来解决 对象即一个又一个能帮我们解决问题的东西

有些东西并不是凭空出现

• 类:类就是对现实事物的一种描述(理解为设计图)

• 类和对象的关系:类是对事物的一种描述，对象则为具体存在的事物

• 类的定义步骤：

  ①定义类 ②编写类的成员变量 ③编写类的成员方法

  类的组成 ①属性: ②行为:通常用方法体现

  类是抽象的 只定义不给值

  — 类里面的行为的方法不用static

  public class 类名 {
  	// 成员变量
  	变量1的数据类型 变量1；//类是抽象的 只定义不给值
  	变量2的数据类型 变量2;
  	…
  	// 成员方法
  	方法1;
  	方法2;	
  }
  
  //对象的使用/*
      创建对象
          格式：类名 对象名 = new 类名();
          范例：Phone p = new Phone();
  
      使用对象
          1：使用成员变量
              格式：对象名.变量名
              范例：p.brand
          2：使用成员方法
              格式：对象名.方法名()
              范例：p.call()
   */
  public class Phone {
      //成员变量
      String brand;
      int price;
  
      //成员方法
      public void call() {
          System.out.println("打电话");
      }
  
      public void sendMessage() {
          System.out.println("发短信");
      }
  }
  
  public class PhoneDemo {
      public static void main(String[] args) {
          //创建对象
          Phone p = new Phone();
  
          //使用成员变量
          System.out.println(p.brand);
          System.out.println(p.price);
  
          p.brand = "小米";
          p.price = 2999;
  
          System.out.println(p.brand);
          System.out.println(p.price);
  
          //使用成员方法
          p.call();
          p.sendMessage();
      }
  }
  
  //例如数组中 有arr.length属性
  

  • Javabean类:用来描述一类事物的类,不写main方法

    • public class 类名{

      ​ 1.成员变量(代表属性)

      ​ 2.成员方法(代表行为)

      }

  • 测试类:编写main方法的类 ,可以在测试类中创建Javabean类并进行赋值使用

• 注意

  • 一个文件定义一个class类

  • 成员变量 一般无需指定初始值(所有的学生都交张三?)

面向对象三大特征

封装 继承 多态

• 封装:

  eg:定义一个类描述人 只要一个类就行

  eg:人画圆 里有两个对象人和圆 要定义一个类 人 一个类 圆 画这个动作 放在圆里

  圆是自己画出来的 人只是调用了 画圆的方法 画圆要知道圆的属性 所以放到圆里面

  人关门 : 门是自己关的 人只是给门一个作用力而已 关门这个方法是门的方法不是人的

  • 对象代表什么，就得封装对应的数据，并提供数据对应的行为

    public static Circle(){
        double r;
        public void draw(){
            System.out.println("画圆");
        }
    }
    

  • private修饰符:被private修饰的成员，只能在本类进行访问 为了保护数据安全性

    • 要想访问private修饰的成员 要用“get变量名()”“set变量名(参数)”(用public修饰)
    • set方法:给变量赋值 , 无返回值
    • get方法:对外提供成员变量的值

    /*
        学生类
     */
    class Student {
        //成员变量
        String name;
        private int age;
    
        //提供get/set方法
        public void setAge(int a) {
            if(a<0 || a>120) {
                System.out.println("你给的年龄有误");
            } else {
                age = a;
            }
        }
    
        public int getAge() {
            return age;
        }
    
        //成员方法
        public void show() {
            System.out.println(name + "," + age);
        }
    }
    /*
        学生测试类
     */
    public class StudentDemo {
        public static void main(String[] args) {
            //创建对象
            Student s = new Student();
            //给成员变量赋值
            s.name = "林青霞";
            s.setAge(30);
            //调用show方法
            s.show();
        }
    }
    

  • this关键字:成员变量与局部变量(方法里面的变量)重名 , 就近原则局部优先 , 优先输出方法里面的局部变量, 加this可输出成员变量

    • 成员变量:类中,方法外
    • 局部变量:方法内

    //用例 这里this.name是setName外面的属性.
    public void setName (String name) {
            this.name = name;
    }
    

• 构造方法

  /*创建对象   Student stu = **new Student();**
  
  是一种特殊的方法 主要是完成对象数据的初始化
  
  格式
    public class 类名{
           修饰符 类名( 参数 ) {
           }
    }*/
  //   
        
  public class Student {
      private String name;
      private int age;
  
      //构造方法 空参构造
      public Student() {
          System.out.println("无参构造方法");
      }
  	//构造方法 
      public Student(String name, int age){
          this.name = name;
          this.age = age;
      }
      
      //行为
      public void show() {
          System.out.println(name + "," + age);
      }
  }
  /*
      测试类
   */
  public class StudentDemo {
      public static void main(String[] args) {
          //创建对象
          Student s = new Student();//会执行上面的 输出"无参数构造方法"
          Student s = new Student("xiaowang",23);//会执行上面带参数构造
          s.show();
      }
  }
  

  • 注意

    • 作用:创造对象的时候，由虚拟机自动调用，给成员变量进行初始化的。

    • 无参数构造方法:初始化的对象时，成员变量的数据均采用默认值。

      有参数构造方法: 在初始化对象的时候，同时可以为对象进行赋值。

    • 注意

      • 任何类定义出来，默认就自带了无参数构造器，写不写都有
      • 一旦定义了有参数构造器，无参数构造器就没有了，此时就需要自己写无参数构造器了
      • 建议在任何时候都手动写上空参和带全部参数的构造方法

标准的Javabean类

① 类名需要见名知意

② 成员变量使用private修饰

③ 提供至少两个构造方法

• 无参构造方法
• 带全部参数的构造方法

④ get和set方法 : 提供每一个成员变量对应的setXxx()/getXxx()

⑤ 如果还有其他行为，也需要写上

• public class User{
      //属性
      private String name;
      private String password;
      private String email;
      private String gender;
      private int age;
      
      //空参
      public User(){
          System.out.println("空参构造哦");
      }
      
      //带全部参的构造
      public User(String name, String password, String email, String gender, int age){
          this.name = name;
          this.password = password;
          this.email = email;
          this.gender = gender;
          this.age = age;
      }
      
      //get()和set()方法
      public void setName(String name){
          this.name = name;
      }
      public String getName(){
          return name;
      }
  }
  
  //
  

练习

注意:改值用set()方法改 获取值用get()方法

eg:用name1变量接受小明名字:name1 = getName();

小明年龄设成18岁:xiaoming.setAge(18);

• 格斗游戏

  • package com.mikotokoruk.test;
    
    import java.util.Random;
    
    public class Role {
        //格斗游戏 血量姓名 k o
        private String name;
        private int blood;
    
        public Role() {
        }
    
        public Role(String name, int blood) {
            this.name = name;
            this.blood = blood;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getBlood() {
            return blood;
        }
    
        public void setBlood(int blood) {
            this.blood = blood;
        }
    
    
        //定义一个方法用于攻击别人
        //Role r1 = new Role();
        //Role r2 = new Role();
        //r1.攻击(r2);  方法的调用着攻击参数
        public void attack(Role role){
            //计算造成伤害 //加一表示1-20
            Random r = new Random();
            int hurt = r.nextInt(20)+1;
    //        role.blood = role.blood-hurt;
            int remainBlood = role.getBlood()-hurt;
    
            remainBlood = remainBlood < 0 ? 0 :remainBlood;
    
            //修改挨揍人的血量 改要用set方法不能直接改
            role.setBlood(remainBlood);
    
    
            //this 表示方法的调用者
            //A打了B一下造成XX点伤害,B还剩XX血
            //这里用this.getName
            //System.out.println(this.name + "打了" + role+"一下,造成"+""+"点伤害"+role+"还剩"+""+"血");
            System.out.println(this.getName() + "打了" + role.getName()+"一下,造成"+hurt+"点伤害"+role+"还剩"+remainBlood+"血");
    
    
    
        }
    }
    
    

批量往对象类型的数组中存入对象

       Car[] arr = new Car[3];

        Scanner sc = new Scanner(System.in);
        for(int i = 0; i<arr.length;i++){
            Car c = new Car();
            System.out.println("请输入第"+i+"辆车的品牌:");
            String brand = sc.next();
            c.setBrand(brand);
            // 课替换为 c.setBrand(sc.next());

            System.out.println("请输入第"+i+"辆车的价格:");
            c.setPrice(sc.nextInt());

            System.out.println("请输入第"+i+"辆车的颜色:");
            c.setColor(sc.next());

            arr[i] = c;
        }

API

​ 简单理解: API就是别人已经写好的东西,我们不需要自己编写,直接使用即可

​ java API : JDK中提供的

字符串

​ String StringBuilder StringJoiner

字符串内容不能被改变(可通过转化为数组改变后再转化为字符串)

String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例。

• 创建String对象

• 2.3String类的构造方法

  • 常用的构造方法

    方法名	说明
    public String()	创建一个空白字符串对象，不含有任何内容
    public String(char[] chs)	根据字符数组的内容，来创建字符串对象
    public String(byte[] bys)	根据字节数组的内容，来创建字符串对象
    String s = “abc”;	直接赋值的方式创建字符串对象，内容就是abc 常用

  • 示例代码

    public class StringDemo01 {
        public static void main(String[] args) {
            //public String()：创建一个空白字符串对象，不含有任何内容
            String s1 = new String();
            System.out.println("s1:" + s1);
    
            //public String(char[] chs)：根据字符数组的内容，来创建字符串对象
            char[] chs = {'a', 'b', 'c'};
            String s2 = new String(chs);
            System.out.println("s2:" + s2);
    
            //public String(byte[] bys)：根据字节数组的内容，来创建字符串对象
            byte[] bys = {97, 98, 99};
            String s3 = new String(bys);
            System.out.println("s3:" + s3);
    
            //String s = “abc”;    直接赋值的方式创建字符串对象，内容就是abc
            String s4 = "abc";
            System.out.println("s4:" + s4);
        }
    }
    

字符串比较

​ 通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同

• String s1 = "abc";
  String s2 = "abc";
  //s1 和 s2在内存里是同一个 结果相等
  
  String s1 = new String("abc");
  String s2 = new String("abc");
  // new 出来的 在内存中开辟新空间 比较的是地址值
  
  String s1 = "abc";
  String s2 = new String("abc");
  //s2 记录堆中的地址值 s1 串池中的地址值 两者不相同
  

常用方式

• 遍历数组(遍历后可进行许多常用操作)

  Scanner sc = new Scanner(System.in);
  System.out.println("请输入一个字符:");
  String str = sc.next();
  for (int i = 0; i < str.length(); i++) {
      char c = str.charAt(i);
      System.out.println(c);
  }
  //
  

字符串常用方法

public char charAt(int index) //根据索引返回字符
public int length()   //返回字符串长度

public boolean equals(String s){}     //比较两个字符串内容是否相同、区分大小写
public boolean equalsIgnoreCase(String s){}  //忽略大小写比较 如验证码    


//截取  注意:包头不包尾 包左不包右 要用变量接收一下
String substring(int beginIndex,int endIndex)
//截取重载方法 
String substring(int beginIndex)
    
    
//替换
String replace(旧值,新值)                                                                                                                      

• 字符串拼接

• 字符串反转

  • StringBuilder :常用于字符串拼接字符串反转

    StringBuilder 可以看成是一个容器，创建之后里面的内容是可变的。

    当我们在拼接字符串和反转字符串的时候会使用到

    public StringBuilder append(任意类型)  //添加数据并返回对象本身
    public StringBuilder reverse()   //反转容器中的内容
    public int length()  //返回长度 (字符出现个数)
    public String toString() //通过toString()就可以实现把StringBuilder转换为String
        
    
    

    //创建示例
    StringBuilder sb = new StringBuilder("abc");
    //此时sb 只是一个容器 帮助我们操作字符串的工具
    String str = sb.toString();
    
    //字符串反转
    String result = new StringBuilder(str).append(str).reverse().toString();
    

  • StringJoiner

    • 注意 StringJoiner的 add() 方法只能添加字符串
    • StringBuilder 的append() 可以添加int 型

    StringJoiner sj = new StringJoiner("间隔符号","开始符号","结束符号")
    //成员方法
    public StringJoiner add()  //添加数据并返回对象本身
    public int length()   //返回长度(字符出现个数)所有字符总个数
    public String toString()  //返回一个字符串(该字符串就是拼接之后的结果)
        
    //eg
    StringJoiner sj = new StringJoiner(",","[","]");
    String str = sj.add("aaa").add("bbb").toString();
    System.out.println(str);//[aaa,bbb]
    
    

集合

​ 长度可变的容器 (添加元素自动扩容) :自动伸缩 可长可短

• 不能存基本数据类型,可以存引用数据类型 (数组都可存)

  • 要存基本数据类型,要先变成包装类再存

  ​

• ArrayList

  • tip

    • 打印对象不是地址值是内容,展示时会拿[]把所有的数据进行包裹

  • 泛型 (加个尖括号里面放入引用数据类型(String是引用数据类型,int不是))

    ArrayList list = new ArrayList<> ();

• ArrayList 成员方法

  • 增删改查

    方法名	说明
    public boolean add(要添加的元素)	将指定的元素追加到此集合的末尾(返回永远true)
    public boolean remove(要删除的元素)	删除指定元素,返回值表示是否删除成功
    public E remove(int index)	删除指定索引处的元素，返回被删除的元素
    public E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
    public E get(int index)	返回指定索引处的元素
    public int size()	返回集合中的元素的个数

• 包装类

  • 常用

    • char Character

    • int Integer

    • 其他第一个字母大写

      //eg
      ArrayList<Integer> list = new ArrayList<>();
      list.add(1);
      

进阶

static

• ​ static是静态的意思。 static可以修饰成员变量或者修饰方法。

注意

• 静态方法中,只能访问静态(不能访问非静态成员变量,不能访问非静态成员方法)

• 非静态方法可以访问所有

• 静态方法中没有this关键字

  • eg

    public class Student {
        private String name;
        private int age;
        private String gender;
        
        public void show1(){
            System.out.println(name+","+age+","+gender);
            show2();
        }
        //上述等价于  不过我们this 通常省略 ,这里this特指这次赋值的这个对象
        public void show1(Student this){
            System.out.println(this.name+","+this.age+","+this.gender);
            this.show2();
            this.method();//非静态方法可以访问所有
        }
        
        public void show2(){
            System.out.println("show2");
        }
        
        public static void method(){
            //System.out.println("this:"+this);//会报错
           	System.out.println("静态方法");
          	//System.out.println(name);   //访问了 非静态报错                                      
        }
        
        //非静态的 是跟对象相关的 跟某个对象相关
        //静态的是共享的 跟某一个对象没有太大关系
        
    }    
    

静态变量

• 特点
  • 被该类所有对象共享
    • 例如班级里老师的姓名
  • 不属于对象,属于类
  • 随着类的加载而加载,优先于对象存在
• 调用方法
  • 类名调用(推荐(不属于类))
    • eg:Studetn.teacherName = “”;
  • 对象调用

静态方法

• 特点

  • 多用在测试类工具类,JavaBean中很少用

• 调用方法:

  • 类名调用(推荐)

  • 对象名调用

继承

• 基础

  • 什么是继承、继承的好处？

    • 面向对象三大特征(封装.继承.多态)之一,可以让类跟类之间产生子父的关系
    • 可以把多个子类中重复的代码抽取到父类中，子类可以直接使用，减少代码冗余，提高代码的复用性

  • 格式

    • public class 子类 extends 父类{}
      

  • 继承后特点

    • 子类可以得到父类的属性和行为，子类可以使用。子类可以在父类的基础上新增其他功能，子类更强大。

  • 继承特点

    • 只能单继承,但支持多层继承 爷爷(间接父类)

    • Java中所有类都直接或者间接继承与Object类

      • eg: public class A{} = public class A extends Objcet{}

    • 子类只能访问父类中非私有成员

  • 继承中成员方法的访问特点:

    this调用:就近原则

    super调用:直接找父类

  • 重写

    • 重写的方法尽量和父类保持一致(名称,形参列表)要用@override备注

    • eg:

      @Override
      public void eat() {
          super.eat();
          System.out.println("吃骨头");
      }
      //调用时如果加super.方法名() 父类和子类重写的都执行
      

  • 继承中构造方法访问特点

    • 子类不能继承父类构造方法,但是可以通过super调用

    • 子类构造方法第一行有个隐藏的super();

    • 默认先访问父类中的无参构造再访问自己. 可手动写子类的有参构造

      • public class Person(){
           String name;
           int age;
           public Person(){}//父类无参
           public Person(String name,int age){
               this.name = name;
               this.age = age;
           }
        }
        public class Studetn extends Person(){
            public Studetn{
                super();//这行是默认的不写也有
            }
            
        	//可手动写子类的带参构造
        	public Student(String name,int age){
                super(name,age);
            }
        }