package com.cn.tt;

abstract class T{
    int a;
    abstract void test();
    T(int a){
        this.a=a;
    }
}
public class Test{
    int a=1;
    public static void main(String[] args)
    {
        
        new T(6){
        //int a=3;
            void test(){
                System.out.println("heheheh"+a);
        }
        }.test();
    }
}
抽象类可以有构造器用来初始化数据，由于有抽象方法所以不可以直接通过new

关键字来创建对象。在Test类中创建了 new T（6）{ ……} 这个 没有引用对象，类型应该是子类类型吧？还能调用test

（）方法？test（）方法访问了抽象类中的数据a，main方法是静态的，匿名对象怎么能成功访问到非静态的数据？这是怎么样的一个过程？

abstract class T{
    int a;
    abstract void test();
    T(int a){
        this.a=a;
    }
}
public class Test{
    int a=1;
    public static void main(String[] args)
    {
        
        new T(6){
        //int a=3;
            void test(){
                System.out.println("heheheh"+a);
        }
        }.test();
    }
}
匿名内部类。
就是内部类的简写格式。
必须有前提：
内部类必须继承或者实现一个外部类或者接口。

匿名内部类：其实就是一个匿名子类对象。
格式：new 父类or接口(){子类内容};
调用匿名内部内的方法：new 父类or接口(){子类内容}.方法();

- -!编译和运行都没问题啊。
new T(6){
        //int a=3;
            void test(){
                System.out.println("heheheh"+a);
        }
        }.test();
你都采用了匿名内部类，传了一个6进去。输出结果是：heheheh6；。
而且匿名内部类大部分只用于作为实际参数进行传递。- -不太明白你的意思

匿名内部类其实是一个匿名子类对象，可以理解为带内容的对象。
1.匿名内部类其实就是内部类的简写格式。new 父类或者接口（）{定义子类的内容}
2.定义匿名内部类的前提：
内部类必须是继承一个类或者实现接口。
可以把代码改成内部类，你的问题就一目了然了。

1. class Inner extends T{
   
2.                 int a=3;
   
3.                 Inner(int a){
   
4.                         super(a);
   
5.                 }
   
6.                 void test(){
   
7.                 System.out.println("heheheh"+a);
   
8.                
   
9.         }
   
10.                
    
11.         }
    
12.         new Inner(6).test();

复制代码

这是匿名内部类的问题，当你new T(6){
         //int a=3;
             void test(){
                 System.out.println("heheheh"+a);
         }
         }.test();时，实际上是匿名了一个类，后面{}的内容是这个类的对父类的继承，复写父类的方法，所以程序运行时，会先走父类，然后走子类，至于调用.text()方法，是匿名的类调用的。

陈汉维 发表于 2012-7-30 15:16
abstract class T{
    int a;
    abstract void test();

匿名内部类。
就是内部类的简写格式。
必须有前提：
内部类必须继承或者实现一个外部类或者接口。
你好，我是把它的抽象方法的实现写在了另一个类里面 ，怎么能叫匿名内部类？ 好像也没有明显的标明实现接口和继承吧？ 这个到底应该怎么称呼？

周坤 发表于 2012-7-30 15:40
匿名内部类其实是一个匿名子类对象，可以理解为带内容的对象。
1.匿名内部类其实就是内部类的简写格式。new ...

1.匿名内部类其实就是内部类的简写格式。new 父类或者接口（）{定义子类的内容}


父类是抽象的 new却可以创建子类对象 ，为什么？

涂金哲 发表于 2012-7-30 16:12
1.匿名内部类其实就是内部类的简写格式。new 父类或者接口（）{定义子类的内容}

多态向上转型，
父类的引用创建的子类的对象，理解下多态就明白了吧。

楼上的没明白楼主的意思，我之前跟楼主有同样的疑惑。楼主是说，Test这个类的主方法是静态的，既然静态方法只能调用非静态成员，那T这个类的test（）方法是非静态的，main方法为什么可以调用它。楼主可以想一下，如果是那样考虑的话，每个程序运行都得从main开始，那岂不是只要main方法需要用到别的类，那这个类的所有成员都得是静态的了？实际上，只是在main方法所在的类里的方法，才必须是静态，比如上面的代码写成这样就会报静态调用非静态错误了：
public class Demo2{
    int a=1;
    public static void main(String[] args)
    {
         test();
    }

    void test(){
        System.out.println("heheheh"+a);//test与main方法都在Demo2类中，test方法必须是静态的
    }

}

之所以main方法可以调用其他类的非静态方法，是因为你调用之前你肯定得先在main方法里创建一个那个类的对象，那那个类就被实例化了，也就是说要么调用与被调用两个方法都是静态，要么创建类的对象再用。所以上面的代码改成下面这种形式也不会出现错误：
public class Demo2{
    int a=1;
    public static void main(String[] args)
    {

         Demo2 d = new Demo2();//在本类内部创建本类自己的对象，加上这句就可以调用下面那个非静态方法test()了
         test();
    }

    void test(){
        System.out.println("heheheh"+a);//test与main方法都在Demo2类中，test方法必须是静态的
    }

}