第三天Java基础（String对象，static关键字，静态，Arrays类,Math类，继承，抽象，接口）

1.字符串常量池

使用双引号包裹的都存在“字符串常量池”中。

2.字符串常用的方法

1.equals(String);//区分大小写
2.equalsIgonreCase(String);//不区分

3.length();//字符串长度
4.concat(String);//拼接字符串
5.charAt(int);//获取指定位置的单个字符串
6.indexOf(String);//查找字符串首次出现的位置，如果没有返回-1

7.subString(int)；//截取
8.subString(int begin,int end);//从begin到end截取[)

9.toCharArray();//拆分
10.getBytes();//拆分
11.replace(CharSequence oldString,CharSequence newString);
//oldString被newString替换

12.split(String);//切割
注意不能以英文中的点“.”为切割元素，需要转译为“杠杠点\.”才能分割。

3.字符串小练习

判断键盘输入字符串的种类：

/**
 * 键盘输入，统计字符串种类，大小写字母，数字或其他
 * 1.使用键盘Scanner
 * 2.接收String str = sc.next();
 * 3.需要比较单个字符char[] ch = str.toCharArray();
 * 4.遍历char[]，定义四个变量进行累加 ++
 * 打印
 */
 public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入：");
        String str = sc.next();
        char[] ch = str.toCharArray();
        int countUpper = 0;
        int countLower = 0;
        int countNuber = 0;
        int countOther = 0;
        for (int i = 0 ; i < ch.length ; i++ ){
            if ('A'<= ch[i] && ch[i] <= 'Z'){
                countUpper++;
            }else if ('a'<= ch[i] && ch[i] <= 'z'){
                countLower++;
            }else if('0'<= ch[i] && ch[i] <= '9'){
                countNuber++;
            }else{
                countOther++;
            }
        }
        System.out.println("大写字母有："+countUpper+"个，小写字母有："+countLower+"个，数字有："+countNuber+"个，其他的有："+countOther+"个。");
    }

4.static

1.静态方法和属性都属于类，不属于对象，所以可以直接用类名进行调用。
2.静态属性内存图

3.静态代码块的典型用途：
为静态属性进行赋值
当首次执行类是，类中的静态代码块将优先于非静态代码块执行，且只执行一次

5.Arrays工具类

1.Arrays.toString(new int[]{1,2,3});// [1,2,3]
2.Arrays.sort(new int[]{3,2,1});//从小到大排序
3.将一个随机字符串进行排序，然后倒序打印

/**
 * 将一个随机字符串进行排序，然后倒序打印
 * 1.需要一个String str;
 * 2.需要用到Arrays.sort进行排序。
 * 3.需要把String str -->char[],用到toCharArray();
 */
public class DayArrays01 {
    public static void main(String[] args) {
        String str = "Sdfsadf1654sd1f65412";
        char[] chars = str.toCharArray();
        Arrays.sort(chars);
        for (int i = chars.length - 1; i >= 0; i--) {
            System.out.println(chars[i]);
        }
    }

6.Math类（数学工具）

1.4+1种方法

• public static double abs();绝对值
• public static double ceil();向上取整
• public static double floor();向下取整
• public static long round(double num);四舍五入
• Math.PI=3.14…
  2.小练习
  -10.8到5.9当中，绝对值大于6或者小于2.5的整数有哪些？

/**
 * -10.8到5.9当中，绝对值大于6或者小于2.5的整数有哪些？
 * 范围是-10.8到5.9，那么for循环可定范围
 * 1.起始位置-10.8向上取整--> -10,使用Math.ceil(),或者直接转化为int舍去小数位。
 * 2.取绝对值，Math.abs(),怎么发现哪些是我们需要的，if(i>6||i<2.5)
 * 3.使用计数器来记录
 */
public class DayMath02 {
    public static void main(String[] args) {
        double min = -10.8;
        double max = 5.9;
        int coun = 0;
        for (int i =(int)Math.ceil(min); i < max; i++){
            if (Math.abs(i)>6||Math.abs(i)<2.5){
                coun++;
                System.out.print(i+",");
            }
        }
        System.out.println(coun);
    }
}

7.继承（extends）

1.Java语言是单继承的。
2.Java语言可以多级继承。
3.子类只能有一个父类，父类可以有多个子类。

8.抽象（abstract）

1.抽象方法所在的类一定是抽象类。
2.抽象类中可以有普通方法。
3.必须继承抽象类才能使用抽象类。
4.抽象类不能new创建。

9.发红包小练习

用户类：

package fahonbao;

public abstract class user {
    private String user;
    private int yuer;

    public user(){

    }
    public void show (){
        System.out.println("我叫："+user+",我有"+yuer+"钱");
    }

    public user(String user, int yuer) {
        this.user = user;
        this.yuer = yuer;
    }

    public String getUser() {
        return user;
    }

    public void setUser(String user) {
        this.user = user;
    }

    public int getYuer() {
        return yuer;
    }

    public void setYuer(int yuer) {
        this.yuer = yuer;
    }
}

群主

import java.util.ArrayList;

public class qunzhu  extends user{
    public qunzhu(){
    }

    public qunzhu(String user, int yuer) {
        super(user, yuer);
    }

    public ArrayList<Integer> send(int m, int s) {
        ArrayList<Integer> arr = new ArrayList<>();
        //1.群主有多少钱
        int yuer = super.getYuer();
        if (yuer<m){
            System.out.println("对不起你的钱不够！");
            return arr;
        }
        //2.从群主的余额中扣，重新设置群众的钱
        super.setYuer(yuer-m);
        //3.如果够每一份应该多少钱
        int pj = m / s;
        //4.如果除不尽余钱给最后一个红包
        int yu = m % s;
        for (int i = 0 ; i < pj-1 ; i++){
            arr.add(pj);
        }
        arr.add(pj+yu);
        return arr;
    }
}

成员

public class chengyuan extends user {
    public chengyuan(){
    }
    public chengyuan(String user, int yuer) {
        super(user, yuer);
    }
    /**
     * 收钱的方法
     */
    public void sou(ArrayList<Integer> m){
        //1.从多个红包中抽一个
        int a = new Random().nextInt(m.size());
        Integer remove = m.remove(a);
        super.setYuer(super.getYuer()+remove);
    }
}

测试

public class TextOut {
    public static void main(String[] args) {
        qunzhu qun = new qunzhu("群主",100);
        chengyuan one = new chengyuan("成员A",0);
        chengyuan tow = new chengyuan("成员B",0);
        chengyuan three = new chengyuan("成员C",0);
        qun.show();
        one.show();
        tow.show();
        three.show();
        System.out.println("----------------------------");
        ArrayList<Integer> send = qun.send(20, 3);
        one.sou(send);
        tow.sou(send);
        three.sou(send);

        qun.show();
        one.show();
        tow.show();
        three.show();
    }
}

10.接口（interface）

1.关键字
interface
implements
注意；接口的实现类必须实现接口中的所有方法，否则实现类必须是抽象的。
Java8：中接口里允许定义默认方法：
在接口中型添加一个方法，子类不用重新去覆盖
主要用于解决接口升级的问题

public default void methodDefault(){
	//这个方法定义在接口当中，实现类可以无条件使用它
	//实现类也可以覆盖该方法
}

Java8中：static
接口中的静态方法

public static void MyInterfaceStatic(){
	//java8后接口中允许使用静态方法
	//该方法只能通过接口名+方法名进行调用
}

java9中：接口中允许使用private

private void MyInterfacePrivate(){
	//主要解决默认方法中重复代码的问题，且不会被实现类调用
}
private static void MyInterfacePrivateAndStatic(){
	//也可以于static一起使用
}

java9中：常量的使用

public static final int i = 10;
//固定写法

小结

注意事项

接口时允许多继承的

11.多态

多态指的是对象拥有多种形态，
代码中的体现就是
父类引用指向子类对象；
Fu f = new Zi();

11.1多态中成员变量的访问方式

变量两种访问方式：
1.直接通过对象名称去访问，看等号左边是谁，优先用谁，没有向上找。
2.间接通过成员方法去访问，看该方法属于谁，优先用谁，没有向上找。

11.2多态中成员方法的访问方式

1.看new的是谁，优先用谁，没有就向上找。
2.口诀：编译看左，运行看右。

11.3成员变量与成员方法访问方式对比

1：成员变量：编译看左，运行看左。
2：成员方法：编译看左，运行看右。

11.4多态中父类引用是没办法调用子类特有的方法的

重要重要重要

Fu fu = new zi();
fu.ziOne();//ziOne()是子类特有的方法，fu是调用不到的。

11.5多态中（instanceof）关键字的使用

Animal animal = new Cat();
if（animal instanceof Dog）{//判断animal原来的类型是不是Dog
	Dog dog = animal;//如果是向下转型
}else if(animal instanceof Cat){
	Cat cat= animal;//如果是向下转型====  该代码执行  ======
}

12.计算机类小练习

//计算机类
package computer;
public class Computer {
    public void open(){
        System.out.println("打开电脑");
    }
    public void clos(){
        System.out.println("关闭电脑");
    }
    public void openUSB(Usb usb){
        if (usb instanceof Sb){
            Sb sb = (Sb) usb;
            sb.open();
            sb.dianji();
            sb.clos();
        }else if(usb instanceof Jp){
            Jp jp = (Jp) usb;
            jp.open();
            jp.type();
            jp.clos();
        }

    }
}

//键盘类
package computer;

public class Jp implements Usb{
    @Override
    public void open() {
        System.out.println("打开键盘！");
    }

    @Override
    public void clos() {
        System.out.println("关闭键盘！");
    }

    public void type (){
        System.out.println("敲键盘！");
    }
}

//鼠标类
package computer;

public class Sb implements Usb{
    @Override
    public void open() {
        System.out.println("打开鼠标！");
    }

    @Override
    public void clos() {
        System.out.println("关闭鼠标！");
    }
    public void dianji(){
        System.out.println("点击鼠标！");
    }
}

//usb接口
package computer;
public interface Usb {
    public void open();
    public void clos();
}

13.final修饰符

14.public、protected、(default)、private