java内部类、数据类型转换

一、java内部类：在一个类内部的类，可以有自己的属性和方法。分四种：

1、正则内部类（也称常规内部类 ），写在类里面普通的类，相当于外部类的类成员。特点：

1）外部类不可直接访问内部类的属性和方法。

2）在正则内部类中可以直接访问外部类的类成员。

3）使用正则内部类，必须先创建外部类的实例，再创建正则内部类的实例，使用.new关键字。

4）正则内部类中不可以写静态的属性和方法，除非加上final。原因：外部类非静态。

用法可参考代码：

public class employee {private int i=10;//类级别的变量 成员变量 属性 全局变量private void saySomething(){System.out.println("外部类方法"+i);}//正则内部类/常规内部类，相当于外部类的成员，可以直接访问外部类的属性和方法public class Department{static final int k=9;int j=100;public void speak(){//内部类的方法System.out.println("正则内部类可以直接访问外部类的类成员"+i);saySomething();}}public static void main(String[] args) {employee e=new employee();//创建和使用正则内部类   <span style="color:#FF0000;">.new()关键字</span>Department d=<span style="color:#FF0000;">e.new</span> Department();d.speak();System.out.println(d.j);}}

2、静态内部类（也称嵌套类）：static修饰的内部类，特点：

1）相当于外部类的静态成员，只能访问外部类的静态的属性和方法。

2）静态内部类中可以写静态的属性和方法。

3）static修饰的变量和方法，在实例化类之前就可以直接使用。所有static的变量或方法，所有类的实例共享一个。

4）访问静态内部类：创建静态内部类，不需要创建外部类实例。

用法可参考代码：

public class Employee1 {int m=99;//非静态变量//非静态方法必须在实例化后才可以使用public void test(){  }static int i=10;static void staticMethod(){System.out.println("外部类静态方法");}//静态内部类，只能访问外部类的静态的属性和方法。static class Department{int k=10;public void speak(){   }static int j=0;static void h(){staticMethod();System.out.println("访问外部类的静态属性和方法"+i);}}public static void main(String[] args) {Employee1 e1=new Employee1();e1.i++;Employee1 e2=new Employee1();e2.i++;Employee1.staticMethod();//test();//静态方法里面不可以直接调用非静态方法//访问静态内部类：创建静态内部类，不需要创建外部类实例<span style="color:#FF0000;">Employee1.Department d=new Employee1.Department();</span>d.k=100;<span style="color:#FF0000;">Employee1.Department.j=10;//静态的变量，不需要实例化Department</span>}}

3、方法局部内部类：写在方法里的类，特点：

1）属于方法里面的类，调用方法时才能调用方法局部内部类。

2）但该类不是执行方法时调用，在实例化外部类时已经创建 该方法内部类。

3）方法局部内部类，只能用final 和 abstract，不能使用public/private/protected。

4）访问局部变量时，只能访问内部类所在方法中final修饰的局部变量。

5）jdk<=7,不可以访问所在方法的局部变量,jdk8不会有编译错误,jdk8会自动加final。

6）实例化时，只能在所在的这个方法里面进行实例化。

用法可参考代码：

public class Employee2 {int i=10;public void saySomething(){int j=100;//方法的局部变量final int k=8;//方法的常量//方法局部内部类，只能用final 和 abstract，不能使用public/private/protected//不是执行方法时调用，在实例化外部类时已经创建 该方法内部类class Department{int h=9;public void say(){System.out.println(i);//可以访问外部类的属性//System.out.println(j);//jdk<=7,不可以访问所在方法的局部变量,jdk8不会有编译错误,jdk8会自动加finalSystem.out.println(k);//只能访问final修饰的局部变量，因为类先于方法创建System.out.println(h);//可以访问}}Department d=new Department();System.out.println(d.h);d.say();}public static void main(String[] args) {Employee2 e=new Employee2();//实例化外部类时已经创建 了方法局部内部类e.saySomething();}}

4、匿名内部类：定义类没有名字，没有实例。优点：

1）只能使用一次。

2）用于接口、抽象类的实现。

3）其他地方不可访问。

用法可参考代码：

public class AnonymousInner {public Student getStudent(){return new Student();}//定义匿名类实现接口，只能使用一次public Person getPerson(){//Person不是一个类，这样写就是匿名类，来实现接口return new Person(){@Overridepublic void sleep() {System.out.println("这是匿名类的方法");}};}public static void main(String[] args) {AnonymousInner e=new AnonymousInner();e.getPerson();e.getStudent();//定义匿名类实现继承抽象类，只能使用一次new Animal(){@Overridepublic void sleep() {System.out.println("这是匿名类的方法");}};}}//使用类来实现接口class Student implements Person{@Overridepublic void sleep() {    System.out.println("非匿名类的sleep");}}interface Person{public void sleep();}abstract class Animal{public abstract void sleep();}

在GUI中的用法参考代码：

public class AnonymousDemo extends JFrame{JMenuBar mbar;JMenu menu;JMenuItem item;public AnonymousDemo(){setVisible(true);setSize(400,400);setTitle("匿名类在界面的实现");mbar=new JMenuBar();menu=new JMenu("文件");item=new JMenuItem("打开");menu.add(item);mbar.add(menu);setJMenuBar(mbar);//<span style="color:#FF0000;">匿名类只为item实现事件处理，且只执行一次</span>item.addActionListener(new ActionListener(){@Overridepublic void actionPerformed(ActionEvent e) {}});}public static void main(String[] args) {new AnonymousDemo();}}

5、内部类的用途的一种：实现多继承，用法可参考代码：

public class InnerClassDemo {class InnerA extends ParentA{@Overridevoid test() {}}class InnerB extends ParentB{@Overridevoid test() {}}abstract class ParentA{abstract void test();}abstract class ParentB{abstract void test();}}

二、数据类型转换

1、基本类型转换：在兼容类型前提下进行转换：

1）默认类型转换，小- -大，自动发生，隐式转换。

2）显示转换，大- -小，强制类型转换（如果大于目标类型的范围时，小心数据丢失）。

2、String类型与基本类型的转换：

public static void main(String[] args) {// 字符串转换为其他类型String score = "123456";int result = Integer.parseInt(score);// Integer是int的包装类int result1 = Integer.valueOf(score);// 与上面的方法都可以转换，只是效率不同// 其他类型转换为字符串String s1 = String.valueOf(result);String s2 = String.valueOf('a');String s3 = String.valueOf(100);}

3、对象类型转换：只发生在继承前提下。

1）向下类型转换，必须发生过向上类型转换的类才能转换。

2）向上类型转换，自动转换。

用法可参考代码：

public class ObjectCastDemo {public static void main(String[] args) {Animal a1=new Animal();Animal a2=new Animal();Dog d=new Dog();Dog d2=new Dog();Cat c=new Cat();a1=d;//使用父类的引用a1引用了子类d，向上类型转换，沿着子类到父类的方向转换//向下类型转换 必须发生过向上类型转换的类//c=(Cat)a2;//转换出错//判断a2是否为Cat类型if(a2 instanceof Cat){}    d2=(Dog)a1;}}class Animal{}class Dog extends Animal{}class Cat extends Animal{}

3）变量引用的内存：