Java学习5

（一）、API

帮助文档的使用流程：

java.lang包使用时不需要导包

（二）、字符串

字符串内容无法改变，它的对象在创建后就更改

创建string对象的两种方式
1.直接赋值：

String name="你";

2.new：

使用直接赋值方式创建的字符串存在StringTable中

==号比较原理：
基本数据类型比较的是数据值
引用数据类型比较的是地址值

字符串的比较：

忽略大小写只能是英文状态下的

（三）、字符串练习

键盘录入获得的字符串是new 出来的

练习1：

package tdxj2;

import java.util.Scanner;

public class st1 {
    
    public static void main(String[] args) {
    
        String rName="张三";
        String rPassword="123456";
        Scanner sc=new Scanner(System.in);

        for (int i=0;i<3;i++) {
    

            System.out.println("请输入用户名");
            String username=sc.next();
            System.out.println("请输入密码");
            String password=sc.next();

            if (username.equals(rName) && password.equals(rPassword)){
    
                System.out.println("登录成功");
                break;
            }else {
    
                if (i==2){
    
                    System.out.println("账号"+username+"被锁定，请联系xxx");
                }else{
    
                    System.out.println("用户名或密码错误，还剩"+(2-i)+"次机会");
                }
            }
        }
    }
}

练习2：遍历字符串

使用到的方法：

package tdxj2;

import java.util.Scanner;

public class st2 {
    
    public static void main(String[] args) {
    
        Scanner sc=new Scanner(System.in);
        System.out.println("输入一个字符串");
        String s1=sc.next();
        for (int i = 0; i < s1.length(); i++) {
    
            // i表示字符串的每一个索引
            char c=s1.charAt(i);
            System.out.println(c);
        }
    }
}

练习3：

package tdxj2;

import java.util.Scanner;

public class st3 {
    
    public static void main(String[] args) {
    
        Scanner sc=new Scanner(System.in);
        System.out.println("输入一个字符串");
        String s1=sc.next();

        int bcount=0;
        int scount=0;
        int ncount=0;
        for (int i = 0; i < s1.length(); i++) {
    
            char c=s1.charAt(i);
            if (c>='a' && c<='z'){
    
                scount++;
            } else if (c>='A'&& c<='Z') {
    
                bcount++;
            }else if(c>='0'&& c<='9'){
    
                ncount++;
            }
        }
        System.out.println("小写字母有"+scount+"个");
        System.out.println("大写字母有"+bcount+"个");
        System.out.println("数字有"+ncount+"个");
    }
}

练习4：拼接字符串

package tdxj2;

public class st4 {
    
    public static void main(String[] args) {
    
        int[] arr={
    1,2,3};
        String result=pjString(arr);
        System.out.println(result);
    }

    //遍历数组
    //需要数组
    //返回拼接的字符串
    public  static String pjString(int[] arr){
    
    if (arr==null){
    
        return "";
    }
    if (arr.length==0){
    
        return "[]";
    }


        String result="[";
        for (int i = 0; i < arr.length; i++) {
    
            if (i==arr.length-1){
    
                result=result +arr[i];
            }else {
    
                result=result +arr[i]+",";
            }
        }
        result =result+"]";
        return  result;

    }
}

练习5：字符串反转

package tdxj2;

public class st5 {
    
    public static void main(String[] args) {
    
        String result =changeString("abc");
        System.out.println(result);
    }

    //需要字符串
    //返回字符串
    public static  String changeString(String str){
    
        //倒过来遍历 forr
        String result="";
        for (int i = str.length()-1; i >= 0; i--) {
    
            char c=str.charAt(i);
            result+=c;
        }
        return  result;
    }
}

练习6：金额转换

package tdxj2;

import java.util.Scanner;

public class st6 {
    
    public static void main(String[] args) {
    
        Scanner sc=new Scanner(System.in);
        int money;
        while (true) {
    
            System.out.println("请输入一个金额");
             money=sc.nextInt();
            if (money>=0 && money<9999999){
    
                break;
            }else {
    
                System.out.println("金额无效");
            }
        }
        //用来表示钱的大写
        String moneyStr="";
        while (true){
    
            int ge=money%10;
           String capitalNumber= getCapital(ge);

           moneyStr=capitalNumber+moneyStr;
            money=money/10;

            if (money==0){
    
                break;
            }
        }

        //补0
        int count=7-moneyStr.length();
        for (int i = 0; i < count; i++) {
    
           moneyStr= "零"+moneyStr;
        }

        //插入单位
        String[] arr={
    "佰","拾","万","仟","佰","拾","元"};
        String result="";
        for (int i = 0; i < moneyStr.length(); i++) {
    
            char c=moneyStr.charAt(i);
            result=result +c+ arr[i];
        }
        System.out.println(result);
    }

    //把数字变成大写的中文
    public  static String getCapital(int number){
    
        String[] arr={
    "零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};

        return arr[number];
    }
}

ctrl +alt +t对选中的内容添加包裹

（四）、StringBuilder

StringBuilder 是一个容器，创建完过后里面的内容是可以改变的
作用：提高字符串的操作效率
使用场景：1.字符串的拼接 2.字符串的反转

构造方法：

常用的方法：

练习：

package tdxj2;

import java.util.Scanner;

public class st7 {
    
    public static void main(String[] args) {
    
        Scanner sc=new Scanner(System.in);
        System.out.println("输入一个字符串");
        String str=sc.next();

        //2.反转键盘输入的字符串
        String result=new StringBuilder().append(str).reverse().toString();
        if (str.equals(result)){
    
            System.out.println("当前字符串是对称字符串");
        }else{
    
            System.out.println("当前字符串不是对称字符串");
        }
    }
}

练习2：

打印对象不是地址值，而是属性值

链式编程：当我们调用一个方法时，不需要用变量接受结果，可以继续调用其他方法

（五）、Stringjoiner

jdk8才出现

构造方法：

常用方法：

add只能加字符串

（六）、static

静态变量：

静态方法：

工具类：


工具类练习：

代码：

package tdxj2;

import javafx.scene.chart.StackedAreaChart;

public class ArrayUtil {
    
    private ArrayUtil(){
    }

    public static String printArr(int[] arr){
    
        StringBuilder sb=new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
    
            if (i==arr.length-1){
    
                sb.append(arr[i]);
            }else {
    
                sb.append(arr[i]).append(",");
            }
        }
        sb.append("]");
        return  sb.toString();
    }

    public static double getAverage(double[] arr){
    
        double sum=0;
        for (int i = 0; i < arr.length; i++) {
    
            sum+=arr[i];
        }
        return sum/arr.length;
    }

}

static的注意事项：

（七）、重识main方法

（八）、继承的概述

好处：可以把子类中重复的代码抽取到父类当中，提高代码的复用性
子类可以在父类的基础上，增加其他的功能，使子类更加强大

什么时候使用：

（九）、继承的特点

Java只支持单继承，不支持多继承，但支持多层继承
单继承：一个子类只能继承一个父类
子类不能同时继承多个父类
每一个类都直接或间接继承object

写继承体系时可以先画图：

写代码时，从上往下写
private只能在本类访问，子类无法访问

（十）、子类能继承父类中的哪些内容

成员变量中，私有的子类可以继承但不能调用

成员方法中会将虚方法放进虚方法表中，进行继承
虚方法：非private，非static，非final

10.1 成员变量的访问特点

就近原则：谁离我近，我就用谁

使用变量时，会从局部开始寻找，然后本类，父类，逐级寻找。都没有则报错
这边name打印的是ziShow

super指的是父类：

10.2 成员方法的访问特点

this调用使用就近原则：谁离我近，我就用谁
super调用直接访问父类

方法的重写：当父类的方法不能满足子类现在的需求时，要进行方法的重写
书写格式：当子类中出现和父类中方法一模一样的方法声明，就称子类这个方法是重写的方法
（重写注解）@Override放在重写后的方法上面，校验子类重写时语法是否正确
重写本质：覆盖虚方法表里的方法

重写注意事项：

10.3 构造方法的访问特点

父类中的构造方法不会被子类继承
子类中所有的构造方法默认先访问父类中的无参构造，再执行自己

调用父类构造方法：子类构造方法的第一行语句默认是：super（），不写也存在，且必须在第一行
调用父类有参构造，必须手动写super调用

this就是一个变量，等于当前调用者的地址值
super：代表父类的存储空间

this（）表示调用本类其他构造，需要写在第一行

练习：

父类：

package days2;

public class Employee {
    
    private String id;
    private  String name;
    private double salary;

    public Employee(){
    

    }

    public Employee(String id, String name, double salary) {
    
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    public String getId() {
    
        return id;
    }

    public void setId(String id) {
    
        this.id = id;
    }

    public String getName() {
    
        return name;
    }

    public void setName(String name) {
    
        this.name = name;
    }

    public double getSalary() {
    
        return salary;
    }

    public void setSalary(double salary) {
    
        this.salary = salary;
    }

    //工作
    public void  work(){
    
        System.out.println("工作");
    }

    public void eat(){
    
        System.out.println("吃米饭");
    }
}

子类经理：

package days2;

public class Manager extends  Employee{
    
    private double bouns;

    public Manager(){
    }

    //带全部参数构造
    //父类+子类
    public Manager(String id, String name, double salary, double bouns) {
    
        super(id, name, salary);
        this.bouns = bouns;
    }

    public double getBouns() {
    
        return bouns;
    }

    public void setBouns(double bouns) {
    
        this.bouns = bouns;
    }

    @Override
    public void work(){
    
        System.out.println("经理工作");
    }
}

子类厨师：

package days2;

public class Cook extends Employee{
    
    public Cook() {
    
    }

    public Cook(String id, String name, double salary) {
    
        super(id, name, salary);
    }

    @Override
    public void work(){
    
        System.out.println("厨师炒菜");
    }
}

（十一）、多态

同类型的对象，表现出不同的形态

多态的表现形式：
父类类型 对象名称=子类对象；

多态的前提：

好处：父类型作为参数，可以接收所有子类对象

11.1 多态调用成员的特点

左边就是创建对象的左边
编译看左边，就是看父类中有没有这个变量或者方法，有就编译成功，没有则编译失败
运行看右边：运行的是子类中的方法

11.2 多态优势和弊端

优势：在多态形式下，右边对象可以实现解耦合，便于扩展和维护
弊端：不能调用子类的特有功能。解决办法：变回子类类型
变量名 instanceof 类名 判断这个变量是不是这个类型 是为true 不是为false

新特性，将判断和转换合在一起写
先判断a是否为dog类型，是就强转为dog类型变量名为d。不是就为false

（十二）、包和final

包：

使用其他类时，需要使用全类名

final：用来修饰

常量：

（十三）、权限修饰符和代码块

权限修饰符：用来控制一个成员能够被访问的范围的
可以修饰成员变量，方法，构造方法，内部类

四种修饰符：作用范围从小到大 private<空着不写/缺省/默认<protected<public

使用规则：

代码块：局部代码块，构造代码块，静态代码块
用{}

局部代码块：提前结束变量的生命周期

构造代码块：写在成员位置的代码块
优先于构造方法执行，可以将构造方法中重复的内容，写在构造代码块中

静态代码块：
格式：static{}
特点：需要通过static修饰，随着类的加载而加载，并且自动触发、只执行一次
使用场景：在类加载的时候，做一些数据初始化的时候使用

（十四）、抽象类和抽象对象

抽象方法定义格式：public abstract 返回值类型 方法名（参数列表）;
抽象类的定义格式：public abstract class 类名{}

注意事项：抽象类中的构造方法用来给创建子类对象时，给属性进行赋值

作用：

（十五）、接口

接口的定义和使用：

注：1.接口和类的实现关系，可以是单实现，也可以是多实现
public class 类名 implements 接口名1，接口名2{}
2.实现类可以在继承一个类的同时实现多个接口。
public class 类名 extends 父类 implements 接口名1，接口名2{}

15.1 接口中成员的特点

15.2 接口和类的关系

实现多个接口时，需要重写所有抽象方法

如果接口中的成员方法重名，只用重写一个就行

如果实现类（子类）接上了最下面的子接口，那么就需要重写体系中所有抽象方法

15.3 接口的新特性

jdk8以后新增的默认方法：

静态方法：

jdk9新增的私有方法：一般用于抽取重复到代码到私有方法中
第一种是普通的私有方法，给默认方法服务的
第二种是静态的私有方法，给静态方法服务的

接口的应用：

适配器设计模式：