JAVA SE基础（四）—— 内部类、匿名类

内部类

• 在JAVA中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类
• Inner class 一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称。（Inner class 的名字不能与包含它的类名相同）
• Inner class可以使用外部类的私有数据，因为它是外部类的成员，同一个类的成员之间可相互访问。而外部类要访问内部类中的成员需要：<内部类.成员 或 内部类对象.成员>
• 分类：

1、成员内部类（static成员内部类、非static成员内部类）——声明在类内部，方法之外

      ①是外部类的一个成员：

            i. 可以有修饰符（4个）

            ii. static  final

            iii. 可以调用外部类的成员属性、方法

      ②具体类的特点：

            i. abstract

            ii.可以在其内部定义属性、方法、构造器

public class Inner_ClassTest {
	public static void main(String[] args) {
		//一、创建内部类的对象*****************************
		//①创建静态内部类的对象：可以直接通过外部类调用静态内部类的构造器直接创建
		Person.House house = new Person.House();
		
		//②创建非静态内部类的对象：必须先创建外部类的对象，通过外部类的对象调用内部类的构造器
		Person person = new Person();
		Person.Tool ptool=person.new Tool();
		
		ptool.showTool();
		/*ptool.showTool();
		 * 内部类Tool调用外部类的show()方法
         * 外部类的信息显示show()！
		 */
		ptool.setName("ptool name");
		/*ptool.setName("ptool name");
		ptool name
		Tool name
		Person name
		*/
	}
}
class Person{
	int id;
	String name="Person name";
	//成员内部类（非static）
	class Tool{
		String name="Tool name";
		String shape;
		public String getName() {
			return name;
		}
		//当变量重名时，变量的调用
		public void setName(String name) {
			System.out.println(name);
			System.out.println(this.name);
			System.out.println(Person.this.name);
		}
		//内部类调用外部类的方法
		public void showTool() {
			System.out.println("内部类Tool调用外部类的show()方法");
			show();
		}	
	}
	//成员内部类（static内部类）
	static class House{
		String name;
		String address;	
	}
	public void show() {
		System.out.println("外部类的信息显示show()！");
	}
}

2、局部内部类（不谈修饰符）、匿名内部类 —— 声明在类的方法内

/**
局部内部类的使用
*/
class OuterClass{
	//局部内部类
	//使用方式较少
	public void method1() {
		class InnerClass{
			
		}
	}
	//常常使用一个方法，使其返回值为某个类或某个接口的对象。而这个类或接口在方法内部创建
	//示例一：Cpmparable接口为返回值
	public Comparable getComparable() {
		//创建一个是实现Comparable接口的类：局部内部类
		class MyComparable implements Comparable{

			@Override
			public int compareTo(Object arg0) {
				// TODO Auto-generated method stub
				return 0;
			}
			
		}
		//返回一个实现类的对象
		return new MyComparable();	
	}
	//示例二、匿名内部类
	public Comparable getComparable1() {
		//返回一个实现Comparable接口的匿名内部类的对象
		return new Comparable() {
			@Override
			public int compareTo(Object arg0) {
				// TODO Auto-generated method stub
				return 0;
			}
		};
	}
}

匿名类 

 

//匿名类示例

public class Inner_ClassTest2 {
	public static void main(String[] args) {
        //匿名类
		PersonTest persontest = new PersonTest() {
			@Override
			public String toString() {
				// TODO Auto-generated method stub
				System.out.println("这是匿名内部类的toString()!");
				return super.toString();
			}
			
		};
		persontest.toString();
		/*persontest.toString();
		 * 这是匿名内部类的toString()!
		 * PersonTest类
		 */
	}
	
}
class PersonTest{
	
	@Override
	public String toString() {
		System.out.println("PersonTest类");
		return "";
	}
	
	
}

面向对象总结

• 面向对象的三条主线：

1. 类与类的成分

2. 面向对象的三大特性

3. 其他的关键字：this、super、import、package、abstract、static、final、interface等

************************************************************
//1、java程序关注类的设计。
//类从代码的角度：并列关系！
//从执行、设计的角度：关联关系、继承关系、聚合关系

class A{}
class B{ A a = new A(); }
************************************************************
//2、类的成分：属性、方法、构造器、代码块、内部类
    /*2.1 属性：
    ①变量的分类：
        成员变量（属性 Field） VS 局部变量 （方法的形参、方法内部、代码 块内部）
        基本数据类型（8种） VS 引用数据类型（数组、类、接口，默认初始值为null）
    ②属性的声明格式：修饰符 数据类型 变量名 = 初始化值;  //java是强数据类型的语言
    ③对属性赋值的操作：
        i.默认初始化; 
        ii.显式的初始化; 
        iii. 代码块的初始化; 
        iv. 构造器的初始化; 
        v.调用方法、属性进行赋值
*/
    /*2.2 方法：
    ①格式：修饰符 （其他的关键字：static/final/abstract）返回值类型 方法名 （形参列表） { //方法体 }
    ②方法的重载（overload） VS 方法的重写（override、overwrite）
    ③方法的参数传递机制：值传递
        
*/
    /*2.3 构造器：
    ①构造器的作用：i.创建类的对象; ii. 初始化对象的成员变量
    ②构造器也可以重载
*/
    /*2.4 代码块
    ①主要作用：用来初始化类的成员变量
    ②分类：静态的代码块 VS 非静态的代码块
*/
    /*2.5 内部类
    ①分类：成员内部类（static的成员 VS 非static的成员） VS 局部内部类（方法内部声明的类）
    ②掌握：
        i.如何创建成员内部类的对象
        ii.如何区别调用外部类、内部类的变量（尤其是变量重名时）
        iii.局部内部类的使用
*/
**************************************************************
//3、类的初始化（创建类的对象）

    /*3.1 如何创建类的对象*/
    /*3.2 内存解析：
       ①
         i. 栈：局部变量、对象的引用名、数组的引用名
        ii.堆：new 出来的“东西”
        iii.方法区：字符串常量池
        iv.静态域：存放类中静态的变量
        ②如何理解创建的对象在内存中的加载的过程（理解）
**************************************************************
//4、面向对象的三大特性：
    /*4.1 封装性：
        ①私有化类的成员变量
        ②可以对类的其他结构进行“封装”
        ③权限修饰符： public、protected、default、private
    /*4.2 继承性
        通过让一个类A继承另一个类B，就可以获取类B种的结构（主要的：属性、方法、构造器）。子类：A；父类：B
    /*4.3 多态性
        ①体现：方法的重载和重写 ； 子类对象的多态性； 
        ②子类对象多态的使用：虚拟方法调用
        ③向上转型、向下转型

**************************************************************
//5、其他关键字：
    /*5.1 this:修饰属性、方法、构造器。表示：当前对象或当前正在创建的对象
    /*5.2 super:修饰属性、方法、构造器。显式地调用父类的相应的结构，尤其是子父类有重名的方法、属性。
    /*5.3 static:修饰属性、方法、代码块、内部类。随着类的加载而加载。
    /*5.4 final：修饰类、属性、方法。表示“最终的”
    /*5.5 abstract:修饰类、方法
    /*5.6 interface:表示是一个接口，（接口是与类并列的一个结构）。类与接口之间同时“implements”发生关系。
>>>abstract不能修饰属性、构造器、不能与final、static、private共用。

*/

 

 

【注】

本文章属个人整理学习使用，如有不当之处望联系指正或删除。

【学习视频来源】尚硅谷http://www.atguigu.com/