Thread: Help with Anonymous Inner class

Hi, I'm trying to practice with anonymous inner classes, so I written a simple Dog class, AnonymousInnerClass class that uses Dog as an anonymous inner class and the main method in class: AnonymousInnerCLassRunner, my question is why does it all compile and run but how do I get it to invoke the new_dog_method() which houses the anonymous inner class?a
Also, I created another instance of AnonymousInnerClass, but when I recompile, I still have the one: AnonymousInnerClass$1.class, but there isn't:AnonymousInnerClass$2.class created though so it it shared?

AnonymousInnerClass class

import java.util.*;
 
public class AnonymousInnerClass
{
	private int outer_num;
 
	public AnonymousInnerClass(int n)
	{
		this.outer_num = n;
	}
 
	public int getOuterNum(){return this.outer_num;}
 
	public void setOuterNum(int n){this.outer_num = n;}
 
	public void zing()
	{
		final String hero = "Snoopy";
		Dog d = new Dog("Ash Ketchum")
		{
			public void new_dog_method()//How do I call this in AnonymousInnerClassRunner? I thought anonymous inner class is extending my Dog class?
			{
				System.out.println(hero);
				System.out.println("ABC");
				System.out.println("123 and so forth");
			}
		};
 
		System.out.println("output inside zing method but outside anonymous inner class");
	}
 
	public void sing()
	{
		System.out.println("Singin' in the rain!");
	}
}

AnonymousInnerClassRunner (main method, but why doesn't program output the statements inside the new_dog_method() method?)

import java.util.*;
 
public class AnonymousInnerClassRunner
{
	public static void main(String[] args)
	{
		AnonymousInnerClass a = new AnonymousInnerClass(89);
		a.zing();//this works, but it doesn't output statements inside new_dog_method()
		// a.zing().new_dog_method()//this doesn't work...
		a.zing();//this outputs fine
		a.sing();//this outputs fine
 
                AnonymousInnerClass aa = new AnonymousInnerClass(89);
		aa.zing();//Q: why isn't AnonymousInnerClass$2.class created?
	}	
}

Dog class, just a regular class

import java.util.Random;
 
public class Dog//I'm using this to test anonymous inner classes (assuming this class is 'useless' on its own)
{
	private String owner;
	private String breed;
	private int breed_num;
 
	//an index b/t 0 and 8
	private String breed_arr[] = {"weiner", "husky", "blood hound", "poodle", "golden retriever", "bull dog", "great dane", "pommeranian", "dalmation"};
 
 
	public Dog(String o)
	{
		this.owner = o; 
 
		//randomly choose a breed
		Random r = new Random();
 
		breed_num = r.nextInt( breed_arr.length );//size is 9 so: random val % 9 gives a value b/t [0 - 8]
 
		this.breed = breed_arr[ breed_num ];
	}
 
	public int getBreedNum(){return this.breed_num;}
 
	public void setOwner(String name){this.owner = name;}
 
	public String getBreed(){return this.breed;}
 
	public void bark(int breed_num)
	{
		switch(breed_num)
		{
			case 0:
			{
				System.out.println("wimper!");
				break;
			}
			case 1:
			{
				System.out.println("Husk husk!");
				break;
			}
			case 2:
			{
				System.out.println("bark bark!");
				break;
			}
			case 3:
			{
				System.out.println("poof, poof...");
				break;
			}
			case 4:
			{
				System.out.println("Ruff, ruff!");
				break;
			}
			case 5:
			{
				System.out.println("GRRRRR!");
				break;
			}
			case 6:
			{
				System.out.println("Roooof!");
				break;
			}
			case 7:
			{
				System.out.println("brrark");
				break;
			}
			case 8:
			{
				System.out.println("Woof, woof!");
				break;
			}
			default:
			{
				System.out.println("bark!");
				break;
			}
		}
 
	}
}

but how do I get it to invoke the new_dog_method()

You can't.

There is nothing to stop an anonymous class extending a "normal" class - like your anonymous class extends Dog - and the anonymous can create some more methods. But, to call those methods (from outside the anonymous class itself) you would have to declare a variable whose type was the anonymous class. And you can't do that because ... the anonymous class doesn't have a name!

Typical usage of anonymous classes is where they extend (/implement) an abstract class (/interface) or a class with very little functionality. What they do is add the implementation of methods that have already been declared by the class (/interface) they are extending (/implementing). They are typically also very brief otherwise the logic gets quite tangled, quite quickly.

---

Your AnonymousInnerClass has an odd name, in as much as it *isn't* an anonymous inner class: it has a name, so it's not anonymous.

Actually I wanted the Dog class to be the anonymous inner class, I think that's what you meant and I understand the poorly named class of: AnonymousInnerClass. So if use of anonymous inner is to extend functionality or honor a contract if implementing an interface (so to define all methods), what's the point of using anonymous inner classes if the overridden methods or implemented methods of an interface can't be invoked?

I found online that they come in handy w/ event-driven programming so Swing for example where it saves time from typing to register a listener as in;

button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e)
    {
        // do something.
    }
});

and with this button registered as a listener, it is implementing the ActionListener interface (which has only one method to implement as part of contract when implementing any interface (unless you use adapters, another story) ), but actionPerformed is not invoked manually by the user, me, but done automatically whenever this button is clicked. But my Dog class is user-defined and so I can't call the new_dog_method() so just curious