内部类：定义在A类内部的B类就是内部类，B类在A类的地位与其它的成员相同，大家可以互相调用
package com.qianfeng.test;
/*
* 内部类：定义在A类内部的B类就是内部类，B类在A类的地位与其它的成员相同，大家可以互相调用
*/
public class Demo4 {
public static void main(String[] args) {
//调用内部类的方法
//第一种方式：借助外部类的方法调用，实现内部类对象的调用
Outer outer = new Outer();
outer.show();
//第二种方式：直接实现内部类
//创建内部类对象的方式：外部类的对象.new 内部类的构造方法
//Outer.Inner:获取内部类的方式
Outer.Inner inner = outer.new Inner();
inner.play();
}
}
class Outer{
int age;
class Inner{//内部类
int height;
public void play(){
System.out.println("Inner-play");
}
}
public void show(){
//借助外部类的方法调用，实现内部类对象的调用
Inner inner = new Inner();
inner.play();
System.out.println("show");
}
}
//实例：通过内部类可以让java间接实现多继承
class A{
}
class B{
}
class X extends A{
class Y extends B{
}
}
局部内部类:定义在一个类方法中的类
package com.qianfeng.test;
import com.qianfeng.test.Outer.Inner;
/*
* 局部内部类:定义在一个类方法中的类
*
* 作用范围:从定义局部内部类开始到show方法结束
*
* 作用:对于当前局部内部类所在的方法,相当于将他的一部分功能面向对象了.形成了局部内部类,这样即保证了代码的私有化,又
* 对代码进行了重新的整理,增加了代码的可读性,可操作性,简化代码,增加了复用性.
*
* 了解:
* show方法中与局部内部类地位等同的局部变量的使用规则
*
*
* * 了解:局部内部类所在的方法中局部变量的使用.
* 局部变量的作用域:定义变量开始到函数结束
* final:被final修饰的变量会被放在常量区,而常量区的值存在的时间要大于局部变量所在的方法,相当于从原来的基础上扩大了作用域
*
* 原理:
* 当方法中同时存在局部内部类与成员变量时,成员变量的使用范围就会从原来的基础上进行扩大.
* 原因:在当前的情况下,程序会默认让final去修饰height.所以当局部变量所在的方法结束的时候,变量没有被释放,保存的值还在.
*
* 关于变量前面的final:
* 前提:变量必须与局部内部类同时存在.
* 在jdk1.7之前要想保住局部变量的值,要手动添加final
* 在jdk1.7之后,java的内部机制已经在变量的前面默认添加了final
*/
public class Demo5 {
public static void main(String[] args) {
}
}
class Outer1{
int age;
public void show(){
int weight;
class Inner{//局部内部类
int height;
public void play(){
System.out.println("Inner-play");
}
}
//在外部类的方法中调用内部类
Inner inner = new Inner();
inner.play();
System.out.println("Outer1-show");
}
}
//实例:要求:将两个小功能变成play的私有功能
//我们通过局部内部类实现了功能的私有化,并对方法内部的代码进行了整理,增强了代码的可读性和可操作性.
class Test{
public void play(){
//因为方法的定义之间是不能嵌套的,所以必须通过局部内部类实现.
// public void gongneng1(){
// System.out.println(“gongneng1”);
// }
//
// public void gongneng2(){
// System.out.println(“gongneng2”);
// }
//使用局部内部类
class Inner{
public void gongneng1(){
System.out.println(“gongneng1”);
}
public void gongneng2(){
System.out.println("gongneng2");
}
}
Inner inner = new Inner();
inner.gongneng1();
inner.gongneng2();
}
public void show(){
//无法调到.因为:两个方法是play方法的局部内部类方法,只对play可见
// gongneng1();
// gongneng2();
}
}
局部内部类小demo。tostring的值可以取到7，所以说明局部变量的值被存住了。
package com.qianfeng.test;
public class Demo6 {
public static void main(String[] args) {
Outer2 outer2 = new Outer2();
outer2.show();
outer2.test();
}
}
//模拟jdk1.7之前局部变量之前会加final的情况–局部变量的值会被存住
class Outer2{
int age;
Object object = null;
public void show(){
int weight = 7;
class Inner{//局部内部类
int height;
public void play(){
System.out.println("Inner-play");
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "tostring"+weight;
}
}
//在外部类的方法中调用内部类
object = new Inner(); //多态
}
public void test(){
System.out.println(object.toString());
System.out.println("test");
}
}
静态内部类
package com.qianfeng.test;
/*
* 了解：
* 静态内部类：
*
* 注意点：
* 1.静态内部类中可以没有静态成员
* 2.有静态成员的一定是静态内部类
*
*/
public class Demo7 {
public static void main(String[] args) {
//工作：
//静态的对象
//注意：要保证内部类本身是静态的
//构成：new 外部类.内部类的构造方法
Outer3.Inner inner = new Outer3.Inner();
//调用方法
inner.play();
inner.show();
Outer3.Inner.show();
}
}
class Outer3{
static int age;
static class Inner{//静态内部类
//非静态的方法
public void play(){
System.out.println("非静态方法-play");
}
//静态的方法
public static void show(){
System.out.println("静态方法-show");
}
}
}
匿名内部类(对象):定义在一个类方法中的匿名子类对象,属于局部内部类
package com.qianfeng.test;
/*
* 等级:中
* 匿名内部类(对象):定义在一个类方法中的匿名子类对象,属于局部内部类
*1. 匿名子类对象
*2. 匿名的内部类对象
*
* 创建匿名内部类对象注意点:1.匿名内部类对象必须有父类或者父接口
*
匿名内部类对象的作用:
* 1.当只用到当前子类的一个实例对象的时候,定义好马上使用
* 2.当不好起名字的时候
* 3.可以更好的定义运行时的回调(知道即可)
*
* 内部类的作用:
* 1.间接实现了多继承
* 2.方便定义
* 3.只有外部类可以访问创建的内部类的属性和方法,包括私有方法
* 4.同一个包中其他的类不可见,有了很好的封装性
*
*/
public class Demo8 {
public static void main(String[] args) {
// //研究匿名子类对象
// //创建匿名对象,完成方法的调用
// new Tests().testsMethod();
//
// //创建匿名子类对象
// //第一种方式
// //使用已有的子类生成匿名子类对象
// //使用场景:现成的子类可以使用多次,当相同的功能需要调用多次的时候.
// new SubTests().testsMethod();
//
// //第二种方式
// //直接创建没有名字的Tests类的匿名子类对象
// //构成:new + 父类的类名/父接口的名字+()+{匿名子类的执行体};
// //使用场景:只能使用一次,使用完立即释放,适合于每次都需要不同的功能
// new Tests(){
// @Override
// public void testsMethod() {
// System.out.println(“没有名字-testsMethod”);
// }
// //自己的方法
// public void play(){
// System.out.println(“没有名字-play”);
// }
// }.play();
//研究匿名内部类对象
Out out = new Out();
out.show();
out.testCanshu1();
out.testCanshu2();
Tests tests1 = out.testFanhuizhi1();
System.out.println(tests1);
Tests tests2 = out.testFanhuizhi2();//多态
tests2.testsMethod();
//tests2.play();//无法调用,play是子类特有的方法
System.out.println(tests2);
}
}
//创建一个类研究匿名子类对象
class Tests{
public void testsMethod(){
System.out.println(“Tests-testsMethod”);
}
}
class SubTests extends Tests{
@Override
public void testsMethod() {
System.out.println(“SubTests-testsMethod”);
}
}
//研究匿名内部类
class Out{
public void show(){
new Tests(){//匿名内部类
@Override
public void testsMethod() {
System.out.println(“没有名字-testsMethod”);
}
//自己的方法
public void play(){
System.out.println(“没有名字-play”);
}
}.play();
}
//普通的匿名对象充当参数
public void testCanshu1(){
System.out.println(new Tests());
}
//使用匿名的子类对象充当参数
public void testCanshu2(){
System.out.println(
new Tests(){
@Override
public void testsMethod() {
System.out.println("没有名字-testsMethod");
}
//自己的方法
public void play(){
System.out.println("没有名字-play");
}
@Override
public String toString() {
return "冰冰真漂亮!";
}
}
);
}
//普通的匿名对象做返回值
public Tests testFanhuizhi1(){
return new Tests();
}
//使用匿名内部类充当返回值
public Tests testFanhuizhi2(){
return new Tests(){
@Override
public void testsMethod() {
System.out.println("没有名字-testsMethod");
}
//自己的方法
public void play(){
System.out.println("没有名字-play");
}
@Override
public String toString() {
return "冰冰真漂亮!";
}
};
}
//练习:创建接口的匿名内部类
}
