javaSE:基础知识【1】

目录

1、this、super的用法

2、static关键字

3、Math常用方法

4、 Calendar、Date、DateFormate、System、String、StringBuilder类

5、迭代器

6、异常

---

1、this、super的用法

/*this关键字访问本类内容。用法
1 在本类的成员方法中，访问本类的成员变量。
2 在本类的成员方法中，访问本类的另一个成员方法。
3 在本类的构造方法中，访问本类的另一个构造方法。即构造方法的重载调用
注意：1、 this(...)调用也必须是一个构造方法的第一个语句。也就是唯一一个。
2、 super和this不能同时使用，因为他俩都要是第一个。
*
*
*  */
public class Fu {
   int num=20;
}
  
public class Zi extends Fu {
    int num = 20;
    public Zi(){
        //有了this，不再赠送super
        this(123);//本类的无参构造，调用本类的有参构造。即构造方法的重载调用。
        //this(1,2);调用成功的只能是第一个this且唯一一个。
    }
    public Zi(int n){
        this(1,2);
    }
    public Zi(int n,int m){
        //this();如果在调用无参，三个构造方法将循环，没有尽头所以报错。
    }
    public void showNumber() {
        int num = 10;
        System.out.println(num);//局部变量
        System.out.println(this.num);//本类的成员变量
        System.out.println(super.num);//父类的成员变量
    }
    public void methodA(){
        System.out.println("AAA");
    }
    public void methodB(){
        this.methodA();
        System.out.println("BBB");
    }
}

/*super关键字用法：
1 在子类成员方法中，访问父类成员变量。
2 在子类成员方法中，访问父类成员方法。
3 在子类构造方法中，访问父类构造方法。
*  */
/*继承关系中，父子类构造方法访问特点

1 子类构造方法中有一个默认隐含"super（）"调用【默认无参】，什么都不写，则赠送一个。
写了，则调用指定的super调用。
2 子类可以通过super关键字，来调用父类重载构造。
3 super的父类构造调用，必须是子类构造方法的第一个语句。且不能一个子类构造调用多次super方法。
*  */

2、static关键字

/*
static关键字
多个对象共用一份数据；一旦使用static关键字，那么对于这样的数据不在属于对象自己，
而是属于类，所以凡是本类的对象，都共享一份。
 */
 /*static:修饰成员
 如果一个成员变量使用了static关键字，那么这个对象不在属于对象自己，而是属于所在的类。多个对象共享同一份数据。

*  */
/*static:修饰方法
一旦使用static修饰成员方法，那么就成了静态方法。静态方法不属于对象，而属于类。
所以在使用静态方法时，不需要创建对象，通过类名称直接使用。

无论是成员变量还是成员方法，有了static，都推荐使用类名称进行调用。
静态变量：类名称.静态变量
静态方法：类名称.静态方法（）
注意：1 静态不能直接访问非静态。
因为在内存中是【先】有的静态内容，【后】有的非静态内容     “先人不知道后人，后人知道先人”
2 静态方法不能有this。
因为this代表当前对象，通过谁调用的方法，谁就是当前对象。
*  */
/*静态代码块：
格式  public class 类名称
            static{
            //静态代码块内容
            }
当第一次用到本类时，静态代码块执行唯一的一次。
静态内容总是优先于非静态代码块。所以静态代码块比构造方法先执行

用途：一次性的对静态变量成员进行赋值。


*/

3、Math常用方法

/*数学相关的类：java.util.Math 提供了大量静态方法，完成与数学运算相关操作
public static double abs(double num);获取绝对值。
public static double ceil(double num);向上取整【1.7--》2.0】
public static double floor(double num);向下取整
public static long round(double num);四舍五入[结果不带小数]
public static double random() ;返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。 
	
Math.PI     代表近似的圆周率常量（double）

*/

4、 Calendar、Date、DateFormate、System、String、StringBuilder类

/*java/util.Calander
日历类 Calander
抽象类
里面有一个静态方法：getInstance（）；该方法返回Calendar子类对象

*/
import java.util.Calendar;
/*
使用静态方法时，不需要创建对象，通过类名称直接使用。
西方月份 0~11月
常用方法：
1 public int get(int filed):返回给定日历的值
参数：filed 日历的指定字段（YEAR,MONTH。。。）
返回值：日历字段代表的具体值
2 public void set(int filed,int value):将给定日历字段设置为给定值
参数：filed 日历的指定字段（YEAR,MONTH。。。） value 给指定字段设置的值
3 public abstract void add(int filed,int amount):给日历增加或减去指定字段
参数：filed 日历的指定字段（YEAR,MONTH。。。） amount 增加减少指定的值【正负表示】
4 public Date getTime():返回表示日历的Date日期。
参数：无参
返回值：Date日期
把日历对象转换为日期对象
int filed 可使用Canendar中的静态成员变量获取

        public static final int YEAR = 1;//年
        public static final int MONTH = 2;//月
        public static final int DATE = 3;//日
        public static final int HOUR = 4;//时
        public static final int MINUTE = 5;//分
        public static final int SECOND = 5;//秒
*  */=======================================================================
/*java.lang.System
System类
常用方法：
1 public static long currentTimeMillis() :返回毫秒为单位的当前时间
2 public static void arraycopy(Object scr,int scrPos,Object dest,int destPos,int length):
                                                            将数组中制定数据拷贝到另一个数组中
   参数：src - 源数组。
        srcPos - 源数组中的起始位置。（起始索引）
        dest - 目标数组。
        destPos - 目标数据中的起始位置。
        length - 要复制的数组元素的数量。

    源数组中位置在 srcPos 到 srcPos+length-1 之间的组件被分别复制到目标数组中的 destPos 到         
    destPos+length-1 位置。 


*  */========================================================================
/*
Date 类
java.util.Date
表示特定时间，精确到毫秒；	千分之一秒
毫秒值得作用：可以对时间和日期进行计算
可以吧日期转换成毫秒，计算完毕，再把毫秒转换为日期。
日期转换为毫秒：
		当前日期 2088-01-01						//这是变化的
		时间原点（0毫秒） 1970年1月1日 00:00:00 (英国格林威治)//这是固定的
		就是计算当前日期带时间原点之间经历了多少毫秒。
		//中国处东八区 会把时间加8小时 即时间原点 1970年 08:00:00
		1天=24*60*60=86400秒 =86400*1000=86400000毫秒

	1 获取当前系统的日期和时间
	2 传递毫秒值，转换为日期
	3 把当前日期转换为毫秒值

 */========================================================================
/*DateFormat类 抽象类
格式化操作：	日期--》文本
解析：		文本--》日期

 */
 import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/*java.text.DateFormat:是日期/时间格式化子类的抽象类
作用：格式化 解析
成员方法：
格式化：     String format(Date date) 按照指定的模式，把Date日期[英文]，格式化为符合模式的字符串
解析：     Date parse（String source） 把符合模式的字符串解析为Date日期【英文】。
抽象类，无法直接创建对象使用，要用他的子类或实现类 SimpleDateFormat
java.text.SimpleDateFormat extends DateFormat
构造方法：
    参数：String 传递指定模式：年月日时分秒 区分大小写
    y   年	year
    M   月	month
    d   日	date
    H   时	hour
    m   分	minute
    s   秒	second
    写对应的模式 “NNNN--MM--dd  HH：mm:ss”
    注意：模式字母不能更改，连接符号可以改。yyyy年MM月dd日  HH时mm分ss秒”
 格式化使用：
 1 创建SimpleDateFormat对象，构造方法中传递指定模式。
 2 调用SimpleDateFormat对象方法format，按照指定模式，把Date日期格式化为字符串（文本）
解析使用：
1 创建SimpleDateFormat对象，构造方法中传递指定模式。
2 调用SimpleDateFormat对象方法parse，把符合方法中模式的字符串解析为Date日期。
注意：public Date parse(String source)throws ParseException
    如果字符串和构造方法的模式不同，就会抛出一个异常；
    解决：1 throws继续抛出这个异常
    2 try catch 自己处理

*
*  */============================================================
/*
 * StringBuilder构造方法：
 *  1 StringBuilder（）             构造一个不带任何字符的字符串生成器，其初始容量为 16 个字符。
 *   2 StringBuilder（String str）   构造一个字符串生成器，并初始化为指定的字符串内容。
 成员方法：
 *  1  public StringBuilder append(...任意数据类型数据)：添加任意形式的字符串形式，并返回当前对象自身
 *  2  public int indexOf(String str,int fromIndex)		从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。【String类也有】
 * */
/*StringBuilder和String可以相互转换
    String --》 StringBuilder：可以使用StringBuilder构造方法。

    StringBuilder --》 String： 可以使用StringBuilder的toString方法。

*  */=========================================================================

5、迭代器

/*
* java.util.Iterator
* Iterator<E>接口 是有泛型的，集合什么泛型，迭代器什么泛型。
* 常用方法：1.1 boolean hasNext() ：如果仍有元素可以迭代，则返回 true。
*                   判断集合中还有没有下一个元素，有返回true，没有返回false
            1.2    E next() ：返回迭代的下一个元素。
                       取出集合下一个元素
Iterator迭代器：是一个接口，需要实现类对象，获取实现类方式比较特殊
* Collection接口中存在方法：iterator（）；这个方法返回的是迭代器的实现类对象。
* 使用步骤：
* 1 先使用集合中的方法iterator（） 获取迭代器的实现类对象。使用Iterator来接收（多态）
* 2 使用Iterator接口的方法hasNext判断，还有没有下一个元素
* 3 使用Iterator接口中的方法next取出集合中的下一个元素。
*
*
*  */
public class Iterator_01 {
    public static void main(String[] args) {
        //创建一个集合对象
        Collection<String> coll=new ArrayList<>();//多态
        coll.add("姚明");
        coll.add("麦迪");
        coll.add("周琦");
        coll.add("詹姆斯");
        coll.add("艾弗森");
        //多态   接口       接口的实现类对象【这个方法在Collection类，所以先用他的一个对象调用着】
       Iterator<String> it=coll.iterator();
        boolean b = it.hasNext();
        while(it.hasNext()){//优化后 这里它自动返回true或false作为循环体方法前提
            String e=it.next();
            System.out.print(e);//姚明麦迪周琦詹姆斯艾弗森
        }//或者【了解下】
        for(Iterator<String> it2=coll.iterator();it2.hasNext();){//初始化表达式：是指针指向索引-1位。判断：如果指针后面有元素		步进表达式：省略 因为hasNext（），做了两件事：1 取出下一个元素 2 把指针向后移走一位
            String e=it2.next();
            System.out.print(e);姚明麦迪周琦詹姆斯艾弗森
        }

6、异常

/*
异常：
	异常是一个超类；java.lang.Throwable
	子类：java.lang.Error【不可处理】	java.lang.Exception【可以避免】

 */
/*
异常产生错误和的解析：
		JVM检测出异常后：1、JVM会根据异常产生的原因，创建一个异常对象，包含了异常产生的（内容，原因，位置）
		new ArrayIndexOutOfBoundsException("3");
		2、在getElement方法中，没有异常的处理逻辑（try__catch），那么JVM就会把异常对象抛出给方法的调用者（main（））
		来处理这个异常；main方法接收到了异常对象，但main（）方法也没有异常的处理逻辑，继续把异常抛给main（）方法的
		调用者JVM;JVM接受到异常后：
								1、把异常对象（内容，原因，位置）以红色字体打印在控制台
								2、JVM会终止当前正在 执行的java程序--》中断处理

*/
/*注意：工作中：我们首先必须对方法传递过来的参数进行合法性检验
 * 如果参数不合法，那么我们就必须使用抛出异常的方式，告知方法的调用者，传递的参数有问题
*   throw关键字：
*   作用：抛出指定的异常
*   格式：throw new xxxException(“异常产生原因”)
*   注意：1、throw关键字必须写在方法的内部
*         2、throw关键字后边new的对象必须是Exception或者Exception的子类对象。
*         3、throw关键字抛出指定的异常对象，我们就必须处理这个异常对象
*               throw关键字后边创建的如果是是RuntimeException或者是RuntimeException的子类对象，可以不处理，默认交给JVM
*               throw关键字后边创建的如果是是编译异常，我们就必须处理这个异常：
*                                                                          throws
*                                                                          try。。。catch
*  NullPointerException:          空指针异常 运行期异常，默认交给JVM
*  ArrayIndexOutOfBoundsException:数组索引越界异常 运行期异常，默认交给JVM
* */
}
/*
*异常注意：1、 如果finally有return语句，就会永远返回finally中的结果,所以finally里要避免return
*       2、子父类异常:要做到父类异常什么样，子类异常什么样
* */
public class Fu_lianxi {
    public void show01() throws NullPointerException,ClassCastException{}
    public void show02() throws IndexOutOfBoundsException{}
    public void show03() throws IndexOutOfBoundsException{}
    public void show04(){}
}
class Zi extends Fu_lianxi{
    //子类重写父类方法时，抛出和父类相同的异常
    public void show01() throws NullPointerException,ClassCastException{}
    //子类重写父类方法时，抛出父类异常的子类
    public void show02() throws ArrayIndexOutOfBoundsException{}
    //子类重写父类方法时
    public void show03(){}
    //父类没有抛出异常，子类重写父类该方法时，也不能抛出异常；此时子类产生异常，只能捕获，不能声明抛出
    //public void show04(){}
    public void show04(){
        try {
            throw new Exception("编译器异常");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

/*
* 自定义异常类：
*   java提供的异常类不够用时，自己定义
*   格式：
*   public class XXXException extends Exception | RuntimeException{
*   添加一个空参构造方法
*   添加一个带异常信息的构造方法[方法内部会调用父类带异常信息的构造方法，让父类来处理这个异常信息]
* }
* 注意：
*   1、自定义异常类一般都是以Exception结尾，说明该类是一个异常类
*   2、自定义异常类，必须继承Exception或RuntimeException
*       继承Exception：那么自定义的异常类就是一个编译器异常，
* 如果方法内部抛出了编译器异常，就必须处理这个异常【throws或try-catch】
*       继承RuntimeException：那么自定义的异常是一个运行期异常。
* 无需处理，默认交给JVM中断处理
* 
*
* */

public class zidingyiException extends RuntimeException{
    public zidingyiException(){
        super();
    }
    public zidingyiException(String message){
        super(message);
    }
}
public class lianxi_03 {
    static String[] usernames={"张三","李四","王五"};
    public static void main(String[] args){//运行期异常
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入注册用户名：");
        String username = sc.next();
        checkUsername(username);
    }
    public static void checkUsername(String username) {//运行期异常处理
        for (String name : usernames) {
            if(name.equals(username)){
                throw new zidingyiException("亲，该用户已经被注册");
            }
        }
        System.out.println("恭喜注册成功");
    }
}