内部类和常用类（感觉学的有点水，浅浅的懂）

标签：常用 String int System 感觉 println 浅浅的 public out

内部类

概念：在一个类的内部再定义一个完整的类

特点：编译之后可以说呢过程独立的字节码文件

​ 内部类可以直接访问外部类的私有成员，而不破坏封装

​ 可以为外部类提供必要的内部功能组件

package lei;

public class Demo01 {

    private String name;

    class Head{//内部类
        public void see(){
            System.out.println(name);
        }

        //在内部类中可以调用外部类私有属性

    }
}

成员内部类

外部类的一个实例部分，创建内部类对象时。必须依赖外部类对象

当外部类，内部类存在重名属性时，会优先访问内部类属性

如果还想访问外部类的属性应该使用，类名.this.属性

内部类不能包含静态属性，但是

可以包含静态常量

System.out.println(Demo02.this.name);

package lei;
//外部类
public class Demo02 {

    //定义的实例变量
    public String name="张三";
    public int age=10;


    //内部类
    class Inner{

        public String address="警察局";
        public  int phone=110;
        //方法
        public void see(){
            //打印外部类的属性
            System.out.println(name);
            System.out.println(age);
            //打印内部类的属性
            System.out.println(phone);
            System.out.println(address);
        }

    }
}
/*
main方法
package lei;

public class Demo02Test {
    public static void main(String[] args) {
        //创建外部类对象，并且实例化
        Demo02 d2 = new Demo02();

        //创建内部类对象，并且实例化
        Demo02.Inner in = d2.new Inner();

        //也可以选择一步到位
        //Demo02.Inner in = new Demo02().new Inner();


        in.see();

    }
}

 */

静态内部类

只有静态内部类才可以使用static，其他的普通类都不能使用

不依赖外部类对象，可以直接创建或者通过类名访问，可声明静态成员

package lei;
//外部类
public class Demo03 {
    private String name="张三";
    private int age=12;


    //静态内部类，和外部类相同
    static class Open{

        private String address="北京";
        private int phone=110;
        //静态成员
        private static int count=100;
        public void show(){
            //静态内部类中的方法如果要调用外部类的属性
            //1.先创建外部类对象
            Demo03 d3 = new Demo03();
            //2.调用外部类对象的属性
            System.out.println(d3.name);
            System.out.println(d3.age);
            //调用静态内部类的属性和方法，直接this.
            System.out.println(this.address);
            System.out.println(this.phone);
            //调用静态内部类中的静态属性，就使用类名.count
            System.out.println(Open.count);
        }

    }
}
/*
用于测试的main方法
package lei;

public class Demo03Test {
    public static void main(String[] args) {
        //可以直接创建静态内部类对象
        Demo03.Open op = new Demo03.Open();
        //调用方法
        op.show();
    }

}

 */

局部内部类

定义在外部类方法中，作用范围和创建对象范围仅限已当前方法

局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的声明周期与自身相同，所以变量必须修饰为final。

package lei;
//外部类
public class Demo04 {
    public String name="刘德华";
    public int age=59;

    public void show(){
        //定义局部变量
         String address="深圳";

         //局部内部类：注意不能添加任何修饰符
        class Inner{
            //局部内部类属性
             public String eamil="1457295116";
             public int phone=666;

             public void show2(){
                 //访问外部类属性
                 System.out.println(Demo04.this.name);
                 System.out.println(Demo04.this.age);
                 //访问内部类属性
                 System.out.println(this.phone);
                 System.out.println(this.eamil);
                 //访问局部变量
                 System.out.println(address);
             }
         }
         //调用局部内部类需要先创建局部类的对象
        Inner in = new Inner();
        in.show2();

    }
}
/*
package lei;

public class Demo04Test {
    public static void main(String[] args) {
        Demo04 d4 = new Demo04();
        d4.show();
    }
}

 */

匿名内部类

没有类名的局部内部类

必须继承一个父类或者实现一个接口

常用类

Object

getClass方法

返回引用中存储的实际对象类型

应用：通常用于判断两个引用中实际存储对象类型是否一致

package lei;

public class Demo06 {
    private String name;
    private int age;

    public Demo06() {

    }

    public Demo06(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
/*
package lei;

public class Demo06Test {
    public static void main(String[] args) {
        Demo06 aaa = new Demo06("aaa", 20);
        Demo06 bbb = new Demo06("bbb", 22);
        //判断aaa和bbb是不是同一个类型
        Class<? extends Demo06> a = aaa.getClass();
        Class<? extends Demo06> b = bbb.getClass();
        if (a==b){
            System.out.println("是属于同一个类型");

        }else{
            System.out.println("不是属于同一个类型");
        }
    }

}

 */

hashCode方法

返回该对象的哈希码值

哈希值根据对象的地址或者字符串或者数字使用hash算法计算出来的int类型的类值

一般情况下相同的对象返回相同的哈希码

toString方法

返回该对象的字符串表示

可以根据程序需求覆盖，重写改方法

//hash方法
System.out.println(a.hashCode());
System.out.println(b.hashCode());
//toString方法
System.out.println(aaa.toString());
System.out.println(bbb.toString());

equals方法

默认实现为（this==obj）比较两个对象的地址是否相同

可进行覆盖，比较两个对象的内容是否相同

equals方法覆盖步骤：比较两个引用是否指向同一个对象

​ 判断obj是否为null

​ 判断两个引用指向的实际对象类型是否一致

​ 强制类型转换

​ 一次比较各个属性值是否相同

finalize方法

垃圾对象：没有有效引用指向此对象时，为垃圾对象

垃圾回收：由GC销毁垃圾对象，释放数据存储空间

包装类

基本数据类型所对应的引用数据类型

基本数据类型：四类八种：byte,short,int,long;float,double;boolean;char

类型转换与装箱拆箱

装箱：基本类型转换成引用类型

拆箱：引用类型转换成基本类型

package lei;

public class Demo07 {
    public static void main(String[] args) {
        int age=20;
        //自动装箱
        Integer integer=age;
        System.out.println("自动装箱");
        System.out.println(integer);

        //自动拆箱

        int age1=integer;
        System.out.println("自动拆箱");
        System.out.println(age1);
    }
}

8种包装类提供不同类型间的转换方式

parseXXX静态方法

注意：boolean类型的字符串形式转换成基本类型时候，只有不是true，都会转化成false。

package lei;

public class Demo07 {
    public static void main(String[] args) {
        int age=20;
        //自动装箱
        Integer integer=age;
        System.out.println("自动装箱");
        System.out.println(integer);

        //自动拆箱

        int age1=integer;
        System.out.println("自动拆箱");
        System.out.println(age1);


        //基本类型和字符串之间转换
        //基本类型转换为字符型
        int a=255;
        //使用+号
        String b=a+"";
        //使用Integer中的toString方法
        String c = Integer.toString(a);
        String d=Integer.toString(a,16);//toString的重载方法，转化为16进制
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);


        //把字符串转换为基本类型
        String str="255";
        //使用interger.praseXXX
        int str1 = Integer.parseInt(str);
        System.out.println(str1);
    }
}

integer缓冲区

Integer c=Integer.valueOf(100);

自动装箱是调用的interger.valueOf的方法，这个方法内的数组范围为-128到127

如果不在这个范围之内，那么valueof方法就会在堆中重新的new一个地址

String类

package lei;

public class Demo09 {
    public static void main(String[] args) {
        String name="张三";

        String con="java是世界上最好的语言";
        //字符串方法的使用
        //length（）返回字符串的长度
        //charAt（int index）返回某个位置的字符串
        //contains（String str) 判断是否包含某一个字符串
        System.out.println(con.length());
        System.out.println(con.charAt(5));
        System.out.println(con.contains("java"));
        System.out.println(con.contains("php"));

        //toCharArray()返回字符串对应的数组
        //indexOf（）返回字符串首次出现的位置
        //lastIndexOf（）返回字符串最后一次出现的位置
        System.out.println(con.toCharArray());
        System.out.println(con.indexOf("java"));
        System.out.println(con.lastIndexOf("java"));

        //trim()去掉字符串前后的空格
        //toUpperCase（）把小写转换为大写toLowCase（）把大写转换为小写
        //endWith（）判断是否以某种字符串结尾startsWith（）判断是否以某种字符串开头
        String con2="  hello WORLD   ";
        System.out.println(con2.trim());
        System.out.println(con2.toUpperCase());
        System.out.println(con2.toLowerCase());
        System.out.println(con2.endsWith("hello"));

        //replace(char old,char new)用新的字符串替换旧的字符串
        //split对字符串进行拆分
        System.out.println(con.replace("java", "php"));
        String say="java is the best programing language";
        String[] arr=say.split(" ");
        System.out.println(arr.length);
        for(String string : arr){
            System.out.println(string);
        }
    }
}

还有equal方法和compare方法

equal比较的是字符

compare方法比较的是字节表中顺序，从第一个字母比较，相同就比较下一个，直到比较到第一个不同的字母。

可变字符串

StringBuffer可变长字符串运行效率慢，线程安全

StringBuilder可变长字符串运行效率快，线程不安全

package lei;

public class Demo {
    public static void main(String[] args) {
        StringBuffer str = new StringBuffer();
        //append追加
        str.append("java世界第一");
        System.out.println(str.toString());
        str.append("java真香");
        System.out.println(str.toString());
        str.append("java真不错");
        System.out.println(str.toString());
        //insert添加
        str.insert(0,"我在最前面");
        System.out.println(str.toString());
        //replace替换
        str.replace(0,5,"hello");
        System.out.println(str.toString());
        //delete删除
        str.delete(0,5);
        System.out.println(str.toString()); 
    }
}

Bigdecimal

因为double是近似存储，在运算时候会精度丢失

所以特别精确的运算，需要借助bigdecimal

位置：java.math

作用：精确计算浮点数

创建方式：BigDecimal bd=new BigDecimal（“1.0”）

package lei;

import java.math.BigDecimal;

public class Demo11 {
    public static void main(String[] args) {
        BigDecimal bd = new BigDecimal("1.0");
        BigDecimal bd1 = new BigDecimal("0.9");
        System.out.println(bd.subtract(bd1));
        System.out.println(bd.add(bd1));
        System.out.println(bd.multiply(bd1));


    }
}

date

package lei;

import java.util.Date;

public class Demo12 {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date.toLocaleString());//今天
        Date date1 = new Date(date.getTime() - (60 * 60 * 24 * 1000));
        System.out.println(date1.toLocaleString());//昨天
        //方法after before
        boolean a = date.after(date1);
        System.out.println(a);
        boolean b = date.before(date1);
        System.out.println(b);

        //比较compareTo
        int c = date1.compareTo(date);
        System.out.println(c);
        //equal方法比较两个时间是否相等
        boolean d = date.equals(date1);
        System.out.println(d);
        
    }
}

Calendar

提供了获取或者设置各种日历字段的方法

构造方法：protected Calendar（）：由于修饰符是保护，所以无法直接创建该对象。

package lei;

import java.util.Calendar;

public class Demo13 {
    public static void main(String[] args) {
        //创建Calendar对象,因为是protected的，所以不能直接new，用get方法来获取
        Calendar cal=Calendar.getInstance();
        System.out.println(cal.getTime().toLocaleString());

        //获取时间信息
        //获取年
        int year = cal.get(Calendar.YEAR);
        //月
        int morth = cal.get(Calendar.MARCH);
        //日
        int day = cal.get(Calendar.DATE);
        //小时
        int hour = cal.get(Calendar.HOUR_OF_DAY);
        //分钟
        int min = cal.get(Calendar.MINUTE);
        //秒
        int sec = cal.get(Calendar.SECOND);
        System.out.println(year+"年"+morth+"月"+day+"日"+hour+"."+min+"."+sec);
        //修改时间
        Calendar cal1 = Calendar.getInstance();
        System.out.println(cal1.getTime().toString());
        //补充方法
        int max = cal1.getActualMaximum(Calendar.DAY_OF_MONTH);//获取当前月的最大值
        int mini = cal1.getActualMinimum(Calendar.DAY_OF_MONTH);//获取当前月的最小值
        System.out.println(max);
        System.out.println(mini);

    }
}

SimpleDateFormat

package lei;

import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo14 {
    //这里用parse转换日期的时候需要先抛出异常，具体原因俺不知道
    public static void main(String[] args) throws Exception{
        //创建SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        //创建date
        Date date = new Date();
        //格式化date（把日期转换成字符串
        String str = sdf.format(date);
        System.out.println(str);
        //解析（把字符串转换成日期
        Date date2 = sdf.parse("2000/03/15");
        System.out.println(date2);

    }
}

System类

系统类主要用于获取系统的属性数据和其他操作，构造方法是私有的

标签：常用,String,int,System,感觉,println,浅浅的,public,out
From： https://www.cnblogs.com/-lhrbk/p/17201334.html