Java学习记录二（集合基础、继承、修饰符、多态、抽象类、接口、形参和返回值、内部类和API）

已于 2022-03-18 15:24:55 修改
阅读量1.4k 收藏
点赞数 4
分类专栏： Java语言 文章标签： java 学习笔记总结
于 2021-05-21 19:27:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53749266/article/details/117133634
版权

Java

Java学习总结笔记（Java学习总结笔记二（集合基础、继承、修饰符、多态、抽象类、接口、形参和返回值、内部类和API）

12.集合基础

集合概述：

集合类的特点:提供一种存储空间可变的存储模型，存诸的数据容量可以发生改变

集合类有很多，目前我们先学习一个: ArrayList
ArrayList :
可调整大小的数组实现
:是一种特殊的数据类型，泛型。
怎么用呢?
在出现E的地方我们使用引用数据类型替换即可

​ 举例:ArrayList,ArrayList

12.1 ArrayList构造方法和添加方法

模块包类

方法名说明
public ArrayList()创建一个空的集合对象
public boolean add(E e)将指定的元素追加到此集合的末尾
public void add(int index,E element)在此集合中的指定位置插入指定的元素
public class ArrayListDemo01 {
    public static void main(String[] args) {
        // public ArrayList ( ):创建一个空的集合对象
        //ArrayList<String> array = new ArrayList<>( );
        ArrayList<String> array = new ArrayList<String>();
        //public boolean add(E e):将指定的元素追加到此集合的末尾
        //System.out.printLn( array. add( "hello" ) );
        array.add( "he11o");
        array.add( "wor1d");
        array.add( "java");
        //public void add(int index,E eLement):在此集合中的指定位置插入指定的元素
        array.add( index: 1,element: "iavase");
        // IndexOutOfBoundsException
        array. add( 4, "javaee" );
        //输出集合
        System.out.println( "array : " + array ) ;
    }
}

需要注意的是：

1.array.add( “he11o”);返回的是布尔类型，因此不能套娃

2.若是index使用时不能越界

// IndexOutOfBoundsException array. add( 4, "javaee" );

12.2ArrayList集合常用方法

方法名说明
public boolean remove(Object o)删除指定的元素，返回删除是否成功
public E remove(int index)删除指定索引处的元素，返回被删除的元素
public E set(int index,E element)修改指定索引处的元素，返回被修改的元素
public E get(int index)返回指定索引处的元素
public int size(）返回集合中的元素的个数

public E set(int index,E element)

修改指定索引处的元素，返回被修改的元素

System.out.println( array .set( 1, "javaee"));

ArrayList<String> array = new ArrayList<String>();
//往集合中添加字符串对象
array.add("周润发");
array.add("彭于晏");
array.add("吴彦祖");
for(int i=0; i<array .size(); i++) {
    String s = array.get(i);
    System.out.println(s);
}

案例：学生管理小系统

/加了括号才是方法/

学生管理系统实现思路：

①定义学生类
②主界面的代码编写

③添加学生的代码编写

④查看学生的代码编写

⑤删除学生的代码编写

⑥修改学生的代码编写

1.定义学生类

学生类:
Student
成员变量:
学号: sid

​ 姓名: name

​ 年龄: age
​ 居住地: address
构造方法:
​ 无参构造
​ 带四个参数的构造
成员方法:
​ 每个成员变量对应给出get/set方法

2.主界面的代码编写

思路
1用输出语句完成主界面的编写
2用Scanner实现键盘录入数据

​ 3用switch语句完成操作的选择

​ 4用循环完成再次回到主界面

3.添加学生的代码编写

思路
1用键盘录入选择添加学生

​ 2定义一个方法，用于添加学生
​ 1）显示提示信息，提示要输入何种信息
​ 2）键盘录入学生对象所需要的数据
​ 3）创建学生对象，把键盘录入的数据赋值给学生对象的成员变量

​ 4）将学生对象添加到集合中（保存)

​ 5）给出添加成功提示

​ 3调用方法

4.查看学生的代码编写（加了判断）

思路
1用键盘录入选择查看所有学生信息

​ 2定义一个方法，用于查看学生信息
​ 1判定集合中是否有数据，如果没有显示提示信息
​ 2显示表头信息
​ 3将集合中数据取出按照对应格式显示学生信息，年龄显示补充“岁”
​ 3调用方法

5.删除学生的代码编写

思路
1用键盘录入选择删除学生信息

​ 2定义一个方法，用于删除学生信息
​ 1显示提示信息
​ 2键盘录入要删除的学生学号
​ 3遍历集合将对应学生对象从集合中删除

​ 4给出删除成功提示

​ 3调用方法

代码：
package com.stu;
/*
    学生类
    Alt + Insert 根据自己的需要进行选择
 */
public class Student {
    //学号
    private String sid;
    //姓名
    private String name;
    //年龄
    private String age;
    //居住地
    private String address;
    public Student(){

    }

    public Student(String sid,String name,String age,String address){
            this.sid=sid;
            this.name=name;
            this.age=age;
            this.address=address;
    }

    public String getSid() {
        return sid;
    }

    public String getName() {
        return name;
    }

    public String getAge() {
        return age;
    }

    public String getAddress() {
        return address;
    }

    public void setSid(String sid) {
        this.sid = sid;
    }

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

    public void setAge(String age) {
        this.age = age;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

package com.stu;


import java.sql.SQLOutput;
import java.util.ArrayList;
import java.util.Scanner;

public class studentManager {
    public static void main(String[] args){
        //创建集合对象，用于存储学生数据
        ArrayList<Student> array = new ArrayList<Student>();

        //用循环完成再次回到主界面
        while(true) {
            //用输出语句完成主界面的编写
            System.out.println("----------欢迎来到学生管理系统----------");
            System.out.println("1 添加学生");
            System.out.println("2 删除学生");
            System.out.println("3 修改学生");
            System.out.println("4 查看所有学生");
            System.out.println("5 退出");
            System.out.println("请输入你的选择");

            //用Scanner实现键盘录入数据
            Scanner sc = new Scanner(System.in);
            String line = sc.nextLine();

            switch (line) {
                case "1":
                    //System.out.println("添加学生");
                    addStudent(array);
                    break;
                case "2":
                    //System.out.println("删除学生");
                    deleteStudent(array);
                    break;
                case "3":
                    System.out.println("修改学生");
                    updateStudent(array);
                    break;
                case "4":
                    //System.out.println("查看所有学生");
                    findAllStudent(array);
                    break;
                case "5":
                    System.out.println("谢谢使用");
                    System.exit(0); //JVM退出
            }
        }
    }

    //定义一个方法，用于添加学生信息
    public static void addStudent (ArrayList<Student> array){
        //键盘录入学生对象所需要的数据，显示提示信息，提示要输入何种信息
        Scanner sc = new Scanner(System.in);

        //为了让sid在while循环外面被访问到，我们就把它定义在了循环外
        String sid;
        //为了能回到这里，我们用循环实现
        while(true) {
            System.out.println("请输入学生学号：");
            sid = sc.nextLine();

            boolean flag = isUsed(array, sid);
            if (flag) {
                System.out.println("你输入的学号已经被使用，请重新输入");
            } else {
                break;
            }
        }
        System.out.println("请输入学生姓名：");
        String name = sc.nextLine();
        System.out.println("请输入学生年龄：");
        String age = sc.nextLine();
        System.out.println("请输入学生居住地：");
        String address = sc.nextLine();

        //创建学生对象，把录入的数据赋值给学生对象的成员变量
        Student s = new Student();
        s.setSid(sid);
        s.setName(name);
        s.setAge(age);
        s.setAddress(address);

        //将学生对象添加到集合中
        array.add(s);

        //给出添加成功提示
        System.out.println("添加学生成功");
    }

    //定义一个方法，用于查看学号是否被使用
    public static  boolean isUsed(ArrayList<Student> array,String sid){
        //如果集合中的某一个学生学号相同，返回true;如果都不相同，返回false
        boolean flag = false;
        for(int i = 0;i< array.size();i++){
            Student s = array.get(i);
            if(s.getSid().equals(sid)){
                flag = true;
                break;
            }
        }
        return flag;
    }
    //定义一个方法，用于查看学生信息
    public static void findAllStudent (ArrayList<Student> array){
        //显示表头信息
        if(array.size()==0){
            System.out.println("无信息，请先添加信息再查询");
            //为了让程序不再往下执行给出return;
            return;
        }
        System.out.println("学号\t\t\t姓名\t\t年龄\t\t居住地");
        //将集合中数据取出按照对应格式显示学生信息，年龄显示补充”岁“
        for(int i=0;i< array.size();i++){
            Student s = array.get(i);
            System.out.println(s.getSid()+"\t\t\t"+s.getName()+"\t\t"+s.getAge()+"岁\t"+s.getAddress());
        }
    }

    //定义一个方法，用于删除学生信息
    public static void deleteStudent(ArrayList<Student> array) {
        //键盘录入要删除的学生学号，显示提示信息
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入你要删除的学生的学号");
        String sid = sc.nextLine();

        //在删除/修改学生操作前，对学号是否存在进行判断如果不存在，显示提示信息如果存在，执行删除/修改操作
        int index = -1;
        //遍历集合将对应学生对象从集合中删除
        for (int i = 0; i < array.size(); i++) {
            Student s = array.get(i);
            if (s.getSid().equals(sid)) {
                //array.remove(i);
                //System.out.println("删除学生成功");
                index = i;
                break;
            }
        }
        if(index == -1){
            System.out.println("该信息不存在，请重新输入");
        }else{
            array.remove(index);
            //给出删除成功提示
            System.out.println("删除学生成功");
        }
    }

    public static void updateStudent (ArrayList<Student> array) {
        //键盘录入要修改的学生学号，显示提示信息
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入你要修改的学生的学号");
        String sid = sc.nextLine();

        //键盘录入要修改的学生信息
        System.out.println("请输入学生新姓名");
        String name = sc.nextLine();
        System.out.println("请输入学生新年龄");
        String age = sc.nextLine();
        System.out.println("请输入学生新居住地");
        String address = sc.nextLine();

        //创建学生对象
        Student s = new Student();
        s.setAddress(address);
        s.setName(name);
        s.setSid(sid);
        s.setSid(sid);

        //遍历集合修改对应的学生信息
        for (int i = 0; i < array.size(); i++) {
            Student student = array.get(i);
            if (student.getSid().equals(sid)) {
                 array.set(i, s);
                 break;
            }
        }
        //给出修改成功提示
        System.out.println("修改学生成功");
    }
}

13.继承

概述：

继承是面向对象三大特征之一。可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法

继承的格式：
格式: public class子类名extends父类名{}范例: public class Zi extends Fu { }
Fu:是父类，也被称为基类、超类Zi:是子类，也被称为派生类

继承中子类的特点:
子类可以有父类的内容
子类还可以有自己特有的内容

13.1继承的好处和弊端

继承好处
提高了代码的复用性(多个类相同的成员可以放到同一个类中)提高了代码的维护性(如果方法的代码需要修改，修改一处即可)
继承弊端
继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性
什么时候使用继承?
继承体现的关系: is a
假设法:我有两个类A和B，如果他们满足A是B的一种，或者B是A的一种，就说明他们存在继承关系，这个时候就可以考虑使用继承来体现，否则就不能滥用继承
举例:苹果和水果，猫和动物，猫和狗

13.2继承中变量的访问特点

在子类方法中访问一个变量
1子类局部范围找
2子类成员范围找

3父类成员范围找
4如果都没有就报错(不考虑父亲的父亲…)

13.2.1super

this关键字指向调用该方法的对象—般我们是在当前类中使用this关键字，所以我们常说this代表本类对象的引用

super关键字的用法和this关键字的用法相似

this:代表本类对象的引用
super:代表父类存储空间的标识(可以理解为父类对象引用)

关键字访问成员变量访问构造方法访问成员方法
thisthis.成员变量
访问本类成员变量		this(…)
访问本类构造方法		this.成员方法(…)
访问本类成员方法
supersuper.成员变量
访问父类成员变量		super(…)
访问父类构造方法		super.成员方法(…)
访问父类成员方法
13.2.2 继承中构造方法的访问特点

子类中所有的构造方法默认都会访问父类中无参的构造方法为什么呢?
因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化

每一个子类构造方法的第一条语句默认都是: super()

public class zi extends Fu {
    public Zi() {
        super();
        System.out.println("zi中无参构造方法被调用");
    }
    public Zi(int age){
            super();
            System. out.println("zi中带参构造方法被调用");
	}
}

如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢?
通过使用super关键字去显示的调用父类的带参构造方法

在父类中自己提供一个无参构造方法
推荐:自己给出无参构造方法

public class zi extends Fu {
    public Zi() {
        //super();
        super(20);
        System.out.println("zi中无参构造方法被调用");
    }
    public Zi(int age){
            //super();
            super(20);
        	System. out.println("zi中带参构造方法被调用");
	}
}
13.2.3继承中成员方法的访问特点

通过子类对象访问一个方法
1子类成员范围找
2父类成员范围找
3如果都没有就报错(不考虑父亲的父亲…)

public class Demo {
    public static void main (string [] args) {
        Zi z =new Zi();
        z.show ();
        z.method ();
    }
}

输出:Fu类无参构造方法被调用

输出:zi类无参构造方法被调用

输出:30
输出:20
输出:40
输出:Fu类method方法被调用输出:30

在这里插入图片描述

需要注意的是：构造方法被调用后才会进行初始化，随即访问到父类的成员变量40，而Zi类对象创建时就直接在堆内存生成地址并且初始化自身的类属性值20

13.3方法重写

方法重写概述
子类中出现了和父类中一模一样的方法声明

方法重写的应用
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容
练习:手机类和新手机类

@Override
是一个注解(注解后面会学习到)
可以帮助我们检查重写方法的方法声明的正确性

需要注意的是：

私有方法不能被重写(父类私有成员子类是不能继承的)

子类方法访问权限不能更低(public>默认>私有)(父类使用public 子类可用默认和私有)

13.4Java中继承的注意事项

Java中类只支持单继承，不支持多继承

Java中类支持多层继承

案例 ： 老师和学生

需求:定义老师类和学生类，然后写代码测试;最后找到老师类和学生类当中的共性内容,抽取出一个父类，
用继承的方式改写代码，并进行测试
思路:
1定义老师类(姓名，年龄，教书()

2定义学生类(姓名，年龄，学习())

3定义测试类，写代码测试

4共性抽取父类，定义人类(姓名，年龄)
5定义老师类，继承人类，并给出自己特有方法:教书()

6定义学生类，继承人类，并给出自己特有方法:学习()

7定义测试类，写代码测试

package teacherAndStu;

public class Person {
    private String name;
    private int age;

    public Person(){
    }

    public Person (String name,int age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}


package teacherAndStu;

public class PersonDemo {
    public static void main(String[] args) {
        //创建老师类对象测试
        Teacher t1 = new Teacher();
        t1.setName("周润发");
        t1.setAge((20));
        System.out.println(t1.getName()+","+t1.getAge());
        t1.teach();

        Teacher t2 = new Teacher("彭于晏",20);
        System.out.println(t2.getName()+","+t2.getAge());
        t2.teach();
    }
}


package teacherAndStu;

public class Student {
    private String name;
    private int age;

    public Student (String name,int age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void teach(){
        System.out.println("我爱学习");
    }
}


package teacherAndStu;

public class Teacher extends Person{
    public Teacher(String name,int age){
        super(name,age);
        //通过父类的带参构造赋值
    }
    public Teacher(){}
    //老师类特有方法
    public void teach(){
        System.out.println("我爱学习");
    }
}

案例 ： 猫和狗

需求:请采用继承的思想实现猫和狗的案例，并在测试类中进行测试
分析:
①猫:
成员变量:姓名，年龄

构造方法:无参，带参
成员方法: get/set方法，抓老鼠（)

②狗:
成员变量:姓名，年龄

构造方法:无参，带参
成员方法: get/set方法，看门()

③共性:
成员变量:姓名，年龄;

构造方法:无参，带参;

成员方法: get/set方法()

思路：

定义动物类(Animal)
成员变量:姓名，年龄

构造方法:无参，带参

成员方法: get/set方法

定义猫类(Cat)，继承动物类
构造方法:无参，带参

成员方法:抓老鼠)

定义狗类(Dog)，继承动物类
构造方法:无参，带参成员方法:看门0
④定义测试类(AnimalDemo)，写代码测试

package CatAndDog;

public class AnimalDemo {
    public static void main(String[] args){
        //创建猫类对象并进行测试
        Cat c1 = new Cat();
        c1.setAge(5);
        c1.setName("加菲猫");
        System.out.println(c1.getName()+","+ c1.getAge());
        c1.catchMouse();

        Cat c2 = new Cat("加菲猫",5);
        System.out.println(c2.getName()+","+ c2.getAge());
        c2.catchMouse();

        Dog d1 = new Dog("乌云盖雪",3);
        System.out.println(d1.getName()+","+ d1.getAge());
        d1.lookDoor();
    }
}


package CatAndDog;

public class AnimalDemo {
    public static void main(String[] args){
        //创建猫类对象并进行测试
        Cat c1 = new Cat();
        c1.setAge(5);
        c1.setName("加菲猫");
        System.out.println(c1.getName()+","+ c1.getAge());
        c1.catchMouse();

        Cat c2 = new Cat("加菲猫",5);
        System.out.println(c2.getName()+","+ c2.getAge());
        c2.catchMouse();

        Dog d1 = new Dog("乌云盖雪",3);
        System.out.println(d1.getName()+","+ d1.getAge());
        d1.lookDoor();
    }
}


package CatAndDog;

public class Cat extends Animal{
    public Cat(){

    }

    public Cat(String name,int age){
        super(name,age);
    }
    public void catchMouse(){
        System.out.println("猫抓老鼠");

    }
}


package CatAndDog;

public class Dog extends Animal{
    public Dog(){}
    public Dog(String name,int age){
        super(name,age);
    }

    public void lookDoor(){
        System.out.println("狗看门");
    }
}

14.修饰符

14.1包

包的概述和使用：

其实就是文件夹
作用:对类进行分类管理

包的定义格式
格式: package包名;(多级包用.分开)

范例: package com.lxh;

带包的Java类编译和执行

手动建包:
按照以前的格式编译java文件 javac HelloWorld.java
手动创建包 在E盘建立文件夹com,然后在com下建立文件夹lxh
把class文件放到包的最里面 把HelloWorld.class文件放到com下的lxh这个文件夹下

​ 带包执行 java com.lxh.HelloWorld
自动建包: javac -d . HelloWorld.java java com.lxh.HelloWorld

14.2导包的概述和使用

使用不同包下的类时，使用的时候要写类的全路径，写起来太麻烦了

为了简化带包的操作，Java就提供了导包的功能

导包的格式
格式: import包名;
范例: importcn.itcast.Teacher
在这里插入图片描述

14.3修饰符

修饰符的分类：
权限修饰符
状态修饰符

修饰符同一个类中同一个包中子类无关类不同包的子类不同包的无关类
private√
默认√√
protected√√√
public√√√√
14.3.1状态修饰符

final(最终态)
static(静态)

14.3.1.1final

final关键字是最终的意思，可以修饰成员方法，成员变量，类
final修饰的特点
修饰方法:表明该方法是最终方法，不能被重写

​ 修饰变量:表明该变量是常量，不能再次被赋值

​ 修饰类:表明该类是最终类，不能被继承

final修饰局部变量：

变量是基本类型: final修饰指的是基本类型的数据值不能发生改变
变量是引用类型: final修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的

14.3.1.2static

static关键字是静态的意思，可以修饰成员方法，成员变量
static修饰的特点
被类的所有对象共享
这也是我们判断是否使用静态关键字的条件

​ 可以通过类名调用
​ 当然，也可以通过对象名调用

​ 推荐使用类名调用

public class Student {
	public String name; //姓名
    public int age; //年龄
	//public String university; //学校
	public static String university; //学校
	public void show() {
		system.out.println(name + "," + age + "," + university);
	}
}

public class StaticDemo {
	public static void main( String[] args) {
        Student.university ="清华大学";
        
        Student s1 =.new Student();
        s1.name ="彭于晏";
        s1.age = 30;
        //si.university =“清华大学";
        s1.show();
        
        Student s2 = new Student();
        s2.name = "周润发";
        s2.age = 33;
        //s2.university ="清华大学";
        s2.show( );
	}
}

static访问特点：

非静态的成员方法
能访问静态的成员变量

​ 能访问非静态的成员变量

​ 能访问静态的成员方法

​ 能访问非静态的成员方法

静态的成员方法
能访问静态的成员变量

​ 能访问静态的成员方法

总结成一句话就是:静态成员方法只能访问静态成员

15.多态

多态概述：

同一个对象，在不同时刻表现出来的不同形态

同一个对象，在不同时刻表现出来的不同形态
举例:猫
我们可以说猫是猫:猫cat = new猫();
我们也可以说猫是动物:动物animal = new猫();这里猫在不同的时刻表现出来了不同的形态，这就是多态

多态的前提和体现
有继承/实现关系

有方法重写
有父类引用指向子类对象

public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();
    }
}

现在父类就可以用子类的东西了，以前继承只能子用父。不公平，所以多态出现了

15.1多态中成员的访问特点

成员变量:编译看左边，执行看左边成员方法:

编译看左边，执行看右边

Animal a = new Cat();

猫的age=20;动物的age=40；

输出结果为40

为什么成员变量和成员方法的访问不一样呢?
因为成员方法有重写，而成员变量没有

15.2多态的好处和弊端

多态的好处:提高了程序的扩展性

​ 具体体现:定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作

多态的弊端:不能使用子类的特有功能

​ //例如：狗看门

15.3多态中的转型

向上转型
从子到父
父类引用指向子类对象

向下转型
从父到子
父类引用转为子类对象

public class AnimalDemo {
    public static void main( tring[] args) {
        //多态
        Animal a = new Cat();//向上转型
        a.eat();
        //a.playGame( );
        
        /*
        //创建Cat类的对象Cat c = new Cat( );
        c.eat();
        c.pLayGame( );
        */
        
        //向下转型
        Cat c = (Cat)a;
        c.eat();
        c.playGame();
    }
}

15.4多态转型内存图解

public class AnimalDemo {
    public static void main(String[] args) {

        Animal a = new Cat();//向上转型
        a.eat();
        
        //向下转型
        Cat c = (Cat)a;
        c.eat();
        c.playGame();
        //向上转型
        a = new Dog();
        a.eat();
        
        //向下转型
        //ClassCastException 类型转换异常
        Cat cc = (Cat) a;
        cc.eat();
        cc.playGame();
    }
}

堆内存：

new Cat（）001

new Dog（）002

起初ac都在001中进行

输出:猫吃鱼

输出:猫吃鱼

输出:猫捉迷藏

a = new Dog();后

a在栈内存中变为002

这时再执行Cat cc = (Cat) a;会出现ClassCastException 类型转换异常

因为虽然Cat和Dog都继承自Animal但他们之间不等价，所以相互之间不能转换。

案例：猫和狗（多态版）

需求:请采用多态的思想实现猫和狗的案例，并在测试类中进行测试

思路:
定义动物类(Animal)
成员变量:姓名，年龄

​ 构造方法:无参，带参
​ 成员方法: get/set方法，吃饭（）

定义猫类(Cat)，继承动物类
构造方法:无参，带参

​ 成员方法:重写吃饭()

③定义狗类(Dog)，继承动物类
构造方法:无参，带参

​ 成员方法:重写吃饭()

package CatAndDog002;

import java.sql.SQLOutput;

public class Animal {
    private String name;
    private int age;

    public Animal(){}

    public Animal(String name,int age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void eat() {
        //System.out.println("动物吃东西");
    }
}


package CatAndDog002;

public class AnimalDemo {
    public static void main (String[] args){
        //创建猫类对象进行测试
        Animal a = new Cat();
        a.setName("加菲猫");
        a.setAge(5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();

        a = new Cat("加菲",5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
    }
}


package CatAndDog002;

public class Cat extends Animal{
    public Cat(){}
    public Cat(String name,int age){
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}


package CatAndDog002;

public class Dog extends Animal{
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

编程看左边，所以在Animal中如果不写eat方法会报错提示找不到符号。

16.抽象类

抽象类概述：

动物本身并不是一个具体的事物，而是抽象的。只有猫和狗本身才是具体的。不知道动物吃的是说明东西,因此在在Animal中不应该给出具体的方法实现。

在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类

一个方法要么给出具体的方法体，要么给出抽象的。

16.1抽象类的特点

抽象类和抽象方法必须使用abstract关键字修饰
public abstractclass类名{}
public abstract void eat();
抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

抽象类不能实例化
抽象类如何实例化呢?参照多态的方式，通过子类对象实例化，这叫抽象类多态

抽象类的子类
要么重写抽象类中的所有抽象方法

​ 要么是抽象类

16.1.1抽象类的成员特点

成员变量
可以是变量

​ 也可以是常量

构造方法
有构造方法，但是不能实例化
那么，构造方法的作用是什么呢?

​ 用于子类访问父类数据的初始化

成员方法
可以有抽象方法:限定子类必须完成某些动作

​ 也可以有非抽象方法:提高代码复用性

案例：猫和狗（抽象类版）

需求:请采用抽象类的思想实现猫和狗的案例，并在测试类中进行测试
思路:
①定义动物类(Animal)
成员变量:姓名，年龄

​ 构造方法:无参，带参
​ 成员方法: get/set方法，吃饭();

②定义猫类(Cat)，继承动物类
构造方法:无参，带参

​ 成员方法:重写吃饭(){…}

③定义狗类(Dog)，继承动物类
构造方法:无参，带参

​ 成员方法:重写吃饭0{…}
④定义测试类(AnimalDemo)，写代码测试

package CatAndDog003;

public abstract class Animal {
    private  String name;
    private  int age;

    public Animal(){
    }

    public Animal(String name,int age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public abstract void eat();
}


package CatAndDog003;

public class AnimalDemo {
    public static void main(String[] args) {
        //创建对象，按照多态的方式
        Animal a = new Cat();
        a.setName("加菲");
        a.setAge(5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        System.out.println("---------");

        a = new Cat("加菲",5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
    }
}


package CatAndDog003;

public class Cat extends Animal{

    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

package CatAndDog003;

public class Dog extends Animal{
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

17.接口

接口概述：

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用

Java中的接口更多的体现在对行为的抽象

17.1接口特点

接口用关键字interface修饰
public interface接口名{}

类实现接口用implements表示
public class类名implements接口名{}

接口不能实例化
接口如何实例化呢?参照多态的方式，通过实现类对象实例化，这叫接口多态。

​ 多态的形式:具体类多态，抽象类多态，接口多态。
​ 多态的前提:有继承或者实现关系;有方法重写;有父(类/接口)引用指向(子/实现)类对象

接口的实现类
要么重写接口中的所有抽象方法

​ 要么是抽象类

17.1.1接口的成员特点

所有类都直接或间接继承Object。如果一个类没有父类，它的父类就是Object，如果一个类有父类，它就间接继承Object。

成员变量
只能是常量
默认修饰符: public static final

构造方法
接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在

​ 一个类如果没有父类，默认继承自Object类
成员方法
​ 只能是抽象方法
​ 默认修饰符:public abstract

​ 关于接口中的方法，JDK8和JDK9中有一些新特性，后面再讲解

案例：猫和狗（接口板）

需求:对猫和狗进行训练，他们就可以跳高了，这里加入了跳高功能。请采用抽象类和接口来实现猫狗案例，
并在测试类中进行测试
思路:
定义接口(Jumpping)
成员方法:跳高(;

​ ②定义抽象动物类(Animal)
​ 成员变量:姓名，年龄;

​ 构造方法:无参，带参;

​ 成员方法: get/set方法，吃饭0;

​ ③定义具体猫类(Cat)，继承动物类，实现跳高接口
​ 构造方法:无参，带参;

​ 成员方法:重写吃饭({.….}，重写跳高方法(){….}

​ ④定义狗类(Dog)，继承动物类，实现跳高接口
​ 构造方法:无参，带参;

​ 成员方法:重写吃饭(){…}，重写跳高方法({.…}

package CatAndDoginterface;

public abstract class Animal {
    private String name;
    private int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Animal(){
    }

    public abstract void eat();
}

package CatAndDoginterface;

public class AnimalDemo {
    public static void main(String[] args){
        //创建对象，调用方法
        Jumpping j = new Cat();
        j.jump();
        System.out.println("--------");
        //接口只能调接口里边的方法

        Animal a = new Cat() ;
        a.setName("加菲");
        a.setAge(5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        ((Cat) a).jump();//Animal里没有jump方法
        //抽象类只能调抽象类里边的方法

        a = new Cat("加菲",5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        System.out.println("--------");

        Cat c = new Cat();
        c.setName("加菲");
        c.setAge(5);
        System.out.println(c.getName()+","+c.getAge());
        c.eat();
        c.jump();
    }
}

package CatAndDoginterface;

public  class Cat extends Animal implements Jumpping{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    public Cat() {
    }
}

package CatAndDoginterface;

public interface Jumpping {
    public abstract void jump();
}

17.2类和接口的关系

类和类的关系
继承关系，只能单继承，但是可以多层继承

类和接口的关系
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

例如：

public class InterImpl extends Object implements Inter1,Inter2,Inter3 {
}

接口和接口的关系：

继承关系，可以单继承，也可以多继承

public interface Inter3 extends Inter1,Inter2{
    
}

17.3抽象类和接口的的区别

-成员区别
抽象类
变量,常量;有构造方法;有抽象方法,也有非抽象方法
接口
常量;抽象方法
-关系区别
类与类
继承，单继承
类与接口
实现，可以单实现，也可以多实现
接口与接口
继承，单继承，多继承

-设计理念区别
抽象类
对类抽象，包括属性、行为
接口
对行为抽象，主要是行为

门和警报的例子

//抽象类
public abstract class Door {
	public abstract void open ();
    public abstract void close () ;
    //public abstract void alarm();//可是有的门不具备报警功能
}


//接口
public interface Door{
    void open();
    void close();
    void alarm();
}

public interface Alram {
	void alarm ( );
}
public abstract class Door {
	public abstract void open ( ) ;
    public abstract void close ( ) ;
}
public class AlarmDoor extends Door implements Alarm {
	public void oepn () {
        // ....
	}
    public void close () {
        // ....
    }
    public void alarm () {
        // ....
}

在这里，我们再次强调抽象类是对事物的抽象，而接口是对行为的抽象

案例：运动员和教练

在这里插入图片描述

思路：

1定义说英语接口
成员方法:说英语();
2定义抽象人类
成员变量:姓名，年龄;构造方法:无参，带参;成员方法: get/set方法，吃饭();
3定义抽象教练类，继承人类
构造方法:无参，带参;成员方法:教);
4定义抽象运动员类，继承人类
构造方法:无参，带参;成员方法:学习);
5定义具体篮球教练类，继承教练类
构造方法:无参，带参;成员方法:重写吃饭({.…}，重写教({.…}
6定义具体乒乓球教练类，继承教练类，实现说英语接口
构造方法:无参，带参;成员方法:重写吃饭().….}，重写教({.…}，重写说英语({.…}
7定义具体篮球运动员类，继承运动员类构造方法:无参，带参;成员方法:重写吃饭()…)，重写学习()…}

8定义具体乒乓球运动员类，继承运动员类，实现说英语接口
构造方法:无参带参;成员方法:重写吃饭(){.…}，重写学习(){.…}，重写说英语().…}

9定义测试类，写代码测试。

package CoachAndPlayer;

public class BaskerballCoach extends Coach{
    public BaskerballCoach() {
    }

    public BaskerballCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("利拉德教我运球");
    }

    @Override
    public void eat() {
        System.out.println("库里吃羊肉喝羊奶");
    }
}

package CoachAndPlayer;

public class BasketballPlayer extends Player{
    @Override
    public void study() {
        System.out.println("篮球运动员学习如何运球和投篮");
    }

    public BasketballPlayer() {
    }

    public BasketballPlayer(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("篮球运动员吃肉喝奶");
    }
}


package CoachAndPlayer;

public abstract class Coach extends Person{
    public Coach() {
    }

    public Coach(String name, int age) {
        super(name, age);
    }

    public abstract void teach();
}


package CoachAndPlayer;

public abstract class Person {
    private String name;
    private int age;

    public Person(){};
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public abstract void eat();
}


package CoachAndPlayer;

public class PersonDemo {
    public static void main(String[] args) {
        //创建对象
        PingPangPlayer aaa = new PingPangPlayer();
        aaa.setName("张继科");
        aaa.setAge(5);
        System.out.println(aaa.getName() + aaa.getAge());
        aaa.eat();
        aaa.speak();
        aaa.study();

        BasketballPlayer bbb = new BasketballPlayer();
        bbb.setName("姚明");
        bbb.setAge(6);
        System.out.println(bbb.getName() + bbb.getAge());
        bbb.eat();
        bbb.study();
    }
}


package CoachAndPlayer;

public abstract class PingPangCoach extends Coach implements SpeakingEnglish{
    public PingPangCoach() {
    }

    public PingPangCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("马龙教我打乒乓球");
    }

    @Override
    public void eat() {
        System.out.println("张继科吃肉");
    }
}


package CoachAndPlayer;

public class PingPangPlayer extends Player implements SpeakingEnglish{
    public PingPangPlayer() {

    }

    public PingPangPlayer(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("乒乓球运动员吃饭");
    }

    @Override
    public void speak() {
        System.out.println("乒乓球运动员说英语");
    }

    @Override
    public void study() {
        System.out.println("乒乓球运动员学发球和接球");
    }
}


package CoachAndPlayer;

public abstract class Player extends Person{
    public Player() {
    }

    public Player(String name, int age) {
        super(name, age);
    }
    public abstract void study();
}


package CoachAndPlayer;

public interface SpeakingEnglish {
    public abstract void speak();
}

18.形参和返回值

18.1类名作为形参和返回值

方法的形参是类名，其实需要的是该类的对象

方法的返回值是类名，其实返回的是该类的对象

public class Cat {
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class CatOperator {
    public void useCat(cat c) {	//Cat c = new Cat( );
    	c.eat();
    }
    
    public Cat getCat() {
        Cat c = new Cat; 
        return c;//方法的返回值是类名，其实返回的是该类的对象
    }
}

public class CatDemo {
    public static void main(String[] args) i
        //创建操作类对象,并调用方法
        CatOperator co = new CatOperator();
    	Cat c = new Cat();
        co.useCat(c);//方法的形参是类名，其实需要的是该类的对象
        
    	Cat c2 = co.getCat();  //new Cat()
            //方法的返回值是类名，其实返回的是该类的对象
        c2.eat();
    }
}

18.2抽象类名作为形参和返回值

方法的形参是抽象类名，其实需要的是该抽象类的子类对象

方法的返回值是抽象类名，其实返回的是该抽象类的子类对象

package abstractfanhuizhi;


public abstract class Animal {
    public abstract void eat();
}
package abstractfanhuizhi;

public class AnimalDemo {
    public static void main(String[] args) {
        //创建操作类对象，并调用方法
        AnimalOperator ao = new AnimalOperator();
        Animal a = new Cat();
        ao.useAnimal(a);

        Animal a2 = ao.getAnimal();
        a2.eat();
    }
}
package abstractfanhuizhi;

public class AnimalOperator {
    public void useAnimal(Animal a){//Animal a = new Cat();
        a.eat();
    }
    public Animal getAnimal(){
        Animal a = new Cat();
        return  a;
    }
}
package abstractfanhuizhi;

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

}

18.3接口值作为形参和返回值

方法的形参是接口名，其实需要的是该接口的实现类对象

方法的返回值是接口名，其实返回的是该接口的实现类对象

package Interasreturn;

public class Cat implements Jumpping{//接口不能实例化，所以需要多态实现类对象

    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}
package Interasreturn;

public interface Jumpping {
    void jump();
}
package Interasreturn;

public class JumppingDemo {
    public static void main(String[] args){
        //创建操作类对象，并调用方法
        JumppingOperator jo = new JumppingOperator();
        Jumpping j  =  new Cat();
        jo.useJumpping(j);

        Jumpping j2 = jo.getJumpping();//new Cat()
        j2.jump();
    }
}
package Interasreturn;

public class JumppingOperator {
    public void useJumpping(Jumpping j){//Jumpping j = new Cat();
        j.jump();
    }

    public Jumpping getJumpping(){
        Jumpping j = new Cat();
        return j;
    }

}

19.内部类

内部类概述:

内部类:就是在一个类中定义一个类。举例:在一个类A的内部定义一个类B，类B就被称为内部类
内部类的定义格式
内部类的访问特点
格式:

public class类名{
    修饰符class类名{
    }
}

范例:

public class outer {
    public class Inner {

    }
}

19.1内部类的访问特点

内部类可以直接访问外部类的成员，包括私有外部类要访问内部类的成员，必须创建对象

//内部类的访问特点

//内部类可以直接访问外部类的成员，包括私有外部类要访问内部类的成员，必须创建对象
public class Outer {
    private int num = 10;
    public class Inner {
        public void show() {
            System.out.println( num);
        }
    }
    
    public void method() {
        //show( ) ;
        Inner i = new Inner();
        i.show();
    }
}

19.2成员内部类

按照内部类在类中定义的位置不同，可以分为如下两种形式
在类的成员位置:成员内部类
在类的局部位置:局部内部类
成员内部类，外界如何创建对象使用呢?
格式:外部类名.内部类名对象名=外部类对象.内部类对象;

​ 范例:Outer.Inner oi = new Outer().new Inner();

public class outer {
 private int num = 10;
 /*public class Inner {
     public void show() {
         System.out.println(num);
  	}
 }*/
 public class Inner {
     public void show() {
         System.out.println(num);
  	}
 }
 
 public void method( ){
     Inner i = new Inner();
     i.show();
 }
}
public class InnerDemo {
 public static void main(String[] args) {
     //创建内部类对象，并调用方法
     //Inner i = new Inner( );
     //Outer.Inner oi = new Outer( ).new Inner( );oi.show( );
     //oi.show();
     Outer o = new Outer();
     o.method();
 }
}

19.3局部内部类

局部内部类是在方法中定义的类，所以外界是无法直接使用，需要在方法内部创建对象并使用

该类可以直接访问外部类的成员，也可以访问方法内的局部变量

public class outer {
	private int num = 10;
    public void method() {
        int num2  = 20;
        class Inner {
            pub1ic void show() {
               System.out.println( num) ;
               System.out.println( num2) ;
            }
		}
        Inner i = new Inner();
        i.show();
	}
}

19.4匿名内部类

前提:存在一个类或者接口，这里的类可以是具体类也可以是抽象类
格式:

new 类名或者接口名(){
	重写方法;
};

范例:

new Inter() {
public void show() {

	}
}

本质:是一个继承了该类或者实现了该接口的子类匿名对象

19.5匿名内部类在开发中的使用

/*
跳高接口
*/
public interface Jumpping {
    void jump ( );
}
/*
接口操作类，里面有一个方法，方法的参数是接口名
*/
public class Jumppingoperator {
    public void method (Jumpping j){
        j.jump ();
    }
}
/*
测试类
*/
public class JumppingDemo {
    public static void main ( string [] args){
        //需求:创建接口操作类的对象，调用method方法
    }
}

20.API

20.1Math

Math类概述:

Math包含执行基本数字运算的方法

没有构造方法，如何使用类中的成员呢?
看类的成员是否都是静态的，如果是，通过类名就可以直接调用

Math类的常用方法:

方法名说明
public static int abs(int a)返回参数的绝对值
public static double ceil(double a)返回大于或等于参数的最小double值,等于一个整数
public static double floor(double a)返回小于或等于参数的最大double值,等于一个整数
public static int round(float a)按照四舍五入返回最接近参数的int
public static int max(int a,int b)返回两个int值中的较大值
public static int min(int a,int b)返回两个int值中的较小值
public static double pow(double a,double b)返回a的b次幂的值
public static double random()返回值为double的正值，[0.0,1.0)
package JAVA002;

public class MathDemo {
    public static void main(String[] args) {
        // public static int abs (int a):返回参数的绝对值
        System.out.println(Math.abs(88));
        System.out.println(Math.abs(-88));
        System.out.println("--------");

        //public static double ceil (double a):返回大于或等于参数的最小double值，等于一个整数
        System.out.println(Math.ceil(12.34));
        System.out.println(Math.ceil(12.56));
        System.out.println("--------");

        //public static double floor (double a):返回小于或等于参数的最大double值，等于一个整数
        System.out.println(Math.floor(12.34));
        System.out.println(Math.floor(12.56));
        System.out.println("--------");

        //public static int round (fLoat a):按照四舍五入返回最接近参数的int
        System.out.println(Math.round(12.34F));
        System.out.println(Math.round(12.56F));
        System.out.println("--------");

        // public static int max (int a,int b);//返回两个int值中的较大值
        System.out.println(Math.max(66,88));
        System.out.println("--------");

        //public static int min (int a,int b):返回两个int值中的较小值(自学)

        //public static double pow (double a , double b):返回a的b次幂的值
        System.out.println(Math.pow(2.0,3.0));
        System.out.println("--------");

        //public static double random ():返回值为double的正值，[0.0,1.0)
        System.out.println(Math.random());
        System.out.println((int)(Math.random()*100));
    }
}

20.2System

System包含几个有用的类字段和方法，它不能被实例化

方法名说明
public static void exit(int status)终止当前运行的Java虚拟机，非零表示异常终止
public static long currentTimeMillis)返回当前时间(以毫秒为单位)
package JAVA002System;

public class SystemDemo {
    public static void main(String[] args) {
            /* System.out.println("开始");
            //public static void exit(int status):终止当前运行的Java虚拟机，非零表示异常终止
            System.exit(0);
            System.out.printLn("结束");
            */
            // public static long currentTimeMillis():返回当前时间(以毫秒为单位)
//          System.out.printLn(System.currentTimeMillis( ) );
//          System.out.printLn(System.currentTimeWillis() * 1.0 / 1000 / 60 / 60 / 24 / 365 +"年");
            long start = System.currentTimeMillis();
            for (int i = 0; i < 1000; i++){
                System.out.println(i);
            }
            long end = System.currentTimeMillis();
            System.out.println("共耗时:" +(end - start)+"毫秒");
    }
}

20.3Object

Object类的概述

Object是类层次结构的根，每个类都可以将Object作为超类。所有类都直接或者间接的继承自该类
构造方法: public Object()
回想面向对象中，为什么说子类的构造方法默认访问的是父类的无参构造方法?

因为它们的顶级父类只有无参构造方法

package JAVA002Object;
/*
* Object 是类层次结构的根,每个类都可以将Object作为超类。所以类都直接或者间接继承自该类
* 看方法的源码,选中方法,按下Ctrl+B*/
public class ObjectDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("彭于晏");
        s.setAge(30);
        System.out.println(s);//JAVA002Object.Student@7ef20235
        System.out.println(s.toString());//JAVA002Object.Student@7ef20235
        /*
        public void println(Object x) {
            String s = String.valueOf(x);
            if (getClass() == PrintStream.class) {
                // need to apply String.valueOf again since first invocation
                // might return null
                writeln(String.valueOf(s));
            } else {
                synchronized (this) {
                    print(s);
                    newLine();
               }
            }
        }

        public static String valueOf(Object obj) {//obj=x；
            return (obj == null) ? "null" : obj.toString();
        }

        public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }
        * */
    }
}
package JAVA002Object;

public class Student extends Object{
    private String name;
    private int age;

    public Student(){}
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

20.4equals

方法名说明
public String toString()返回对象的字符串表示形式。建议所有子类重写该方法，自动生成
public boolean equals(Object obj)比较对象是否相等。默认比较地址，重写可以比较内容，自动生成

20.5Arrays

20.5.1冒泡排序

排序:将一组数据按照固定的规则进行排列
冒泡排序:一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对所有的数据进行操作，直至所有数据按要求完成排序

如果有n个数据进行排序，总共需要比较n-1次
每一次比较完毕，下一次的比较就会少一个数据参与

代码实现:

package java003;

public class ArrayDemo {
    public static void main(String[] args) {
        //定义一个数组
        int []arr = {24,15,69,80,57,13};
        System.out.println("排序前" + arrToString(arr));
        for(int x=0;x<arr.length-1;x++)
            for(int i = 0;i<arr.length-1-x;i++){
                if(arr[i]>arr[i+1]){
                    int temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
        System.out.println("排序后" + arrToString(arr));
    }
    public static String arrToString(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("]");
        String s = sb.toString();
        return s;
    }
}
20.5.2Arrays类的概述和常用方法

Arrays类包含用于操作数组的各种方法

方法名说明
public static String toString(int[] a)返回指定数组的内容的字符串表示形式
public static void sort(int[]a)按照数字顺序排列指定的数组

工具类的设计思想:
构造方法用private修饰(防止外界创造对象)

成员用public static修饰(为了让使用类名访问该成员方法)

平时只会伸手要,最后只会没人要

20.6基本类型包装类

将基本数据类型封装宓对象的好处在于可以在对象中定义更多的功能方法操作

该数据常用的操作之一:用于基本数据类型与字符串之间的转换

基本数据类型包装类
byteByte
shortshort
intlnteger
longLong
floatFloat
doubleDouble
charCharacter
booleanBoolean
20.6.1Integer类的概述和使用

Integer:包装一个对象中的原始类型int的值

方法名说明
public Integer(int value)根据int 值创建Integer对象(过时)
public Integer(String s)根据String 值创建lnteger对象(过时)
public static Integer valueOf(int i)返回表示指定的int值的Integer 实例
public static Integer valueOf(String s)返回一个保存指定值的Integer 对象String
package java003Integer;

public class IntegerDemo {
    public static void main(String[] args) {
        /*
        //public Integer(int value):根据 int 值创建 Inter 对象（过时）
        Integer i1 = new Integer（100）;
        System.out.println(i1);

        //public Integer(String s):根据 String 值创建 Integer 对象（过时）
        Integer i2 = new Integer("100");
        //Integer i2 = new Integer("abc");//NumberFormatException
         */
        //public static Integer valueOf (int i):返回表示指定的int值的Integer实例
        Integer i1 = Integer.valueOf(100);
        System.out.println(i1);

        //public static Integer valueOf(String s):  返回一个保存指定值的Integer 对象 String
        Integer i2 = Integer.valueOf("100");
        System.out.println(i2);
    }
}
20.6.2int和String的相互转换

基本类型包装类的最常见操作就是:用于基本类型和字符串之间的相互转换
1.int转换为String
public static String valueOf(inti):返回int 参数的字符串表示形式。该方法是String类中的方法
2.String 转换为int
public static int parseInt(Strings):将字符串解析为int类型。该方法是Integer类中的方法

20.7案例:字符串中数据排序

需求:有一个字符串:“9127463850”，请写程序实现最终输出结果是:“2738465091"
思路:
①定义一个字符串
②把字符串中的数字数据存储到一个int类型的数组中
●得到字符串中每一个数字数据?
public String[]split(Stringregex)
●定义一个int数组，把String[]数组中的每一个元素存储到int数组中

public static int parselnt(String s)

③对int数组进行排序
④把排序后的int数组中的元素进行拼接得到一个字符串，这里拼接采用StringBuilder来实现

⑤输出结果

package java003Integer.Integer3;

import java.util.Arrays;

public class IntegerTest {
    public static void main(String[] args) {
        //定义一个字符串
        String s = "91 27 46 38 50";

        //把字符串中的数字数据存储到一个int类型的数 组中
        String[] strArray = s.split(" ");
        for(int i=0 ;i< strArray.length;i++){
            System.out.println(strArray[i]);
        }

        //定义一个int数组,把String[]数组中的每一个元素存储到int数组中
        int []arr = new int[strArray.length];
        for(int i=0;i< arr.length;i++){
            arr[i] = Integer.parseInt(strArray[i]);
        }

        //对int数组进行排序
        Arrays.sort(arr);
        StringBuilder sb = new StringBuilder();
        for(int i=0;i< arr.length;i++){
            if(i== arr.length-1){
                sb.append(arr[i]);
            }else{
                sb.append(arr[i]).append(" ");
            }
        }
        String result = sb.toString();

        //输出结果
        System.out.println("result :"+ result);
    }
}

20.8自动装箱和拆箱

装箱:把基本数据类型转换为对应的包装类类型

拆箱:把包装类类型转换为对应的基本数据类型

package java003Integer.Integer4;

public class IntegerDemo {
    public static void main(String[] args) {
        //装箱：把基本数据类型转换为对应的包装类类型
        Integer i = Integer.valueOf(100);
        Integer ii = 100;//自动装箱Integer.valueOf(100);

        //拆箱：把包装类类型转换为对应的基本数据类型
        //ii+=200;
        ii = ii.intValue() + 200;//自动拆箱
        System.out.println(ii);

        Integer iii = null;
        if (iii != null) {
            iii + = 300;//NullPointerException
        }
    }
}

注意:在使用包装类类型的时候，如果做操作，最好先判断是否为null
我们推荐的是，只要是对象，在使用前就必须进行不为null的判断

参考资料

https://www.bilibili.com/video/BV18J411W7cE?p=1

_NOUS_
关注
专栏目录
Java笔记 - 黑马程序员_03（继承，修饰符，多态，抽象类，接口，内部类）
逸乐的博客
04-22 2518
1. 继承 1.1 继承的概述 继承是面向对象三大特征之一。可以使得子类具有父类元素的属性和方法，还可以在子类中重新定义，追加属性和方法。 继承的格式： 格式：public class 子类名 extends 父类名 案例：public class ZI extends FU{} FU类为父类（superclass），超类，基类 ZI类为子类（subclass），派生类，扩展类 继承中子类的特点： 子类可以有父类的内容 子类也可以有自己特有的内容
Java基础知识点（类和对象、方法、封装、继承、多态、抽象类和接口）
StruggleBamboo的博客
12-18 1077
Java基础知识点一、类和对象1.类是什么？对象又是什么？类和对象的关系又是什么？2.单元测试：3.输出简洁方式4.类：二、方法1.方法的组成：2.修饰符：3.返回值类型：4.方法名：5.参数：6.调用：7.构造方法：8.重载：三、封装和继承1.封装：2.包：3.访问修饰符：4.static和this关键字5.继承：6.this和super的区别：7.重写（覆盖）和重载：8.Final：9.要想让一个类不被其它类继承：10.继承总结：四、多态1.重写object类的equals方法2.instanceof3
01 static 代码块 继承 权限修饰符 多态 抽象类 接口 枚举
最新发布
晨绪的博客
04-09 1136
static修饰变量修饰方法修饰代码块隶属类(静态变量)类(静态方法)类(静态代码块)推荐访问方式类名.变量名类名点.方法名()类加载时自动执行经典使用场景多对象共享变量工具类方法为类变量初始化赋值什么是继承?继承的好处是啥？继承就是java允许我们用extends关键字，让一个类和另一个类建立起一种父子关系。提高代码复用性，减少代码冗余，增强类的功能扩展性。继承的格式子类 extends 父类继承后子类的特点？
Java基础学习必备（2）(继承、多态、修饰符、抽象类、接口)
ker的博客
06-26 1048
Java基础看这里
Java基础 | 继承，多态，抽象类与接口
zszq111的博客
01-12 1951
继承，多态，抽象类和接口
抽象类，接口，形参和返回值
weixin_54226626的博客
05-05 280
接口就是一种公共的规范标准，只要符合规范标准，大家都可以使用。Java中的接口更多体现在对行为的抽象。
Java基础③-继承、修饰符、多态、抽象类、接口、参数传递、内部类
qq_44989062的博客
03-03 107
Java基础③
Java | 继承、多态、抽象类与接口
天下弈星~的博客
07-28 567
详细介绍了Java中的继承、多态。抽象类与接口的相关知识点。
Java-类和对象、继承多态、抽象类、接口---语法简记
YeZh1Yong 的博客
08-10 647
Java中类和对象、继承多态、抽象类、接口的基本语法内容
java基础笔记三（静态、继承与多态、抽象类、接口、权限修饰符、枚举、final关键字、Object&Math&Date&包装类等常见类、Collection集合、Map集合）
fuyaozhishangzzx的博客
08-14 328
java基础知识（三）：stastic、extend、implements、面向对象三大特性：封装、继承、多态，抽象类、接口与开发中常见类、集合的使用.
JAVA第七章继承、多态、抽象类与接口
m0_73900638的博客
03-31 428
tostring（）的功能是将一个对象返回为字符串形式，它会返回一个String实例，在实际的应用中通常重写tostring（）方法，为对象提供一个特定的输出的模式，当这个类转换为字符串或与字符串连接时，将自动调用用重写的tostrin（）方法。在Java语言中，有两种比较对象的方式，分别为“==”运算符与equals（）方法，两者区别在于：“==”比较的是两个对象引用内存地址是否相等，而equals（）方法比较的是两个对象的实际内容，【例7.4】根据身份证号判断是否为同一人。//某只鸽子是一只鸟。
Java第七章继承、多态、抽象类和接口
2302_76537296的博客
04-04 1433
总结
Android动画学习记录二（属性动画、估值器和插值器）
nous_x的博客
03-19 3784
Android动画学习记录二（属性动画、估值期和插值器） 自API 11 Android 3.0版本开始，系统给我们提供了一种全新的动画模式，属性动画(property animation)，它弥补了之前补间动画的一些缺陷，几乎可以完全替代掉补间动画了。关于补间动画可以看这篇，https://blog.csdn.net/qq_53749266/article/details/123571771?spm=1001.2014.3001.5502 如果只需要对View进行移动、缩放、旋转和淡入淡出操作，那么补间
JDK 1.8 ArrayList类源码阅读记录
nous_x的博客
03-11 1189
JDK 1.8 ArrayList类源码阅读记录 JDK 1.8 ArrayList类源码阅读记录JDK 1.8 ArrayList类源码阅读记录一、简介二、属性三、构造方法四、ArrayList扩容机制五、方法5.1 增add(E e)****add(int index, E element)********addAll（Collection<? extends E> c）********addAll(int index, Collection<? extends E> c)***
Java学习记录六（方法引用、函数式接口、Stream流、反射和模块化）
nous_x的博客
03-18 953
文章目录Java28.方法引用28.1体验方法引用28.2方法引用符28.3Lambda表达式支持的方法引用28.3.1引用类方法28.3.2引用对象的实例方法28.3.3引用类的实例方法28.3.4引用构造器29.函数式接口29.1函数式接口概述29.2函数式接口作为方法的参数29.3函数式接口作为方法的返回值29.4常用的函数式接口29.4.1Suplier接口29.4.1.1Supplier接口练习之获取最大值29.4.2Consumer接口29.4.2.1Consumer接口练习之按要求打印信息29
Java学习记录四（IO流）
nous_x的博客
06-27 759
Java Java学习总结笔记（基础篇4）Java24.IO流24.1File24.1.1File类概述和构造方法24.2File类创建功能24.3File类删除功能24.4File类判断和获取功能24.5递归案例：递归求阶乘*案例：遍历目录24.2字节流24.2.1IO流概述和分类24.2.2字节流写数据24.2.3字节流写数据的3种方式24.2.4字节流写数据的两个小问题24.2.5字节流写数据加入异常处理24.2.6字节流读数据（一次读一个字节数据）案例：复制文本文件24.2.7字节流读数据(一次读一
哈希表+ JDK 1.8 HashMap源码学习记录
nous_x的博客
05-22 708
哈希表+HashMap源码学习记录一、什么是哈希表1.1 哈希函数1.1.1 哈希碰撞拉链法线性探测法总结二、HashMap类2.1 继承关系2.2 底层数据结构2.2.1 HashMap中的table桶数组三、HashMap的工作过程3.1 需要了解的知识3.1.1 用位运算代替取模运算的好处：3.2 `new HashMap()`的过程3.2.1 tableSizeFor`原理：3.2.2 其他的构造方法3.3 HashMap计算哈希值/索引的方法——hash算法(也称为高位运算算法)小结3.3 put
Java学习记录一（概述、第一个程序、基础语法、运算符、分支语句、循环语句、数组、方法、Debug、面向对象基础和字符串）
nous_x的博客
04-22 621
Java Java学习总结笔记（基础篇1）Java1.Java概述1.1JVM1.1JRE和JDK1.3JKD、JRE和JVM的关系JDK的安装目录2.第一个程序2.1常用DOS命令2.1.1打开命令提示符窗口2.1.2常用命令2.2Path环境变量的配置3.1HelloWorld案例3.1.1HelloWorld案例常见问题3.基础语法3.1关键字3.1.1关键字特点3.1.2常量分类3.2数据类型3.2.1计算机存储单元3.2.2数据类型3.2.3数据类型内存占用和取值范围3.3变量3.3.1变量定义3
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值