12、 递归、泛型、增强for循环、方法重写

一、递归

• 递归：方法内部调用方法本身。

• 递归注意事项：
  a: 递归一定要有出口，否则会发生死循环；
  b: 递归的次数不宜过多，不然有可能会发生内存溢出；
  c: 构造方法不能递归调用。

• 递归方法使用思路
  a: 寻求方法的出口；
  b: 找规律，

• 递归方法的使用

  • 1、递归获取目录下所有的指定后缀的名称
    思路：
    a 封装目录 file构造函数
    b 获取目录下所有文件及文件夹的对象数组
    c 遍历对象数组获取每个对象
    d 对对象进行判断
    e 如果是文件夹则返回调用方法。
    f 如果是文件，则判断是否是java结尾，如果是则输出。

  • 2、递归删除带内容的目录
    思路：
    a 封装目录 file构造
    b 获取目录下所有文件及文件夹的对象数组
    c 遍历对象数组获取每一个对象
    d 对对象进行判断，
    e 如果是文件夹返回调用方法；
    f 如果是文件，执行删除操作。
    g 在for循环外进行一步删除文件夹的操作。

二、泛型

• 泛型的概述和使用
  概念：参数类型，是java1.5版本出现的新特性，它可以限定方法操作的数据类型，在定义集合类时，使用<参数化类型>的方式指定该类中方法操作的数据类型，具体格式如下：ArrayList<参数化类型>list=new ArrayList( );
• 泛型的好处
  a：解决Eclipse黄色警告线问题
  b：把运行时期的类型转换异常提前到编译期
  c：优化程序设计
  d：避免了强制类型转换的麻烦
• 泛型的使用
  泛型一般用在集合中，在类、接口、方法、等位置加入，明确使用的数据类型。
  a：泛型类

1、public class Tool2<QQ> {//泛型定义在类上
          public void show(QQ qq) {
          System.out.println(qq);
     }
}

2、public class Tool2Test {//测试类
     public static void main(String[] args) {

          Tool2<String> t = new Tool2<String>();
          t.show("hello");
          Tool2<Integer> t2 = new Tool2<Integer>();
          t2.show(10);
     }
}

b：泛型方法

1、public class Tool {
     public <BYD> void show(BYD byd) {//泛型定义在方法上
          System.out.println(byd);
     }
}

2、public class ToolTest {//泛型测试类
     public static void main(String[] args) {
          Tool t = new Tool();
          t.show("hello");//此处泛型为String类型
          t.show(10);//此处泛型为int型
     }
}

c：泛型接口：

1、public interface Inter<BMW> //泛型定义在接口上
{
     public abstract void show(BMW bmw);
  }
2、public class InterImpl<BWM> implements Inter<BWM>//实现类使用泛型
 {
     public void show(BWM bmw) //复写方法
{
          System.out.println(bmw);
     }
}
3、public class InterTest//测试类
 {
     public static void main(String[] args) 
{
          InterImpl<String> ii = new InterImpl<String>();//泛型测试
          ii.show("hello");
     }
}

• 泛型限定<？extends person>
  ？通配符（占位符）
  ？extends E：可以接收E类型与其E的子类型。//上限
  ？super E：可以接收E类型或者其父类类型。//下限

三、增强for循环

• foreach循环用于遍历数组或集合中的元素，格式：
  for（容器中的元素类型 临时变量： 容器变量）{
  执行语句；
  }
• 作用
  由于Iterator遍历集合的元素写法比较繁琐，所以采用foreach简化书写。
  注意：
  由于foreach是用来替代迭代器的，所以不能在使用增强for的时候，对集合元素进行改变，防止
  引起并发修改异常。

四、方法重写

• toString()方法重写
  public String toString() {
  return "Student [age=" + age + ", name=" + name + "]";
  }
• equals（）方法重写

     public boolean equals(Object obj) {
            //为了提高代码效率
            if( this== obj){
                 return true;
           }
           
            //为了提高程序的健壮性
            //加一个判断：判断传递过来的对象是否是Student类型的。
            //怎么判断?
            //格式：对象名 instanceof 类名 判断对象是否是该类的对象,返回boolean类型
            if(!( obj instanceof Student)){
                 return false;
           }
           
            /*
            * this -- s1
            * obj -- s2
            */
           Student s =  (Student) obj;
            //重写equals一般就是为了比较某个类的多个对象的所有成员变量值是否相同
            //如果成员变量是基本类型，就用==比较
            //如果成员变量时引用类型,就用该变量对应的引用类型的equals（）方法
            return this. age == s. age && this. name.equals( s. name);
     }