A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

本帖最后由 小石姐姐 于 2018-4-20 09:14 编辑

Object,System,日期,包装类,Object类


  • Object是所有类的根类(上帝)
  • 所有类都直接或间接继承了Object类
  • class  Students{} :Student默认继承了Object类
  • class Student  extends  Person{}:Student继承了Person类,Person类继承了Object类

    • String  toString():返回该对象的字符串表示,如com.itheima.Student@120D83


String toString()源代码:    return getClass().getName()+"@"+Integer.toHexString(hashCode());
getClass():返回一个字节码对象
Integer.toHexString:返回指定参数的十六进制字符串形式
hashCode():返回该对象的哈希码值(内部地址)
重写toString方法:快捷键   Ctrl + Shift + s →  Generate toString()...            
Object的equals方法
  • boolean   equals(Object  obj)

  • 使用  == 来比较两个对象是否相等,则比较地址值是否相等
  • 需要重写
  • 重写方法快捷键:Alt +Shift +s → 有个equals方法


获取字节码对象的3种方式方式  1
  • Object类的Class  getClass()方法


示例:Class  clazz= student.getClass();
方式  2
通过类名调用.Class属性来获取
示例:Class   clazz = Student.class;(后面的class  c小写)
扩展:实际上.Class是一种特殊形式,称为类字面常量,Class是关键字不能作为属性名,且Object类中并没有定义这个属性
方式  3
通过Class类的静态方法:forName(String    className)来获取
示例 :Class   clazz  =  Class。forName ("come.itheima.Student");
注意:因为该方法使用字符串来寻找类,有可能并没有该字符串对应的类,所以会抛出ClassNotFoundException类无法找到的异常

         //创建Student对象
        Student  s1 = new Student();
        //对象s1去调用
        Class  clazz1 = s1.getClass();
        //类名Student调用
        Class  clazz2 = Student.class;
        //方法调用Class.forName
        Class  clazz3 = Class.forName("上课01.Student");
        //对比是否一样
        System.out.println(clazz1  ==  clazz2);
        System.out.println(clazz1  ==  clazz3);
        System.out.println(clazz2  ==  clazz3);
注意:
同一个类的字节码对象只有一个,地址值是相同的
System类
  • java.lang包下,不用导包就可以使用
  • System类:包含一些有用的类字段和方法,它不能被实例化
    类字段:静态成员
    ​        err:标准错误输出流
    ​        in:标准输入流
    ​        out:标准输出流


常用静态方法(复制数组)

  • static  void  arrayCopy(Object src,int  srcPos,Object dest, int destPos, int length);


复制源数组中指定长度个元素到一个新数组中
复制数组
  • static  void  arraycopy  (Object src,int  srcPos,Object dest, int destPos, int length)
    src :源数组 (从那个数字中读取数据,就传入那个数组)(被复制的数组)
    srcPos :指定从哪个索引位置开始复制(如果给0 ,那就从0 后面的元素全部复制)
    dest :目标数组(这是从源数组复制到一个新的数组中(目标数组))(要复制到的数组)
    destPos :指定目标数组接受元素的索引位置(想从那个索引开始,就写成那个索引)
    length :目标数组接受元素的个数(新数组接受几个,就写几) (要复制的元素个数)


返回当前系统时间
  • static  long  currentTimeMillis()


终止虚拟机的运行
  • static  void  exit (int   status)
  • System.exit(0);这是终止程序运行,常用在if判断语句里


System类的其他方法static long currentTimeMillis()方法
  • static  long  currentTimeMillis():返回当前系统(以毫秒值返回当前系统时间)
    1000毫秒  =  1秒
    如果系统时间1970 - 1 - 1     0  :0:1      1000(如果是一秒,就返回1000毫秒)
    如果系统时间1970 - 1 - 1     0  :1:0     1000 * 60(如果是一分钟,就返回1000*60)
    如果是一小时一分钟:1000  *  60  *  60  + 1000  *  60


例题  ↓
​        long  now  = System . currentTimeMillis();   syso( now );
  • static  void  exit (int   status):终止虚拟机的运行(不是零就表示异常终止,零表示正常终止  )
  • System . exit (0); (直接输入)(比如全名有个if判断,一个数 == 多少的时候,就终止虚拟机的运行(也就是终止程序的运行))
  • Data :表示特定的瞬间,精确到毫秒,他可以通过方法来设定自己所表示的时间,可以表示任意的时间
  • static  long  currentTimeMillis():返回当前系统(1970-1-1到至今的毫秒数)

数组
  • static  long currentTimeMillis()


Date类的概述和构造
  • 注意导包:java.util.Date


  • 表示特定的瞬间,精确到毫秒,他可以通过方法来设定自己所表示的时间,可以表示任意的时间
  • System.currentTimeMillis():返回的是当前系统时间,1970-1-1至今的毫秒数


构造方法
Date():创建Date对象,并表示当前系统时间的Date对象

Date(long  timestamo):根据指定的时间,创建Date对象
成员方法
String toLocalString():转换为本地时间格式的字符串
  • 已过时


Date类的常用方法成员方法
void  setTime(long  time):设置Date对象的时间
long  gettime():获取Date对象中保存的时间毫秒值
  • 注意:无论何时调用,都是获取Date对象中已经储存的那一瞬间的时间,而不是调用方法时的时间。


常用方法毫秒值  ----   Date(毫秒值转成Date对象)
设置        返回值是void,参数类型  long            
第一种方法
void   setTime ( long time   (1970-1-1加上你给的值,比如1000或者 1000*60) )  要以毫秒的形式填入
  • 第一种方法
  • void   setTime ( long time   (1970-1-1加上你给的值,比如1000或者 1000*60) )  要以毫秒的形式填入


第二种方法
Date(long  date);
toLocaleString() :这是在控制台显示时间,前面要有变量 比如 d.toLocaleString()
Date  d  =  new Date();   括号里什么也没写,就是当前时间(前提需要导入java . util .Date;包,里面写了参数就是从1970-1-1,到你写的数值(注意是毫秒))
Date   ---   毫秒值(Date对象转成毫秒值)SimpleDateFormat的概述构造方法
SilmpleDateFormat():使用默认的格式进行对象的构建
SilmpleDateFormat(String  pattern):创建对象同时指定格式
成员方法
  • String   format(Date   date)  :将Date对象格式化为字符串


  • Date  parse(String  source):


格式化:  Date  ------→   String                    日期变成字符串
​                2018-4-9   ------→   2018年4月9日
  • String   format(Date   date)
    析: String  ------  Date                                字符串变成日期

        “2018-4-9”
  • Date  parse(String  source)


字符
y年    M月   m分    D年中的天   d:月中的天   H:小时(24时制) k:小时(12时制)
S:毫秒    s:秒   E:星期
示例 yyy-MM-dd               2018-04-09
Calendar:日历
提供了一些操作年月日时的方法
创建对象:Calendar  c  =  Calendar.getInstance();
方法获取   get修改   set添加   add
静态字段:
static         YEAY:年份
static        MONTH:月份,注意月份数值时0-11
static        DAY_OF_MONTH:日期
static        H
成员方法
int get :返回给定体力字段的值
包装类的概述和基本使用包装类
  • 封装了基本数据类型的类,提供了更多的方法和变量
  • 把基本数据类型的使用方式转换为面对对象的使用方式
  • 基本数据类型和引用数据类型的对应关系
    ​        byte:  Byte                                     long :Long
    ​        short:Short                                        float :Float
    ​        char:Character                                double:Double                        
    ​        int : Integer                                        boolean:Boolean                        


Integer类的转换方法
String  ------>  int
​        方式一:int  intValue();
​        方式二:String int  parseInt(String s) 例题: int 变量 = 类名.psrseLnt(“10”)
int   ------> String
​        方式一:加 双引号 “ ”
​        方式二:String  toString();
构造方法
integer(int value);int转integer
integer(String  s);String转integer
自动装箱
  • 基本数据类型可以自动转换为包装类
  • integer   i  = 10;这就是自动装箱
  • int  a   = i;  这是自动拆箱


自动拆箱
  • 包装类可以自动转换为基本数据类型
  • int  a  = i.intValue();


自动装箱拆箱的应用场景
  • 集合存储基本数据类型就是自动装箱,本质上集合中储存的都是引用数据类型


正则表达式
  • 概念:一种用于匹配字符串的规则
  • 可用于半段字符串是否符合某种规则,比如是否是邮箱,是否是手机号等等


Pattern类(API查看)
创建正则表达式模板,内有正则表达式规则
常用规则
字符
x : 一个字符x
\\   :表示\反斜杠.
Greedy数量次(API查看)判断字符串中间的字符是否是元音字母(aeiou)String类
boolean类型接受 = 变量名.matches (String regex):是否匹配指定的正则

String [ ] split (String  regex):按照正则表达式分割字符串(按逗号分割那个)
转义:
  • 转移使用  \  ,正则中有的
  • 常用规则(查看API中的Pattern类)


切割字符串
类名.split(“  逗号或者空格等等,多个相同的,例如空格加   + ”);
Collection< E >接口常用的功能
(单列集合体系的顶层)
集合的体系结构
由于不同的数据结构(数据的组织,储存方式),所以就有了Collection
常用方法
(boolean)增加元素: add        
(boolean)删除元素:remove 清空元素:clear                    
(boolean)判断集合中是否包含指定元素 contains(boolean)判断是否为空 isEmpty           
返回集合中元素个数 size将集合转换成一个Object类型的数组 Object [ ] 数组名 = 集合名.toArray        获取集合的迭代器 :iterator
List接口
是Collection的子接口
(有序,可重复,有索引)
​        增 add   删 remove  改 set  查 get
​        Listiterator:获取List特有的迭代器对象
ArrayList
​                        ArrayList类(底层是数组,查询快,增删慢)
LinkedList
​                         LinkedList类(底层是链表,查询慢,增删快)
​                                addFirst:添加到元素开头
​                                addLast:添加到元素末尾
​                                增   删  改  查       后面加First 是开头   后面加Last是末尾
迭代器
创建对象 :   Collection   c  = new  ArrayList();子类指向父类,多态
需要导包:import  java.util.Iterator;
iterator接口
​                iterator:获取List特有的迭代器对象,可以用来遍历集合
​                next:返回下一个元素
​                remove:从迭代器指向collection中移除迭代器返回的最后一个元素
​                hasNext:判断是否有元素获取(使用while循环)
并发修改异常
​        错误:ConcurrenModificationException
发生原因
迭代器依赖于集合,相当于集合的一个副本,当迭代器在操作的时候,发现和集合不一样,则抛开异常
解决方案
在使用迭代器遍历的时候使用迭代器修改
List接口中  ListIterator 获取与List的迭代器,然后调用ListIterator 的add方法
//创建List对象,子类指向父类
List list = new ArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("java");
        //把List对象转为ListIterator迭代器
        ListIterator i = list.listIterator();
        //循环遍历迭代器
        while (i.hasNext()) {
            //判断里面有没有 “Java”
            if (i.next().equals("java")) {
                //用迭代器添加d
                i.add("android");
            }
        }
        System.out.println(list);
泛型&增强for
泛型:是一种广泛的类型,把明确数据工作提前了编译时期,借鉴了数组的特点
泛型好处
避免了类型转换的问题
可以减少黄色警告线
可以简化我们代码的书写
什么时候使用泛型
查看API文档的时候,看到   < E >  的时候,就可以使用泛型  

         //创建集合
        Collection<Student> c = new ArrayList<Student>();
        //创建元素对象
        Student s = new Student("张三", 18);
        Student s2 = new Student("lisi", 19);
        //添加元素对象
        c.add(s);
        c.add(s2);
        //遍历集合对象
        Iterator<Student>  it = c.iterator();
        while(it.hasNext()){
            /*String string= (String)it.next();
            System.out.println(string);*/
            Student stu = it.next();
            System.out.println(stu);
        }
        
泛型的类型擦除
泛型知识一种安全检测机制,只在编译时期有效
当源代码便以为Class字节码文件后,代码中是不存在泛型的,这称为泛型的类型查出
所以,集合本质能够储存Object类型是没有因为添加了泛型而发生改变的
泛型的定义位置
类:class  类名< 泛型 >
接口:interface  接口名< 泛型 >
方法:public <泛型为C(也可以是别的)> void 类名(C  c){}
​            public  < 泛型  C >     C   eat(C  c){}    //但会泛型对象
静态方法: public   static  < C >  void  eat  {C   c}
泛型的边界
< ? > :通配符泛型(表示不知道是什么泛型)没用,只能存储null
< ? extends T >:上界通配符,
传入对象可以使用E类型及其子类对象
例题: List  < ? extends  Animal >,表示可以存入Animal及子类对象
< ? super T >:下界通配符
传入的对象可以使用E类型及其父类对象
例题:  List< ? super Dog>,表示可以存入Dog及其父类对象
foreach的概述(增强for循环)作用
遍历数组和集合
for(元素类型    变量名:数组或者集合对象){
​        //可以直接使用变量
​        //每次循环都会遍历出一个元素,保存到变量名中
}
例题
int  [ ] arr = {1,2,3};
for(int  i : arr){
System.out.printLn(i);
}
注意
在增强for循环中不能修改集合,否则会出现并发修改异常
原因:增强for循环底层就是迭代器,所以不允许修改
常见数据结构数组特点
​        数组的长度一旦定义则不可改变
​        数组中的元素都有整数索引
​        数组只能存储同一类型的元素
​        数组既可以存储基本数据类型,也可以存储引用数据类型
查找快,增删慢
ArrayList
链表
由链子链接起来的一堆结点
LinkedList
结点
地址值,值,下一个节点地址值
特点
查询慢,增删快
栈和队列
先进后出(FILO ,First  in   Last  Out)(子弹弹夹原理)
或者后进先出(LIFO  , Last   in   First   Out)
队列
先进先出(FIFO  , )(排队)
List的特点和特有功能
list接口(列表对象)
继承自Collection 接口,在java.util包下
特点
有序的(存储和读取的顺序是一致的)
有整数索引
允许重复的
特有功能
(都是List对象下的)
增        add(int  index  ,E  element):在指定索引位置添加指定元素
查        get (int  index):根据索引返回元素
删         remove (int   index):删除指定元素并返回
改        set(int  index , E  element):将指定索引位置上的元素替换为指定元素
List的常用子类
ArrayList :(底层是数组)查找快,增删慢
LinkedList :(底层是链表)查询慢,增删快
查询多,增删少,使用ArrayList , 如果查询少,增删多,使用LinkedList
不知道用啥的时候,用ArrayList
LinkenList
LinkedList常用功能:
​                                addFirst:添加到元素开头
​                                addLast:添加到元素末尾
​                                增   删  改  查       后面加First 是开头   后面加Last是末尾
HashSet集合
HashSet< String >  sss =  new  HashSet< String >( );创建对象
特点
  • 元素无序(存入和取出的顺序不一致)
  • 元素不能重复
  • 没有索引


遍历方法
HashSet的add()方法,首先会使用点钱集合中的每一个元素和新添加的元素进行hash值比较
从Sutdent这个类newSutdent的时候,new了一个新的地址值,所以就算你存入的值(张三,18)一样,但是你new的地址值不一样,所以还是会都添加到HashSet对象中
所以要用 “地址值” 或者使用equals()方法比较
第一种:迭代器       Iterator
第二种:增强                foreach
第三种:        传入数组 (就变成了数组了)
在写一个class类的时候,里面写 get /set    ,  全参,无参  , toString  ,                                                    hashCode    /    equals    全写在里面!!!!!!!!!!!
如何判断重复
HashCode( )                这个比较的是地址值
equals( )                这个比较的是值
如果直接添加HashSet对象里面,就不用了(没有别的泛型的时候比如(Student))
Collections工具类区别
Collection 是集合体系的最顶层,包含了集合体系的共性
Collections  是一个工具类,是私有的,全是static修饰的,方法都是完全用于操作Collection的
方法
  • binarySearch(List list ,Object  key):使用二分查找指定元素在指定列表的索引位置(这个元素必须是排好顺序的)
  • fill(List list,Object  obj):使用指定的对象填充列表的所有元素
  • copy(List  dest  ,  List  src): 将源列表中的数据复制到目标列表
  • (注意:目标列表的长度至少等于源列表的长度)
  • reverse(List  list):  反转集合中的元素
  • shuffle(List  list):  傻否,随机置换(随机打乱集合中的元素的顺序)
  • sort(List < T > list):  按照列表中元素的自然顺序进行排序(正序)
  • swap(List  list , int  i  , int  j): 将指定列表中的两个索引进行位置互换


自然顺序:元素具有比较性
A - Z    a  -  z   0  -  9
自定义的对象,需要自己手动用方法排序
斗地主案例
练习模拟斗地主发牌的案例定义String[]数组, 存储4种花色定义String[]数组, 存储13个牌面值定义ArrayList, 作为牌盒为3个选手分别定义ArrayList, 作为手中的牌的集合牌盒加入以上牌和大小王, 调用Collections的shuffle方法洗牌发牌时, 留3张底牌, 每人发17张牌, 最后查看底牌和每个人的牌
package 上课02;

import java.util.ArrayList;
import java.util.Collections;

public class Test2 {
    public static void main(String[] args) {
        //花色
        String [] color ={"黑桃","红桃","方片","梅花"};
        //数字
        String [] num = {"A","1","2","3","4","5","6","7","8",
                "9","10","J","Q","K"};
        //牌盒
        ArrayList<String> 牌盒 = new ArrayList<>();
        
        //遍历数组,存到集合
        for(int  x= 0 ; x < color.length ; x++){
            for(int  y = 0; y<num.length;y++){
               
                牌盒.add(color[x] + num [y]) ;
            }
        }
        牌盒.add("大王");
        牌盒.add("小王");
        //洗牌
        Collections.shuffle(牌盒);
        
        //赵三个牌友
        ArrayList<String> 热巴 = new ArrayList<>();
        ArrayList<String> 千玺 = new ArrayList<>();
        ArrayList<String> 王俊凯 = new ArrayList<>();
        //发牌
        for (int i =0; i < 牌盒.size()-3; i++) {
            /*
             * i = 0 ;i % 3 = 0;
             * i = 1 ;i % 3 = 1;
             * i = 2 ;i % 3 = 3;
             *  
             */
            if(i % 3 == 0){
                热巴.add(牌盒.get(i));
            }
            else if (i % 3 == 1){
                千玺.add(牌盒.get(i));
            }
            else if (i % 3 == 2){
                王俊凯.add(牌盒.get(i));
            }
        }
        System.out.println("热巴"+热巴);
        System.out.println("千玺"+千玺);
        System.out.println("王俊凯"+王俊凯);
        //三张底牌
        for(int x = 牌盒.size()-3;x<牌盒.size();x++){
            System.out.println("底牌"+牌盒.get(x));
        }
        
    }
}
Map接口
双列集合体系的顶层,以键值对方式储存,键不可重复,值可以重复
key-value(键值对)方式,一个键对应一个值
创建多态对象
Map< String  , String  > map = new HshMap <>();
储存在里面的值是什么类型的,别的或者自定义的也许
方法映射功能
put(K  key,V value):将key映射到value,如果key存在,则覆盖value,并将原来的value返回
获取功能
get (Object  key):根据指定的key返回key
size():返回对应关系的个数
删除功能
clear():        清除  :清空所有的对应关系
remove(Object  key):        删除 :根据指定的key删除对应关系,并返回key所对应的值,如果没有删除则返回null
判断功能
isEmpty():判断集合是否为空(没有任何键值对)false就是不为空,true就是为空
containsKey(Object key):判断指定key是否存在(boolean)
contionsValue(Object value):判断value是否存在(boolean)
遍历功能
Set < Map.entry < K , V>> entrySet ( )

Set< K > keySet ( )
        Collection< V >  values ( )
获取所有的方法获取key和values
Set < K > keySet():取出key的键
例题:Set < 类型(String)>  变量名字  =  map.keySet ( ) ;
Collection< V > values ( )  :取出values的值
例题:Collection  < 类型(String)>   变量名子 =  map.values ( ) ;
获取所有值
第一种

package 上课02;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Test005 {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("谢霆锋","张柏芝");
        map.put("程冠希","陈欣彤");
        map.put("李亚鹏","王菲");
        
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
                String string = map.get(key);
                System.out.println(key +"--"+ string);
        }
    }
}
第二种
entrySet():全部取出,然后封装起来

package 上课02;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/*
* Map的第二种遍历方式
*  class  结婚证<K , V >{
*      K 丈夫;
*      V 媳妇
*  }
*/
public class Test06 {
    public static void main(String[] args) {
        //创建Map对象
        Map<String, String> map = new HashMap<>();
        //添加映射关系
        map.put("张三", "张三媳妇");
        map.put("李四", "李四媳妇");
        map.put("王五", "王五媳妇");
        //获取所有的结婚证对象
    Set<Entry<String, String>> entrys = map.entrySet();
        //遍历包含了结婚证对象的集合
        for (Entry<String, String> entry : entrys) {
            //获取每个单独的结婚对象
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key +"---"+value);
        }
    }
}
可变参数
可变参数:当参数不确定的时候,类型要明确,Java可以把多个参数直接帮我们转成数组
格式
类型  .   .   . 变量名         
这是形参(可以在方法传形参的时候用) :类型  .   .   . 变量名                          比如:int  . . .  sun       遍历还是像数组那样
实参 :一个参数一个参数的传                        比如:sun(1,2,3,4.。。)
元素排序
TreeSet类:元素可以排序
LinkedHashSet类:具有HashSet的元素不可重复的特点,而且还能不改变顺序
Set< Character > se = new LinkedHashSet<>();


异常
异常包含了错误的类型,原因以及位置
ArithmeticException:冒号后面是异常的原因(数学异常)
异常体系结构
Throwable :异常的超类(顶层)
​                   |_   Error:出现的不能够处理的严重问题
​                   |_   Exception:可以处理的问题        # 编译时异常:编译时期就会发生的异常
​                          |_   RuntimeExceptio   # 运行时异常:编译时正常,运行时才会发生异常
常见异常
NullPointerException
ArrayIndexOutOfBoundExceptio
at后面自己的包名,类名,方法名,行数
异常处理方式JVM默认处理方式
如果出现异常我们没有处理,JVM会帮我们进行处理,把异常类型,原因和位置显示在命令行,并且还终止了程序,异常后面的代码将不在执行
try...catch处理方式    try{
        可以有多行代码
        有可能出现问题的代码;
}catch ( ArithmeticException ae (异常类型  异常对象名)) {
        处理异常;
}

try{
}catch( ArithmeticException |Exception ae(里面可以写两个异常类型,用单或|) ){
    处理异常;(系统繁忙,请稍后再试)
}
try...catch的执行顺序:
首先执行try语句
​        如果发现异常,异常下面的代码不在执行,直接跳入catch语句,catch语句结束后,整个try...catch结束,
​        如果没有出现异常,try语句执行结束后,try...catch直接结束,不再执行catch语句
手动处理异常的2中方式
1:捕获异常并处理:
2:直接抛出异常:
异常的抛出处理方式
处理不了的时候,我们就抛出异常,谁调用方法,谁处理异常
throws:
在方法名()throws 异常类型{ }
Throwable顶层常用方法
​    getMessage():异常的原因
​    toString():异常的类型和原因
void    printStackTrace():异常的类型,原因和位置

try{
        可以有多行代码
        有可能出现问题的代码;
}catch ( ArithmeticException ae (异常类型  异常对象名)) {
        处理异常;
    syso(   ae.getMessage(); )
    syso(   ae.toString  )
        ae.printStackTrace()
}
finally的概述和应用场景
finally:组合try...catch使用,用于释放资源等收尾工作,它一定会执行
IO流处理异常 ↓
FileWrite fw = null;
try{
fw = new FileWrite("a.txt");
fw .write("hello");
这里写代码,比如输出流,
}catch( ArithmeticException |Exception ae(里面可以写两个异常类型,用单或|) ){
    处理异常;(系统繁忙,请稍后再试)
}finally{
    释放资源;
    if(!fw = null){
try{
fw. close();
   }catch(异常对象){
       e.printStackTrace();
   }
}   清理垃圾;
}
异常的分类
运行时期异常: RuntimeException的子类就是运行时期异常,在编译时期可以自由选择处理或者不处理
编译时期异常:Exception及其子类(除RuntimeException体系)在编译时期必须处理,一种抛出,一种捕获,用try...catch解决
自定义异常
throws:用于抛出编译时异常,在方法声明上使用,由调用者处理
throw:制造异常的方式,并且结束方法
自定义一个异常类:写一个类去继承Exception或者RuntimEexception,然后实现多个构造即可     throw  new      Exception();或者            throw  new      RuntimEexception();
递归
阶乘:n! = n * ( n - 1 ) !
递归:把大问题拆成小问题,小问题拆成更小的问题,一个个解决
在方法本身不断的调用方法自己
递归注意事项:
​                        递归一定要有出口,内存溢出
​                        递归次数不宜过多,内存溢出

public  static int  show(int  n){
    //出口(出口就是能够解决问题了,不用再在调用方法自己)
    if(n == 1){
        return  1;
    }
   return  n * show(n-1);
}
讲故事
从前有座山,山里有座庙,庙里有个老和尚,老和尚在给小和尚讲故事,
从前有座山,山里有座庙,庙里有个老和尚,老和尚在给小和尚讲故事,
一直讲会累死,程序也一样,所有要有出口,而且不能次数太多!!!!!!!!
例题
public static void main(String[] args) {
    int c = JC(5);
        System.out.println(c);
    }
    public static int JC(int n) {
        //出口
        if(n == 1){
            return 1;
        }
        return n * JC(n -1);
    }
斐波那契数列package 上课01;

public class 递归不死神兔 {
    public static void main(String[] args) {
        System.out.println(meth(20)); //6765
    }
    //定义方法,求第n个月的兔子数量
    public static int meth(int n) {
        //定义出口,第一个月和第二个月的兔子数量都是1
        if(n==1){
            return 1;
        }
        else if(n == 2){
            return 1;
        }else{
            //如果是其他月,计算方式是  上个月兔子数+上上个月兔子数
            return  meth(n-1)+meth(n-2);
        }
    }
}





0 个回复

您需要登录后才可以回帖 登录 | 加入黑马