• java学习--day15（泛型、集合）

    文章目录

    day14复习

    1.String类下面的讲的所有方法
	equals
	length
	charAt
	indexOf 
	lastIndexOf
	endWidth
	isEmpty
	contains
	equalsIgnoreCase
	valueOf
	toCharArray
	replace
	split
	subString
	toUpperCase
	toLowerCase
	trim
2.多态的简单理解
	父类的引用指向子类的对象
	一个方法的参数是父类，真实传参的时候子类的对象
3.重写和重载
	重写：
		继承，在子类中去重写
		子类的方法和父类的方法除了方法体不一样其他都一样
	重载：
		在一个类中，方法名字一样，参数列表一定不一样的
4.final和finally关键字的区别
	final 修饰变量  类  方法等，代表最终的
	finally  在try-catch   无论有没有异常都要执行的
5.抽象类的语法格式
	abstract class  类 ｛
		
	｝
6.接口的语法格式
interface  接口名字  {
	
}
7.成员方法的语法格式
 权限修饰符 返回值 方法的名字 (参数列表) {
 
 }
8.继承的语法格式
class B extends A {

}
9.对成员变量的封装，如何做
	1.private 
	2.set  get

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49

    今天的内容

    1.泛型

    2.权限修饰符

    3.集合

    1.泛型

    1.1为啥要使用泛型

    泛型: 广泛的类型

    在开发中对数据一致性的要求是比较看重的！！！

    例如：

    ​ 数组中存的数据 类型都是一致的。

    ​ 但是数组有一个不好的地方，数组预先定义容量！！！

    使用集合，你要记住集合也是存储数据的！！！

    package com.qfedu.b_fanxing;

import java.util.ArrayList;

public class Demo1 {
    public static void main(String[] args) {
        //声明一个int类型数组
        int[] arr = {1, 2, 3, 4};
        char[] chs = {'a', 'b', 'c'};
        //在数组的容量中  数据类型的都是一致的，很好！！！
        //数组中的存储的数据确实一致的，但是开发不用！！！为啥？
        //咱们 使用的时候，容量先定好的，而且数组添加数据删除数据，太麻烦了
        //实际开发中咱们需要后面即将学的集合
        //集合就是用来存储的数据的！！！
        ArrayList  list = new ArrayList();//就把他当成一个容器即可
        list.add("狗蛋");
        list.add(250);
        list.add('a');
        list.add(false);
        //啥类型的数据都可以存进来的
        System.out.println(list);
        //以上存储的数据好不好？  不好！！！
        //对数据类型一致性要求是比较高的！！！
        //取值,每次都需要强转  太不好了
        String str = (String)list.get(0);
        System.out.println(str);

        //可以使用泛型 进行约束
        ArrayList<String> list1 = new ArrayList<>();
        //告知编译器  这个集合只能存String类型的数据
        list1.add("狗蛋");
        list1.add("老邢");
        list1.add("骚磊");
        System.out.println(list1);
        //取值
        String s = list1.get(0);
        System.out.println(s);
    //  ArrayList人家底层是封装了好了泛型，人家已经做好的
        //学习自己如何自己写带有泛型的类  泛型的方法 等

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    1.2带有泛型的方法

    成员方法的语法格式:

    public 返回值类型  方法名字 （参数列表） ｛
｝

    • 1
    • 2

    带有的泛型的方法语法格式：

    public <无意义的占位符> 返回值类型   方法的名字 (参数列表) {

}

    • 1
    • 2
    • 3

    无意义的占位符: 可以是T 或者E 也可以是? 等 都可以

    无参无返回值的方法

    有参无返回值的方法

    无参有返回值的方法

    有参有返回值的方法

    package com.qfedu.b_fanxing;

public class Demo2 {
    public static void main(String[] args) {
        test(34);
        test("狗");
        test('蛋');
        test1();
        test3("老邢");
        test3(89.7);
    }
//    public static void test (int a) {
//        System.out.println(a);
//    }
//    public static void test (String a) {
//        System.out.println(a);
//    }
//    public static void test (char a) {
//        System.out.println(a);
//    }
    //使用泛型的写法
    //这个T只是一个占位而已，如果你传了字符串 那么这个T就是String
    //如果你传了一个整数 那么T  就是Integer
    //具有广泛性和普适性
    //其实方法的重载的升级版本
    //无返回值有参数的
    public static <T> void test (T t) {
        System.out.println(t);
    }
    //无返回值 无参的方法，没有必要使用泛型  没有意义
    public static <T> void test1 () {
        T t = null;
        //你这个结果和泛型有有啥关联？没有任何意义
        System.out.println("嘻嘻哒");
    }
    //无参 有返回值的方法，有咩有必要使用泛型? 没有
    public static <T> T test2() {

        return null;
    }
    //有参 有返回值的方法,这个使用泛型有没有意义? 有！！！
    public static <T> T test3 (T t) {
        return t;
    }
//    public static  T test4 (T t, T t1) {
//        return t + ":" + t1;
//    }
    //总结：
    /**
     * 泛型的方法一定是带有参数的才有意义！！！
     * 无参的都是无意义的，而且一定要注意带有返回值的
     * 这个返回值是和参数的T 数据类型要保持一致的
     */


}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    package com.qfedu.b_fanxing;

class Dog {

    public <T> void test (T t) {
        System.out.println(t);
    }
}
public class Demo3 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.test("goudan");
        dog.test(89);
        dog.test(90.8);
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    总结：泛型方法一定要使用带有参数的方法才有意义

    1.3带有泛型的类

    语法格式:

    class 类<无意义的占位符> ｛
｝

    • 1
    • 2
    package com.qfedu.b_fanxing;

class Person<T> {

//    T name;//所以成员变量最好不用
//    T age;
//    T sex;
    //主要看成员方法
    //带有泛型的方法，最起码得有参数
    //注意： 如果再一个带有泛型的类，成员方法不要加 了
    public <T> void test (T t) {
        System.out.println(t);
    }
    //想要一个方法中的泛型和类保持一致，一定在方法不要加
    public void test1 (T t) {
        System.out.println(t);
    }
    //如果是静态方法呢？
    //对象创建的时候才 确定E数据类型，静态的方法在创建对象之前
    //这个E和上面 类的T无关的  自娱自乐
    public static <E> void test2 (E e) {
        System.out.println(e);
    }

}
public class Demo4 {
    public static void main(String[] args) {
        //在声明对象的时候，指定好了咱们的T是啥数据类型
        //那么 你的成员变量 T  name  T 就是那种数据类型
        Person<String> stringPerson = new Person<>();
       // stringPerson.name = "goudan";
        // stringPerson  泛型 是String 就意味着test(T t)
        //T  也应该是String
        stringPerson.test(89);
        stringPerson.test1("wuw");
        Person<Integer> person1 = new Person<>();
        //person1.name = 98;
        person1.test1(56);
        //调用静态方法
        Person.test2("hjsj");
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    package com.qfedu.b_fanxing;

class Cat<E> {

    //带有泛型的方法
    public void eat (E e) {
        System.out.println(e);
    }
}
public class Demo5 {
    public static void main(String[] args) {
        Cat<String> cat = new Cat<>();
        cat.eat("还是当今世界");
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    声明一个泛型类Animal，子类Panda Panda下面重写Animal类下面的泛型方法 play（T t）

    实例化对象 调用play方法

    package com.qfedu.b_fanxing;

class Animal<T> {
    public void play (T t) {
        System.out.println(t);
    }
}
class Panda<T> extends  Animal<T> {
    @Override
    public void play(T t) {
        System.out.println(t);
    }
}
public class Demo6 {
    public static void main(String[] args) {
        Panda<String> panda = new Panda<>();
        panda.play("玩狗");

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    总结：

    1.泛型方法

2.泛型类
	在泛型类中如果写泛型方法的时候，不需要加 

    • 1
    • 2
    • 3
    • 4
    1.4带有泛型的抽象类

    语法格式:

    abstract class 类名<无意义的占位符> ｛
｝

    • 1
    • 2
    package com.qfedu.c_fanxing;

abstract class A<T> {
    abstract void testA (T t);
}
//抽象类，暂时没有办法直接实例化，只能再写一个普通类去继承抽象类
//总结：继承了带有泛型的抽象类，那么继承类也需要有泛型！！！
class TestA<T> extends A<T> {

    @Override
    void testA(T t) {
        System.out.println(t);
    }
}
public class Demo1 {
    public static void main(String[] args) {
        /**
         * int 的包装类 Integer
         * byte 的包装类 Byte
         * short 的包装类 Short
         * long 的包装类 Long
         * float 的包装类 Float
         * double 的包装类  Double
         * char  的包装类 Character
         * boolean 的包装类 Boolean
         *
         */
        //是int的包装类  就是代表的是int类型的数据
        TestA<Integer> testA = new TestA<>();
        testA.testA(89);
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    1.5带有泛型的接口

    语法格式:

    interface 接口的名字<无意义的占位> ｛

｝

    • 1
    • 2
    • 3
    package com.qfedu.c_fanxing;

//element 元素  Type  类型
interface B<T> {
    //成员方法
    void eat(T t);
}
class TestB<T> implements B<T> {

    @Override
    public void eat(T t) {
        System.out.println(t);
    }
}
public class Demo2 {
    public static void main(String[] args) {
        TestB<Character> testB = new TestB<>();
        testB.eat('g');


    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    案例明天来讲

    总结：

    泛型方法：
public   void test (T t) {}
泛型类中的泛型方法，不要这个
public  void test (T t) {}
泛型类:
class Person  {

}
抽象类:
abstract class Person {

}
接口：
interface Person {

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    2.权限修饰符【简单】

    其实咱们已经见过权限修饰符了

    public private default(不写是叫default) 默认的， protected

    权限修饰符 四个：

    ​ 权限修饰符去修饰 类， 成员变量 ，成员方法 等。赋予他们不同的权限

    2.1private修饰符

    private 修饰成员变量和成员方法。私有的

    1.在本类中可以使用私有化的成员属性和成员方法

    2.同一个包下面其他类不能使用私有化的成员属性和成员方法

    3.其他的包的下面的其他类不能使用私有化的成员属性和成员方法

    总结：private修饰的成员变量和成员方法只能在本类中使用

    2.2不写（默认的）

    修饰方法和属性

    就是不写，默认的

    1.在本类中默认的属性和方法是可以使用的

    2.同一个包下面的其他类可以使用

    3.其他包下面的其他类不能使用的

    总结：默认的属性和方法只能在同一个包使用！！！

    2.3protected

    修饰方法和属性

    1.同一个类中可以使用的

    2.同一个包下面其他类可以使用

    3.不同包下面，如果是子类可以使用但是其他类不能使用

    总结：其他包下面其他类不能使用，但是继承的子类可以使用的

    2.4public

    修饰方法和属性

    公开的，谁都可以

    开发中最常用的是 private public

    权限修饰符的名称当前类同一个包下面其他类不同包下面子类不同包下面的其他类
    public可以可以可以可以
    protected可以可以可以不可以的
    不写（默认）可以可以不可以不可以
    private可以不可以不可以不可以

    这个几个修饰符会写一辈子带到坟墓中

    3.集合【重点】

    集合和数组一样，都是用来存储数据的

    真实开发的时候咱们用集合，不用数组

    数组存数据：

    ​ 1.容量是固定

    ​ 2.数组封装的方法是比较少的，集合封装的方法是比较多的！！！

    Java给咱们封装了集合的类库，封装了很多！！！所以先学集合的架构

    3.1集合的架构

    看官方的API

    interface Collection java中集合的总接口

    Collection下面有两个重要的子接口 List 和 Set

    List 接口：
	Collection下面的子接口，存储数据特征： 有序的，可重复的
	有两个比较重要的实现类:
		ArrayList    LinkedList
Set  接口:
	Collection下面的子接口，存储数据特征:  无序的，不可重复的
	有两个比较重要的实现类:
		HashSet   TreeSet

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    3.2Collection接口

    学习Collection这个接口，其实就是在学习这个接口下面的方法

    这些方法咋调用啊？接口不能直实例化？咋办？

    借助于ArrayList即可，用多态

    

    • 1
  • 相关阅读:
    《ClickHouse原理解析与应用实践》知识梳理
    在Ubuntu中设置中文输入法的步骤
    git log 用法
    洛谷C++简单题小练习day21—梦境数数小程序
    Isoperimetric inequality
    VMware17Pro虚拟机安装macOS教程(超详细)
    力扣-H指数
    818专业课【考经】—《信号系统》之章节概要：第五章 连续时间信号的变换域分析
    JavaWeb---实验课---第8章 EL-JSTL
    MYSQL 最朴素的监控方式
  • 原文地址：https://blog.csdn.net/m0_46202060/article/details/133063482