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会自动加final
				System.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(){
			@Override
			public void sleep() {
				System.out.println("这是匿名类的方法");		
			}};
	}
	public static void main(String[] args) {
		AnonymousInner e=new AnonymousInner();
		e.getPerson();
		e.getStudent();
		//定义匿名类实现继承抽象类，只能使用一次
		new Animal(){
			@Override
			public void sleep() {
				System.out.println("这是匿名类的方法");					
			}};
	}
}
//使用类来实现接口
class Student implements Person{
	@Override
	public 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(){
			@Override
			public void actionPerformed(ActionEvent e) {				
			}});
	}
	public static void main(String[] args) {
		new AnonymousDemo();
	}
}

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

public class InnerClassDemo {
	class InnerA extends ParentA{
		@Override
		void test() {		
		}}
	class InnerB extends ParentB{
		@Override
		void 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）变量引用的内存：