java常用类汇总（1）

内部类汇总

package oop.demo13;
//外部类
public class Outer1 {
    private String name="张三";
    private  int age=16;
    //内部类
    class Inter1{
        private String  address="南昌";
        private int id=110;
        private String name="李四";
        //private  static  int a=1;报错  成员内部类是不能写静态类的 但可以包含静态常量
        private static  final int a=1;
        public void test(){
            //打印外部类的私有属性和内部类属性
            System.out.println("外部类"+name);
            System.out.println("外部类"+age);
            System.out.println("内部类"+address);
            System.out.println("内部类"+id);
            //当内部类属性和外部类属性同名时候，访问的是内部类的属性
            //如果要访问的话  要加  Outer1.this.name  外部类名.this.同名属性
            System.out.println("外部类同名属性"+Outer1.this.name);//张三
        }
    }

}
package oop.demo13;

import oop.demo12.Outer;

public class Application {
    public static void main(String[] args) {
        //创建外部类和内部类
      /*  Outer1 outer1 = new Outer1();
        Outer1.Inter1 inter1= outer1.new Inter1();*/
      //一步到位
        Outer1.Inter1 inter1=new Outer1().new Inter1();
        inter1.test();//调用内部类
    }
}

静态内部类的使用(只有内部类才可以被static修饰)

public class Application {
    public static void main(String[] args) {
   
        staticClass.Inter1 inter1=new staticClass.Inter1();
        inter1.show();
    }

}
package oop.demo13;
//外部类
public class staticClass {
    private  String name="xxx";
    private  int age=17;
    //静态内部类 与外部类相同
    static class Inter1{
        private  String address="山东";
        private String phone="10087";
        private  static int count=11;//静态内部成员
        public void  show(){
            //调用外部类的属性
            staticClass s=new staticClass();//先创建外部类对象
            System.out.println(s.age);//调用外部类属性
            System.out.println(address);//调用外部类属性
            System.out.println(Inter1.count);//通过内部类名调用内部类的属性
        }
    }
}

局部内部类

package oop.demo14;

public class Outer {
    //外部类
    private String name="小黄";
    private  int age=13;
    public void show(){
        //定义局部变量
       final String address="南京";
        //局部内部类不能添加任何访问修饰符
        class Inter{
            //局部内部类的属性
            private String phone="11112";
            private  String email="133@.qq.com";
            public void  show2(){
                //访问外部类的属性
                System.out.println(Outer.this.name);//因为show（）方法可以直接用 而局部内部Inter类和局部变量级别是相同的所以直接调用
                System.out.println(Outer.this.age);//这样写更规范点 或者直接写age
                //访问内部类属性
                System.out.println(this.email);
                System.out.println(this.phone);
                //访问局部变量 jdk1.7要求 变量必须为常量 final jdk1.8自动添加final
                //因为局部变量address在方法里面 方法运行完会消失，而类不会  所以把它设置为常量才可以调用
                //标准的说呢就是  局部内部类访问外部类当前方法中的局部变量时 因无法保障变量的生命周期与自身相同，变量必须加修饰符final
                System.out.println(address);
            }
        }
        Inter inter=new Inter();
        inter.show2();
    }
}
package oop.demo14;

public class Application {
    public static void main(String[] args) {
        Outer outer=new Outer();
        outer.show();
    }
}

匿名内部类

package oop.demo15;

public class TestUsb {
    public static void main(String[] args) {
        //这是第一步
        /*//创建接口类型的变量 我初步理解把接口相当成了父类
        UsbImpl usb=new Mouse();//父类引用子类变量 哈哈哈
        usb.service();*/
        //这是第二步
  /*      //局部内部类
        class Fan implements UsbImpl{

            @Override
            public void service() {
                System.out.println("连接电脑成功，风扇开始工作了...");
            }
        }
        UsbImpl usb1=new Fan();
        usb1.service();*/
        //这是第三步
  //使用匿名内部类优化（相当于创建了一个局部内部类）
        UsbImpl usb2=new UsbImpl() {
            @Override
            public void service() {
                System.out.println("连接电脑成功，风扇开始工作了...");
            }
        };//注意这里有一分号
        usb2.service();
    }
}
--------------------------------------------------------------------------------
    //实现接口的类
public class Mouse implements UsbImpl {
    @Override
    public void service() {
        System.out.println("鼠标已经连接成功....");
    }
}
//这是接口
public interface UsbImpl {
    void service();
}

匿名内部类注意点：

1. 没有类名的局部内部类，一切特征与局部内部类相同
2. 必须继承一个父类或者一个接口
3. 定义类，实现类，创建对象的语法合并，只能创建一个该类的对象
4. 优点减少代码量
5. 缺点可读性差

---

Object类-------getClass(),hashCode()

package oop;

public class Students {
    private String name;
    private  int age;
    public Students(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //重写toString方法
    @Override
    public String toString() {
        return "Students{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    //重写equals 判断两个对象是否内容相同 equals  ilde自动生成
     @Override
    public boolean equals(Object o) {
        //判断两个对象是否为同一个引用
        if (this == o) return true;
        //判断0是否为空或者是否为同一类型
        if (o == null || getClass() != o.getClass()) return false;
        //强制转换类型
        Students students = (Students) o;
        return age == students.age &&
                Objects.equals(name, students.name);
    }

    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;
    }
}
-----------------------------------------------------------------------------------------
public class TestStudents {
    public static void main(String[] args) {
        Students student1=new Students("小明",17);//有参构造函数的创建对象
        Students student2=new Students("小楼",18);
        //判断student1和student2是不是同一个类型
        getclass()方法
        Class class1=student1.getClass(); //getClass返回值是类  相当于赋值
        Class class2= student2.getClass();
        if (class1==class2){
            System.out.println("同一类型");
        }else {
            System.out.println("不是同一类型");
        }
        //hashCode（）方法 返回该对象的哈希码值 （int） 一般情况相同的对象返回的相同的哈希码
        System.out.println(student1.hashCode());
        System.out.println(student2.hashCode());
        Students s3=student1;
        System.out.println(s3.hashCode());//s1和s3相同
		//toString()方法 返回对象的字符串表示 可以重写里面的方法体
        System.out.println(student1.toString());
        System.out.println(student2.toString());
        //equals（）方法 返回值boolean类型  比较两个对象地址是否相同
        // 可以进行覆盖  比较两个对象的内容是否相同
        System.out.println(student1.equals(student2));
        
    }
}

装箱与拆箱

package oop.demo16;

public class Demo01 {
    public static void main(String[] args) {
     /*   //JDK1.5之前的操作了 out了 但是可以了解
        int num=10;
        //类型转换  装箱：基本类型转换为引用类型的过程
        //下面两种方法都可以
        Integer integer1=new Integer(num);
        Integer integer2=Integer.valueOf(num);
        System.out.println("装箱 "+integer1);
        System.out.println("装箱 "+integer2);

        //类型转换  拆箱：引用类型转换为基本类型
        Integer integer3=new Integer(100);
        int num2=integer3.intValue();
        System.out.println("拆箱"+num2);
*/
        //JDK1.5之后，提供了自动装箱和拆箱
        int age=30;
        //自动装箱
        Integer integer4=age;
        System.out.println("自动装箱"+integer4);
        //自动拆箱
        int age2=integer4;
        System.out.println("自动拆箱"+age2);
        
    }
}

基本类型与字符串转换

package oop.demo16;

public class Demo02 {
    public static void main(String[] args) {
        //基本类型和字符串之间的转换
        //基本类型转换为字符串
        //1.使用+号
        int num1=255;
        String s1=num1+"";
        //2.使用Integer中的toString（）方法
        String s2=Integer.toString(num1,16);//这个是按(16)进制转换 ff
        System.out.println(s1);
        System.out.println(s2);
        // 字符串转换为基本类型
        String str="150";
        //使用Integer.parsexxx();
        int num2=Integer.parseInt(str);//转换成int型时string类型的不能出现字母  如str="123dd"这样是不可以的
        System.out.println(num2);
        //boolean字符串形式转换成基本类型 如 "true"-->true   非"true"-->false
        String str2="true";
        String str3="sss";
        boolean b1=Boolean.parseBoolean(str2);
        boolean b2=Boolean.parseBoolean(str3);
        System.out.println(b1);//true
        System.out.println(b2);//false
    }
}

需要保证类型兼容，否则抛出NumberFormatException异常。

//面试题Integer integer1=new Integer(100);Integer integer2=new Integer(100);System.out.println(integer1==integer2);//false
//因为两个引用类型的是存放在堆区里面的  他们的地址是不相同的，比较也是比较地址  即使内容相同也不一样
        //Integer integer3=100;
        Integer integer3=Integer.valueOf(100);//自动装箱
        Integer integer4=100;//Integer integer4=Integer.valueOf(100);自动装箱
        System.out.println(integer3==integer4);//true
        Integer integer5=200;//Integer integer5=Integer.valueOf(100);自动装箱
        Integer integer6=200;//Integer integer6=Integer.valueOf(100);自动装箱
        System.out.println(integer5==integer6);//false
//因为这里面有一个整数缓冲区-128~127之间  自动装箱其实是调用了Integer里面的valueOf方法 
//里面的范围是-128~127之前 所以i3  i4 是true i5 i6是false 超出了范围