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);
}
}

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();
}

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);
}

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{}

最后

以上就是失眠书包为你收集整理的java内部类、数据类型转换的全部内容，希望文章能够帮你解决java内部类、数据类型转换所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。