Java基础知识 - 集合，面向对象进阶_new arraylist<>()-优快云博客

本文链接：https://blog.youkuaiyun.com/2301_81220652/article/details/143753948

1.创建集合的对象：

ArrayList<String> list = new ArrayList<>();

2.成员方法：

1.add(E e) 添加元素

2.remove(E e)删除指定元素

3.set(int index,E e) 修改元素

4.get(int index) 获取指定索引的元素

5.int size() 集合的长度

3.综合练习：

案例一：集合的遍历方式

需求：定义一个集合，添加字符串，并进行遍历，遍历格式参照：[元素1，元素2，元素3]

package ArrayList;

import java.util.ArrayList;

public class ArrayListTest1 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        System.out.print("[");
        for (int i = 0; i < list.size(); i++) {
            if(i == list.size() - 1){
                System.out.print(list.get(i));
            }else{
                System.out.print(list.get(i) + ", ");
            }
        } 
        System.out.println("]");  //[aaa, bbb, ccc]
    }
}

案例二：添加数字并遍历：

需求：定义一个集合，添加数字，并进行遍历。

package ArrayList;

import java.util.ArrayList;

public class ArrayListTest2 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(111);
        list.add(222);
        list.add(333);
        System.out.print("[");
        for (int i = 0; i < list.size(); i++) {
            if(i == list.size() - 1){
                System.out.print(list.get(i));
            }else{
                System.out.print(list.get(i) + ", ");
            }
        }
        System.out.println("]");
    }
}

案例三：添加学生对象并遍历

需求：定义一个集合，添加一些学生对象，并进行遍历，学生类的属性为：姓名，年龄

要求：对象的数据来自键盘录入

package ArrayList;

import java.util.ArrayList;
import java.util.Scanner;

public class ArrayListTest3 {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();

        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            //创建学生对象
            Student s = new Student();
            System.out.println("请输入学生的姓名：");
            String name = sc.next();
            System.out.println("请输入学生的年龄：");
            int age = sc.nextInt();

            //把姓名和年龄赋值给学生
            s.setName(name);
            s.setAge(age);

            //把这些值添加到集合里
            list.add(s);
        }

        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            //元素 list.get(i)
            Student stu = list.get(i);
            System.out.println(stu.getName() + ", " + stu.getAge());
        }
    }
}

案例四：添加用户对象并判断是否存在

需求：main方法中定义一个集合，存入三个用户对象。用户属性为：id,username,password

要求：定义一个方法，根据id查找对应的用户信息，如果存在，返回true

package ArrayList;

public class User {
    private String id;
    private String username;
    private String password;

    public User() {
    }

    public User(String id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public String getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}


package ArrayList;

import java.util.ArrayList;

public class ArrayListTest4 {
    public static void main(String[] args) {
    //1.创建集合
        ArrayList<User> list = new ArrayList<>();
        //2.创建三个用户对象
        User u1 = new User("1","zhangsan","123456");
        User u2= new User("2","lisi","234567");
        User u3 = new User("3","wangwu","123457");

        list.add(u1);
        list.add(u2);
        list.add(u3);

        boolean contains = contains(list, "4");
        //打印结果
        System.out.println(contains);
    }

    //定义方法
    public static boolean contains(ArrayList<User> list,String id){
        for(int i = 0; i < list.size(); i++){
           User u = list.get(i);
           String uid = u.getId();
           if(uid.equals(id)){
               return true;
           }
        }
        return false;
    }
}

二。面向对象进阶：static，继承，包，抽象类，接口，多态，内部类

1.static

1.static表示静态，是Java中的一个修饰符，可以修饰成员方法，成员变量

2.被static修饰的成员变量，叫静态变量

*特点：被该类所有对象共享

*调用方式：类名调用 / 对象名调用

3.被static修饰的成员方法，就是静态方法

2.继承：

1.Java中提供一个关键字extends，用这个关键字，我们可以让一个类和另外一个类建立起继承关系
public class Student extends Person {}
2.什么时候用继承：当类与类之间，存在相同的内容，并满足子类是父类中的一种，就可以考虑使用继承

3.继承的特点：

Java只支持单继承，不支持多继承，但支持多层继承

练习：继承的练习

现在有四种动物：布偶猫，中国狸花猫，哈士奇，泰迪。暂时不考虑属性，只考虑行为。

四种动物分别有以下的行为：

布偶猫：吃饭，喝水，抓老鼠

中国狸花猫：吃饭，喝水，抓老鼠

哈士奇：吃饭，喝水，看家，拆家

泰迪：吃饭，喝水，看家，蹭一蹭

package extendDemo;

public class Animal {
    public void eat(){
        System.out.println("吃东西");
    }
    public void drink(){
        System.out.println("喝水");
    }
}


package extendDemo;

public class Cat extends Animal{
    public void catchMouse(){
        System.out.println("猫在抓老鼠");
    }
}


package extendDemo;

public class Dog extends Animal{
    public void lookHome(){
        System.out.println("狗在看家");
    }
}


package extendDemo;

public class Husky extends Dog{
    public void breakHome(){
        System.out.println("哈士奇在拆家");
    }
}


package extendDemo;

public class LiHua extends Cat{

}


package extendDemo;

public class Ragdoll extends Cat{


}


package extendDemo;

public class Teddy extends Dog{
    public void touch(){
        System.out.println("泰迪又在蹭我的腿了");
    }
}


package extendDemo;

public class Test {
    public static void main(String[] args) {
        //创建布偶猫的对象
        Ragdoll r = new Ragdoll();
        r.eat();
        r.drink();
        r.catchMouse();
        System.out.println("-------------------");
        //创建哈士奇的对象
        Husky h = new Husky();
        h.eat();
        h.drink();
        h.breakHome();
    }
}

3.多态：

1.什么是多态：同类型的对象，表现出的不同形态

2.多态的前提：

*有继承关系

*有父类引用指向子类对象

*有方法重写

3.综合练习：

需求：1.定义狗类属性：年龄，颜色；行为：吃东西，看家；

2.定义猫类属性：年龄，颜色，行为：吃东西，逮老鼠；

3.定义饰养员：属性：姓名，年龄；行为：dog方法，cat方法

4.定义测试类：调用dog方法和cat方法

package ManyDemo;

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

    public Animal() {
    }

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

    public int getAge() {
        return age;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public void eat(String something){
        System.out.println("动物在吃" + something);
    }
}


package ManyDemo;

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

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

    @Override
    public void eat(String something) {
        System.out.println(getAge() + "岁的" + getColor() + "颜色的猫咪眯着眼睛侧着头吃" + something);
    }

    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}


package ManyDemo;

public class Dog extends Animal{

    public Dog() {
    }

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

    @Override
    public void eat(String something){
        System.out.println(getAge() + "岁的" + getColor() + "颜色的狗两只前腿死死的抱住" + something  +"猛吃");
    }
    public void lookHome(){
        System.out.println("狗在看家");
    }
}


package ManyDemo;

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;
    }

    //饰养狗
//    public void keepPet(Dog dog,String something){
//        System.out.println("年龄为" + age + "岁的" + name + "养了一只" + dog.getColor() + "颜色的" + dog.getAge() + "岁的狗");
//        dog.eat(something);
//    }
//
//    //饰养猫
//    public void keepPet(Cat cat,String something){
//        System.out.println("年龄为" + age + "岁的" + name + "养了一只" + cat.getColor() + "颜色的" + cat.getAge() + "岁的猫");
//        cat.eat(something);
//    }

    //想要一个方法，接收所有的动物，就要用到多态
    //方法的形参：可以写这些类的父类，Animal
    public void keepPet(Animal a,String something){
        if(a instanceof Dog d){
            System.out.println("年龄为" + age + "岁的" + name + "养了一只" + a.getColor() + "颜色的" + a.getAge() + "岁的狗");
            d.eat(something);
        }else if(a instanceof Cat c){
            System.out.println("年龄为" + age + "岁的" + name + "养了一只" + c.getColor() + "颜色的" + c.getAge() + "岁的猫");
            c.eat(something);
        }else{
            System.out.println("没有这种动物");
        }

    }

}


package ManyDemo;

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

//        //创建对象并调用方法
//        Person p1 = new Person("老王", 30);
//        Dog d = new Dog(2,"黑");
//        p1.keepPet(d,"骨头");
//
//        Person p2 = new Person("老李" ,25);
//        Cat c = new Cat(3,"灰");
//        p2.keepPet(c,"鱼");

        //创建饰养员的对象
        Person p = new Person("老王",30);
        Dog d = new Dog(2,"黑");
        Cat c = new Cat(3,"灰");
        p.keepPet(d,"骨头");
        p.keepPet(c,"鱼");


    }
}

//年龄为30岁的老王养了一只黑颜色的2岁的狗
2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃
年龄为30岁的老王养了一只灰颜色的3岁的猫
3岁的灰颜色的猫咪眯着眼睛侧着头吃鱼

四.抽象类和抽象方法

1. 一个方法抽取到方法里不确定方法体就不要写方法体，用抽象方法

2.一个类中存在抽象方法，那么该类就必须声明为抽象类

3.抽象方法的定义格式：

public abstract 返回值类型 方法名(参数类型);

4.抽象类的定义格式：

public abstract class 类名{}

5.注意事项：

*抽象类不能实例化（不能创建对象）

*子类要重写父类里面所有的抽象方法还有别忘了构造方法

6.编写带有抽象类的标准JavaBean类

*青蛙frog：属性：名字，年龄行为：吃虫子，喝水

* 狗dog：属性：名字，年龄行为：吃骨头，喝水

*山羊sheep：属性：名字，年龄行为：吃草，喝水

package abstrDemo;

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 void drink(){
        System.out.println("动物在喝水");
    }
    public abstract void eat();
}


package abstrDemo;

public class Dog extends Animal{

    public Dog() {
    }

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

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


package abstrDemo;

public class Frog extends Animal{

    public Frog() {
    }

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

    @Override
    public void eat() {
        System.out.println("青蛙在吃虫子");
    }
}


package abstrDemo;

public class Sheep extends Animal{

    public Sheep() {
    }

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

    @Override
    public void eat() {
        System.out.println("山羊在吃草");
    }
}


package abstrDemo;

public class Test {
    public static void main(String[] args) {
        //创建对象
        Frog f = new Frog("小绿",1);
        System.out.println(f.getName() + ", " + f.getAge());
        f.drink();
        f.eat();
    }
}

//小绿, 1
动物在喝水
青蛙在吃虫子

五. 接口（就是一种规则）

1.接口用关键字interface来定义

public interface 接口名{}

2.接口不能实例化（不能创建它的对象）

3.接口和类之间是实现关系，通过implements关键字表示

public class 类名 implements 接口名{}

4.接口的子类：

要么就重写接口中的所有抽象方法

要么是抽象类

5.练习：编写带有接口和抽象类的标准JavaBean类

*青蛙frog：属性：名字，年龄行为：吃虫子，蛙泳

* 狗dog：属性：名字，年龄行为：吃骨头，狗刨

*兔子：属性：名字，年龄行为：吃胡萝卜

package implementDemo;

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 implementDemo;

public interface Swim {
    public abstract void swim();
}


package implementDemo;

public class Rabbit extends Animal {

    public Rabbit() {
    }

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

    @Override
    public void eat() {
        System.out.println("兔子在吃胡萝卜");
    }


}


package implementDemo;

public class Frog extends Animal implements Swim{

    public Frog() {
    }

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

    @Override
    public void eat() {
        System.out.println("青蛙在吃虫子");
    }

    @Override
    public void swim() {
        System.out.println("青蛙在蛙泳");
    }
}


package implementDemo;

public class Dog extends Animal implements Swim{

    public Dog() {
    }

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

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

    @Override
    public void swim() {
        System.out.println("狗刨");
    }
}


package implementDemo;

public class Test {
    public static void main(String[] args) {
        //创建对象
        Frog f = new Frog("小青",1);
        System.out.println(f.getName() + ", " + f.getAge());
        f.eat();
        f.swim();
    }
}

//小青, 1
青蛙在吃虫子
青蛙在蛙泳

六.匿名内部类：

1.格式：

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