JAVA笔记5

/*基本数据类型的封装
*Integer
Double
Byte
Boolean
*/
public class test{
    public static void main(String args[]){
        Integer  i=new Integer(256);
        Integer j=new Integer("256");
        System.out.println(i.intValue()*2); //将当前Integer类的对象转化为整型数据
        System.out.println(i.doubleValue());//转为double
        System.out.println("i="+i.toString());//转为字符串
        System.out.println(i==j);//判断是否相同
        System.out.println(i.compareTo(j));//判断是否相等

        System.out.println(Integer.parseInt("100")*2);//字符串转为整型
        System.out.println("100*2="+Integer.toString(100*2));//整型转字符串
        int k;
        k=Integer.valueOf("1010",2).intValue();//字符串转化为Integer类的对象
        System.out.println(k);

        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);

    }
}

/*Math 类*/
public class test{
    public static void main(String args[]){
        System.out.println(Math.E);
        System.out.println(Math.PI);
        System.out.println(Math.exp(5.7));//e的参数次幂
        System.out.println(Math.random());//随机数
        System.out.println(Math.sqrt(9.08));//开方
        System.out.println(Math.pow(2,3));//乘方
        System.out.println(Math.round(99.6));//四舍五入
        System.out.println(Math.abs(-8.09));//绝对值
    }
}

/**String类*/
public class test{
    public static void main(String args[]){
        String s;
        s="String test";//赋值方式
        s=new String("String test");

        /*获取字符串长度*/
        int stringLength=s.length();
        System.out.println("stringLength="+stringLength);

        /*查询特定字符位置*/
        int blankIndex=s.indexOf('s');
        System.out.println("blankIndex="+blankIndex);
        /*查询特定字符串的位置*/
        int subStringIndex=s.indexOf("est");
        System.out.println("subStringIndex="+subStringIndex);
        /*获取特定位置的字符串*/
        String sub=s.substring(2,5);
        System.out.println("sub="+sub);
        /*得到特定位置的字符*/
        char singleChar=s.charAt(3);
        System.out.println("singleChar="+singleChar);
    }
}

/*
*Date 类
void setTime(long)//设置新的时间
long getTime();//返回时间为毫秒
*/
import java.util.Date;
public class test{
    public static void  main(String args[]){
        Date currentDate=new Date();
        /**获取当前时间*/
        System.out.println(currentDate);
        /*从1970年的毫秒时间*/
        Date newDate=new Date(100000);
        System.out.println(newDate);
    /*判断当前时间与1970年时间的前后*/
        System.out.println(currentDate.after(newDate));
        System.out.println(currentDate.before(newDate));

    }
    }

//Calendar类
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
public class test{
    //获取当前时间之前的某个时间
    private static void doAdd(){
        Calendar now=Calendar.getInstance();
        Calendar working;
        SimpleDateFormat formatter=new SimpleDateFormat("yyyy.MM.dd hh:mm:ss");
        working=(Calendar)now.clone();
        working.add(Calendar.DAY_OF_YEAR,-(365*2));
        System.out.println("Two years "+formatter.format(working.getTime()));
    }
    //获取指定时间与当前时间的差
    private static void doDate(){
        Date startDate1=new GregorianCalendar(1994,02,14,14,00).getTime();
        Date endDate1=new Date();
        long diff=endDate1.getTime()-startDate1.getTime();
        long time=diff/(1000L*60L*60L*24L);
        System.out.println(time);
    }
    public static void main(String args[]){
        doAdd();
        doDate();
    }
}

接口：

/* interface
接口的定义格式.
接口的图形表示
接口的实现格式
有了接口，就可以得到多重继承的效果。
接口中的所有成员变量都默认是由public static final修饰的。
接口中的所有方法都默认是由public abstract修饰的。接口没有构造方法。

与抽象类一样，接口要使用也必须通过子类，子类通过implements关键字实现接口。
*/
interface A{
    String AUTHOR="李华";
    void print();
    String getInfo();
}
interface B{
    public void say();
}
class X implements A,B{
    public void say(){
        System.out.println("hello world!");
    }
    public String getInfo(){
        return "HELLO";
    }
    public void print(){
        System.out.println("作者"+AUTHOR);
    }
}
public class test1{
    public static void main(String args[]){
        X x=new X();
        x.say();
        x.print();
    }
}

/* interface
接口的定义格式.
接口的图形表示
接口的实现格式
有了接口，就可以得到多重继承的效果。
接口中的所有成员变量都默认是由public static final修饰的。
接口中的所有方法都默认是由public abstract修饰的。接口没有构造方法。

与抽象类一样，接口要使用也必须通过子类，子类通过implements关键字实现接口。

*/
interface A{
    public static final String AA="李华";
    public void say();

    public void info();
}
abstract class B{
    public abstract void print();
}
/* 同时接口和继承 */
class C extends B implements A{
    public void say(){
        System.out.println("Hello");
    }
    public void print(){
        System.out.println("print()");
    }
    public void info(){
        System.out.println("info");
    }

}
public class test1{
    public static void main(String args[]){
        C c=new C();
        c.say();
        c.print();
    }
}

/* toString（）方法来返回当前对象的一些重要属性。
equals(obj,obj) */
class Person {            // 定义Person类
    private String name ;    // 定义name属性
    private int age ;        // 定义age属性
    private int num;
    public Person(String name,int age,int num){//通过构造设置属性内容
        this.name = name ;
        this.age = age ;
        this.num=num;
    }
    public String toString(){// 此处覆写toString()方法
        return "姓名：" + this.name + "；年龄：" + this.age+"num"+this.num ;
    }
}
public class test {
    public static void main(String args[]) {
        Person per = new Person("李华",30,2) ;//实例化Person对象
        System.out.println("对象信息：" + per) ;// 打印对象调用toString()方法
    }
}

/*1.abstract抽象方法
2.抽象类的定义格式及使用规则
只有方法的声明，没有方法的实现的方法称为抽象方法
使用abstract定义的类被称为抽象类
1.抽象类不能被实例化（不能以抽象类为模板生成对象）
2.如果一个类当中包含抽象方法，那么这个类必须被声明为抽象类。
3.如果一个类当中没有抽象方法也可以被声明为抽象类。
4.抽象类必须被子类继承，子类（如果不是抽象类）必须覆盖抽象类中的全部抽象方法。

*/
abstract class A{
    public static final String FLAG="CHINA";
    private String name="梨花";
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name=name;
    }
    public abstract void print();
}
class B extends A{
    public void print(){
        System.out.println(FLAG);
        System.out.println(super.getName());
    }
}
public class test1{
    public static void main(String args[]){
        B b=new B();
        b.print();
    }
}