黑马程序员技术交流社区

标题: 【石家庄校区】学习总结1 [打印本页]

---

作者: 水煮鱼000    时间: 2019-5-7 14:44
标题: 【石家庄校区】学习总结1
一、继承继承如何实现

extends关键字。继承的意思

例：class 子类 extends 父类

继承的好处

• 提高代码的复用性
• 提高代码的维护性
  
  

继承的弊端

• 类和类之间的耦合性增强。类和类之间的关系太紧密了！如果父类提供类功能，子类需要的话，可以继承下去使用。如果子类不需要，也得要！
  
  

继承中的成员变量访问特点

访问原则

• 就近原则
  
  
  • 在子类的局部位置查找。如果有就使用。如果没有
  • 在子类的成员位置查找。如果有就使用。如果没有
  • 在父类的成员位置查找。如果有就使用。如果没有就报错了
    
    
  
  

super关键字

• 代表的是父类对象的引用。可以访问父类中的成员(成员变量、构造方法、成员方法)
  
  

继承中构造方法的访问特点

• 在子类所有的构造方法中，默认第一行都隐藏了一个super()。目的是为了调用父类的无参构造方法，先创建父类的对象，然后再创建子类的对象
• 在子类构造方法中，可以调用父类的有参构造方法。调用格式：super(参数)
  
  

继承中成员方法的访问特点

就近原则

• 如果子类有成员方法，优先使用子类的成员方法。如果子类没有
• 去父类中查找成员方法，如果有就使用。如果没有，就报错！
• 如果就想在子类中去调用父类的成员方法，使用super.父类的成员方法
  
  

方法重写的注意事项

• 子类无法重写父类的私有方法。私有方法根本不能继承
• 子类重写父类方法时，权限修饰符必须大于等于父类方法的权限修饰符(public->protected->默认->private)
• 子类重写父类方法时，子类方法的返回值类型可以是父类方法返回值类型的子类
  
  

java中继承的特点

• java中只支持单继承。不支持多继承
• 但是可以多层继承
  
  

​                        本类                相同包(子父类或无关类)          不同包(子父类)             不同包(无关类)

1.public               Y                                 Y                                          Y                            Y

2.protected        Y                                 Y                                           Y

3.默认                   Y                               Y

4.private             Y

final关键字

• 修饰类：类变成了一个最终的类，不能被继承。但是可以有父类
• 修饰成员变量：变量变成了一个常量。不可以改变
• 修饰成员方法：方法不能被重写，但是可以被继承使用
• 修饰引用数据类型：对象记录的内存地址值不能发生改变。但是对象中的内容是可以修改的
  
  

static关键字

静态特点

• 静态成员属于类的。静态成员是随着类的加载而加载。静态成员要优先于对象存在
• 静态成员可以通过类名直接访问
  
  

静态成员访问特点

• 静态成员只能访问静态的成员
• 非静态成员既可以访问静态成员，也可以访问非静态成员
  
  

使用场景

当一个成员需要被所有对象所共享使用时，就可以将其定义为静态的！

动名词法

名词是类，动词是方法；

二、多态什么是多态

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

多态的前提

• 要有继承或实现关系
• 要有方法的重写
• 要有父类引用指向子类对象
  
  

成员访问特点

• 成员变量
  ​        编译看父类，运行看父类
• 成员方法
  ​        编译看父类，运行看子类
  
  

多态好处

​        提高程序的扩展性。

弊端

​        不能使用子类的特有成员

多态中的转型

• 向上转型
  ​        父类引用指向子类对象就是向上转型
  ​        格式：父类型 对象名 = new 子类名；
• 向下转型
  ​        格式：子类型 对象名 = (子类型)父类引用;
  
  

三、抽象类抽象类的概述

​        当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！

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

抽象类的特点

抽象类和抽象方法必须使用 abstract 关键字修饰

抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

抽象类不能实例化

抽象类的子类

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

​        要么是抽象类

抽象类的成员特点

• 成员变量
  
  
  • 既可以是变量
  • 也可以是常量
    
    
• 构造方法
  
  
  • 空参构造
  • 有参构造
    
    
• 成员方法
  
  
  • 抽象方法
  • 普通方法
    
    
  
  

四、接口接口的概述

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

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

接口的特点

接口用关键字interface修饰

类实现接口用implements表示

接口不能实例化

​        接口实例化参照多态的方式，通过实现类对象实例化，这叫接口多态。

​        多态的形式：具体类多态，抽象类多态，接口多态。

接口的子类

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

​        要么子类也是抽象类

接口的成员特点

成员特点

• 成员变量
  ​         只能是常量​         默认修饰符：public static final
• 构造方法
  ​        没有，因为接口主要是扩展功能的，而没有具体存在
• 成员方法
  ​        只能是抽象方法
  ​        默认修饰符：public abstract
  
  

类和接口的关系

• 类与类的关系
  ​        继承关系，只能单继承，但是可以多层继承
• 类与接口的关系
  ​        实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
• 接口与接口的关系
  ​        继承关系，可以单继承，也可以多继承
  
  

抽象类和接口的区别

• 成员区别
  
  
  • 抽象类
    ​        变量,常量；有构造方法；有抽象方法,也有非抽象方法
  • 接口
    ​        常量；抽象方法
    
    
• 关系区别
  
  
  • 类与类
    ​        继承，单继承
  • 类与接口
    ​        实现，可以单实现，也可以多实现
  • 接口与接口
    ​        继承，单继承，多继承
    
    
• 设计理念区别
  
  
  • 抽象类
    ​        对类抽象，包括属性、行为
  • 接口
    ​        对行为抽象，主要是行为
    
    
  
  

五、内部类类名作为形参和返回值

• 类名作为方法的形参
  方法的形参是类名，其实需要的是该类的对象
  实际传递的是该对象的【地址值】
• 类名作为方法的返回值
  方法的返回值是类名，其实返回的是该类的对象
  实际传递的，也是该对象的【地址值】
  
  

抽象类作为形参和返回值

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

接口名作为形参和返回值

• 接口作为形参和返回值
  
  
  • 方法的形参是接口名，其实需要的是该接口的实现类对象
  • 方法的返回值是接口名，其实返回的是该接口的实现类对象
    
    
  
  

内部类概念

• 在一个类中定义一个类
• /*格式：   class 外部类名{           修饰符 class 内部类名{
  
  

/*
    格式：
    class 外部类名{
        修饰符 class 内部类名{
        
        }
    }
*/
​
class Outer {
    public class Inner {
        
    }
}内部类的访问特点

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

成员内部类

• 成员内部类的定义位置
  
  
  • 在类中方法，跟成员变量是一个位置
    
    
• 外界创建成员内部类格式
  
  
  • 格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
  • 举例：Outer.Inner oi = new Outer().new Inner();
    
    
• 成员内部类的推荐使用方案
  
  
  • 将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。
    
    
  
  

局部内部类

• 局部内部类定义位置
  
  
  • 局部内部类是在方法中定义的类
    
    
• 局部内部类方式方式
  
  
  • 局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用
  • 该类可以直接访问外部类的成员，也可以访问方法内的局部变量
    
    
  
  

匿名内部类

• 匿名内部类的前提
  
  
  • 存在一个类或者接口，这里的类可以是具体类也可以是抽象类
    
    
• 匿名内部类的格式
  
  
  • 格式：new 类名 ( ) {  重写方法 }  
    ​           new  接口名 ( ) { 重写方法 }
    
    
  
  

• 匿名内部类的本质
  
  
  • 本质：是一个继承了该类或者实现了该接口的子类匿名对象
    
    
• 匿名内部类的细节
  
  
  • 匿名内部类可以通过多态的形式接受
    
    
• 匿名内部类直接调用方法
  
  

interface Inter{
    void method();
}
​
class Test{
    public static void main(String[] args){
        new Inter(){
            @Override
            public void method(){
                System.out.println("我是匿名内部类");
            }
        }.method(); // 直接调用方法
    }
}匿名内部类在开发中的使用

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

• 当发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码
  
  

六、常用APIMath

• 1、Math类概述
  
  
  • Math 包含执行基本数字运算的方法
    
    
• 2、Math中方法的调用方式
  
  
  • Math类中无构造方法，但内部的方法都是静态的，则可以通过   类名.进行调用
    
    
• 3、Math类的常用方法
  [td]

  方法名    方法名	说明
  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)

  
  

System

• System类的常用方法
  
  

[td]

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

Object类的toString方法

• Object类概述
  
  
  • Object 是类层次结构的根，每个类都可以将 Object 作为超类。所有类都直接或者间接的继承自该类，换句话说，该类所具备的方法，所有类都会有一份
    
    
• 查看方法源码的方式
  
  
  • 选中方法，按下Ctrl + B
    
    
• 重写toString方法的方式
  
  
  • 
    
    • Alt + Insert 选择toString
      
      
  • 
    
    • 在类的空白区域，右键 -> Generate -> 选择toString
      
      
    
    
• toString方法的作用：
  
  
  • 以良好的格式，更方便的展示对象中的属性值
    
    
  
  

Object类的equals方法

• equals方法的作用
  
  
  • 用于对象之间的比较，返回true和false的结果
  • 举例：s1.equals(s2);    s1和s2是两个对象
    
    
• 重写equals方法的场景
  
  
  • 不希望比较对象的地址值，想要结合对象属性进行比较的时候。
    
    
• 重写equals方法的方式
  
  
  • 
    
    • alt + insert  选择equals() and hashCode()，IntelliJ Default，一路next，finish即可
      
      
  • 
    
    • 在类的空白区域，右键 -> Generate -> 选择equals() and hashCode()，后面的同上。
    • ​
      
      
    
    
  
  

冒泡排序原理

• 冒泡排序概述
  
  
  • 一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对所有的数据进行操作，直至所有数据按要求完成排序
    
    
• 如果有n个数据进行排序，总共需要比较n-1次
• 每一次比较完毕，下一次的比较就会少一个数据参与
  
  

Arrays

• Arrays的常用方法
  [td]

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

• 工具类设计思想
  1、构造方法用 private 修饰
  2、成员用 public static 修饰
  
  

七、包装类基本类型包装类

• 基本类型包装类的作用
  ​        将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据
  ​        常用的操作之一：用于基本数据类型与字符串之间的转换
• 基本类型对应的包装类
  [td]

  基本数据类型	包装类
  byte	Byte
  short	Short
  int	Integer
  long	Long
  float	Float
  double	Double
  char	Character
  boolean	Boolean

  
  

Integer类

• Integer类概述
  ​        包装一个对象中的原始类型 int 的值
• Integer类构造方法
  [td]

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

  String到int  Inerger.parsrlnt将字符串参数解析为带符号的十进制整数。
  
  

int和String类型的相互转换

• int转换为String
  
  
  • 转换方式
    
    
    • 方式一：直接在数字后加一个空字符串
    • 方式二：通过String类静态方法valueOf()
      
      
    
    
  
  

• ​
  
  public class IntegerDemo {
      public static void main(String[] args) {
          //int --- String
          int number = 100;
          //方式1
          String s1 = number + "";
          System.out.println(s1);
          //方式2
          //public static String valueOf(int i)
          String s2 = String.valueOf(number);
          System.out.println(s2);
          System.out.println("--------");
      }
  }
• String转换为int
  
  

• 转换方式
  
  
  • 方式一：先将字符串数字转成Integer，再调用valueOf()方法
  • 方式二：通过Integer静态方法parseInt()进行转换
    
    
  
  

• 示例代码
  
  public class IntegerDemo {
      public static void main(String[] args) {
          //String --- int
          String s = "100";
          //方式1：String --- Integer --- int
          Integer i = Integer.valueOf(s);
          //public int intValue()
          int x = i.intValue();
          System.out.println(x);
          //方式2
          //public static int parseInt(String s)
          int y = Integer.parseInt(s);
          System.out.println(y);
      }
  }
  

自动拆箱和自动装箱

• 自动装箱
  ​        把基本数据类型转换为对应的包装类类型
• 自动拆箱
  ​        把包装类类型转换为对应的基本数据类型
• 开发过程中，引用数据类型均要判断是否非null
• 示例代码
  
  Integer i = 100;  // 自动装箱
  i += 200;         // i = i + 200;  i + 200 自动拆箱；i = i + 200; 是自动装箱
  

八、时间日期类Date类

• Date类概述
  ​        Date 代表了一个特定的时间，精确到毫秒
• Date类构造方法
  [td]

  方法名	说明
  public Date()	分配一个 Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒（无参默认返回当前系统时间）
  public Date(long date)	分配一个 Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数

  toLocaleString 打印出更合适的时间形式
  
  

Date类常用方法

• 常用方法
  [td]

  方法名	说明
  public long getTime()	获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
  public void setTime(long time)	设置时间，给的是毫秒值

  
  

SimpleDateFormat类

• SimpleDateFormat类概述
  ​        SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。
  ​        日期格式化和解析
• SimpleDateFormat类构造方法
  [td]

  方法名	说明
  public   SimpleDateFormat()	构造一个SimpleDateFormat，使用默认模式和日期格式
  public SimpleDateFormat(String pattern)	构造一个SimpleDateFormat使用给定的模式和默认的日期格式

• SimpleDateFormat类的常用方法
  
  
  • 格式化(从Date到String)
    
    
    • public final String format(Date date)：将日期格式化成日期/时间字符串
      
      
  • 解析(从String到Date)
    
    
    • public Date parse(String source)：从给定字符串的开始解析文本以生成日期
      
      
    
    
• 示例代码
  
  

public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        //格式化：从 Date 到 String
        Date d = new Date();
//        SimpleDateFormat sdf = new SimpleDateFormat();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String s = sdf.format(d);
        System.out.println(s);
        System.out.println("--------");
​
        //从 String 到 Date
        String ss = "2048-08-09 11:11:11";
        //ParseException
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date dd = sdf2.parse(ss);
        System.out.println(dd);
    }
}Calendar类

• Calendar类概述
  ​        Calendar 为特定瞬间与一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法
  ​        Calendar 提供了一个类方法 getInstance 用于获取这种类型的一般有用的对象。
  ​        该方法返回一个Calendar 对象。
  ​        其日历字段已使用当前日期和时间初始化：Calendar rightNow = Calendar.getInstance();
• Calendar类常用方法
  [td]

  方法名	说明
  public int   get(int field)	返回给定日历字段的值
  public abstract void add(int   field, int amount)	根据日历的规则，将指定的时间量添加或减去给定的日历字段
  public final void set(int year,int month,int date)	设置当前日历的年月日

  
  

异常

• ​
  
  
  • 概念：不正常的现象
  • 异常的体系结构
    
    
    • Throwable
      
      
      • Error:不可处理的异常
      • Exception:可处理的异常
        
        
        • RuntimeException： 运行时异常
        • 非RuntimeException：编译时异常
          
          
        
        
      
      
  • JVM默认处理异常的方式
    
    
    • 如果程序出现了问题，我们没有做任何处理，最终JVM 会做默认的处理，处理方式有如下两个步骤：
    • 把异常的名称，错误原因及异常出现的位置等信息输出在了控制台
    • 程序停止执行
      
      
  • try:异常监视块
  • catch():捕获块
  • 执行流程
    
    
    • 程序从 try 里面的代码开始执行
    • 出现异常，就会跳转到对应的 catch 里面去执行
    • 执行完毕之后，程序还可以继续往下执行
      
      
    
    
• Throwable成员方法
  
  
  • getMessage() 异常字符串
  • toString()简短异常消息
  • printStackTrace():详细异常消息
    
    
• 运行时异常和编译时异常
  
  
  • 运行时异常：无需显示处理
  • 编译时异常：必须显示处理
    
    
• throws 抛出异常
  
  
  • 概念：回避异常
    
    
• 自定义异常
  
  
  • 步骤
    
    
    • 自定义一个类继承自Exception
    • 构造方法-> super(message)
    • throw
      
      
    
    
  
  

自定义异常

• 自定义异常类
  
  public class ScoreException extends Exception {
  ​
      public ScoreException() {}
  ​
      public ScoreException(String message) {
          super(message);
      }
  ​
  }
• 老师类
  
  public class Teacher {
      public void checkScore(int score) throws ScoreException {
          if(score<0 || score>100) {
  //            throw new ScoreException();
              throw new ScoreException("你给的分数有误，分数应该在0-100之间");
          } else {
              System.out.println("成绩正常");
          }
      }
  }
• 测试类
  
  public class Demo {
      public static void main(String[] args) {
          Scanner sc = new Scanner(System.in);
          System.out.println("请输入分数：");
  ​
          int score = sc.nextInt();
  ​
          Teacher t = new Teacher();
          try {
              t.checkScore(score);
          } catch (ScoreException e) {
              e.printStackTrace();
          }
      }
  }
  

九、集合Collection

集合概念及体系结构

• 概念：可变长度数据容器
• 体系结构：
  
  
  • 单列：Collection
    
    
    • 可重复：List   抽象类，有序的，可重复
      ​                ArrayList
      ​                 LinkedList
    • 不可重复的:Set
      ​                     HashSet
      ​                     TreeSet 可自然排序可用比较器排序，不可重复
      ​                     LinkedHashSet有序的，不可重复的
      
      
  • 双列：Map HashMap
    
    
  
  

Collection的概述和基本使用

• 创建Collection接口对象的方式:Collection c=new  ArrayList();多态创建
• 添加数据:add()
  
  

Collection集合的常用方法

• 添加:add(Object j)
• 删除:remove(Object j)
• 清除：clear()
• 判断是否为空:isEmpty()
• 判断某个对象是否在集合存在:contains(Object j)
• 长度:size()
  
  

Collection集合遍历

• 如何去获取迭代器:调取iterator()   
• 判断是否还有元素：hasNext()
• 取出对象:next()
  
  

List

list集合的概述和特点

• 有序（有索引）
• 可重复
  
  

• list集合特有方法
  
  
  • 读取:get(i)返回指定索引处的元素
  • 添加:add(i,object)在此集合中的指定位置插入指定的元素
  • 指定位置替换数据：set(i,object)修改指定索引处的元素，返回被修改的元素
  • 删除:remove(i)删除指定索引处的元素，返回被删除的元素
    
    
• 集合并发问题及ListIterator用法
  
  
  • iterator():循环时不能修改集合数据，若修改则会出现异常：ConcurrentModificationException
  • listIterator()  可以对集合进行修改，也可反向遍历集合   add() remove()
    
    
• 增强for循环
  
  
  • 语法格式:for（元素数据类型 变量名:集合或数组）
    
    
• 数组和链表的区别
  
  
  • 数组特点:查询块,增删慢---》ArrayList
  • 链表的特点:增删快，查询慢---》LinkedList
    
    
  
  

LinkedList

LinkedList特有方法

• 添加: addFirst()  addLast()
• 删除:removeFirst()  removeLast()
• 获取:getFirst()  getLast()
  
  

Set

• Set集合的特点
  
  
  • 存取无序
  • 没有索引，只能通过增强for或迭代器遍历
  • 不能重复的元素
    
    
• Hash值的概念
  
  
  • 哈希值简介
    ​        是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
  • 如何获取哈希值
    ​        Object类中的public int hashCode()：返回对象的哈希码值
  • 哈希值的特点
    
    
    • 同一个对象多次调用hashCode()方法返回的哈希值是相同的
    • 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同
      
      
    
    
  
  

• 概念：整数值
  
  

• HashSet集合的特点
  
  
  • 无序(没索引)
    
    
    • 底层数据结构是哈希表
    • 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
    • 没有带索引的方法，所以不能使用普通for循环遍历
      
      
  • 由于是Set集合，不能重复的元素
  • 低层实现是hash表
    
    
• LinkedHashSet集合的特点
  
  
  • 不能重复的元素
  • 由链表保证元素有序，元素的存储和取出顺序是一致的
  • 由哈希表保证元素唯一，也就是说没有重复的元素
  • 能够按照存储的顺序读出数据
    
    
• TreeSet集合的特点
  
  
  • 不能重复的元素
  • 能够按照自然顺序排序TreeSet()
  • 能够按照我们指定方式排序TreeSet(Comparator c)
    
    
    • 第一种方式：自定义类
      
      
      • 实现java.lang.Comparable<Student>
      • 重写compareTo(Student t)
      • 返回一个int    >0 当前对象大      ==0相等      <0 当前对象小
        
        
    • 第二种方式：通过匿名内部类传给TreeSet的构造函数
      
      
      • 实现java.util.Comparator
      • 重新compare（Student t1，Student t2）
      • 返回一个int    >0 当前对象大      ==0相等      <0 当前对象小
        
        
      
      
    
    
• 泛型的概念及好处
  
  
  • 概念：参数化类型
  • 类型检查，编译
  • 把运行时期的问题提前到了编译期间
  • 避免了强制类型转换
    
    
• 泛型举例
  
  
  • 泛型类
    
    public class Generic<T> {
        private T t;
    ​
        public T getT() {
            return t;
        }
    ​
        public void setT(T t) {
            this.t = t;
        }
    }
    ​
    
    • 泛型方法
      
      public class Generic {
          public <T> void show(T t) {
              System.out.println(t);
          }
      }
      
  • 泛型接口
  • 
    public interface Generic<T> {
        void show(T t);
    }
    public class GenericImpl<T> implements Generic<T> {
        @Override
        public void show(T t) {
            System.out.println(t);
        }
    }
    ​
    
    • 类型通配符
      
        //类型通配符：<?>
              List<?> list1 = new ArrayList<Object>();
              List<?> list2 = new ArrayList<Number>();
              List<?> list3 = new ArrayList<Integer>();
      ​
              System.out.println("--------");
      
    
    
  
  

           //类型通配符上限：<? extends 类型>
   //        List<? extends Number> list4 = new ArrayList<Object>();
           List<? extends Number> list5 = new ArrayList<Number>();
           List<? extends Number> list6 = new ArrayList<Integer>();
​
​
           System.out.println("--------");
​
           //类型通配符下限：<? super 类型>
           List<? super Number> list7 = new ArrayList<Object>();
           List<? super Number> list8 = new ArrayList<Number>();
           list8.add(new Integer(5));
   ```

• 可变参数
• 可变参数
  
  
  • public void test(int ...i)
  • for(int ii:i){}
    
    
• 可变参数举例
  
  
  • Aarrays.asList()返回由指定数组支持的固定大小的列表，返回的集合不能做增删操作，可以做修改操作
  • List.of()返回包含任意数量元素的不可变列表，返回的集合不能做增删改操作
  • Set.of()返回一个包含任意数量元素的不可变集合，在给元素的时候，不能给重复的元素
    
    
  
  

Map

• map集合的概述和特点
  
  
  • 健值对方式存储数据
  • 一个键对应一个值
  • 健不允许重复，值可以重复
  • 无序
    
    
• map集合常用方法
  
  
  • 添加:put(key,value)
  • 删除:remove(key)
  • 清除:clear()
  • 判断健是否存在:containsKey(key)
  • 判断值是否存在:containsValue(value)
  • 是否为空:isEmpty()
  • 长度:size()
    
    
• map结合读取数据方法
  
  
  • 获取单个元素：get(key)
  • 获取所有健:keySet()
  • 获取所有的值:values()
  • 获取健和值的集合:entrySet()      Map.Entry<k,v>
    
    
• Collections常用方法
  
  
  • 排序:sort()
  • 反转:reverse()
  • 洗牌:shuffle()使用默认的随机源随机排列指定的列表
    
    
  
  

十、IO流File类

• File类的概述和构造方法
  
  
  • 概念:文件和目录的抽象表示
    
    
    • 文件和目录是可以通过File封装成对象的
    • 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。
      
      
  • 构造方法
    
    
    • new File("完整路径")；（主要用此方法）
    • new File("目录"，“文件”)；
    • File file1=new File("目录") File file2=new File(file1,"文件")；
      
      
    
    
• File类创建类方法
  
  
  • 创建文件:createNewFile();
  • 目录:mkdir() ;
  • 多级目录:mkdirs()
    
    
• File类的判断和获取方法
  
  
  • 判断是否是目录:isDirectory()
  • 判断是否是文件:isFile()
  • 判断文件或目录是否存在:exists()
  • 名字:getName()
  • 相对路径:getPath()
  • 绝对路径:getAbsolutePath()
  • 获取目录下文件名数组:list()
  • 获取目录下文件对象数组:listFiles()
    
    
• File类删除
  
  
  • 删除文件:delete（）删除目录时，目录必须为空
    
    
• 递归的介绍
  
  
  • 以编程的角度来看，递归指的是方法定义中调用方法本身的现象
  • 把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解
  • 递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算
    
    
  递归的注意事项
  ​        递归一定要有出口。否则内存溢出
             递归虽然有出口，但是递归的次数也不宜过多。否则内存溢出
  
  public class DiGuiDemo01 {
      public static void main(String[] args) {
          //调用方法
          int result = jc(5);
          //输出结果
          System.out.println("5的阶乘是：" + result);
      }
  ​
      //定义一个方法，用于递归求阶乘，参数为一个int类型的变量
      public static int jc(int n) {
          //在方法内部判断该变量的值是否是1
          if(n == 1) {
              //是：返回1
              return 1;
          } else {
              //不是：返回n*(n-1)!
              return n*jc(n-1);
          }
      }
  }
  

IO流

• 流概述
  
  
  • IO：输入/输出(Input/Output)输入流   输出流
  • 流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输
  • IO流就是用来处理设备间数据传输问题的。常见的应用：文件复制；文件上传；文件下载
  • 工作方式：字节流 字符流
    
    
• IO流的使用场景
  
  
  • 如果操作的是纯文本文件，优先使用字符流
  • 如果操作的是图片、视频、音频等二进制文件。优先使用字节流
  • 如果不确定文件类型，优先使用字节流。字节流是万能的流
    
    
• 字节流写数据
  
  
  • 字节输出流:OutPutStream()  这个抽象类是表示字节输出流的所有类的超类
    ​                    FileOutPutStream("文件的路径") 子类，子类名称都是以其父类名作为子类名的后缀
  • 字节形式写数据:write() 返回字符
    ​                            write(byte[])  返回数组长度
    ​                            write(byte[],off,len)
  • 释放资源:close()
    
    
• 字节流写数据的两个小问题
  ​        换行
  
  
  • windows:\r\n
  • linux:\n
  • mac:\r
    不覆盖，追加写入
  • 如何进行追加写:new FileOutPutStream("文件的路径",true)
    异常处理
  • 
    finally try catch后必须要执行的代码块，做关闭资源的操作
    
• 字节流读取数据
  
  
  • 字节输入流对象:InputStream() FileInputStream("")
  • 读数据的方法:read()     当-1时代表文件到结尾   read(byte[])返回值实际读取数据的长度，-1代表数据读取完成
  • 释放资源:close()
    
    
  
  

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2