views:

202

answers:

6

I try to encapsulate. Exeption from interface, static inner class working, non-static inner class not working, cannot understand terminology: nested classes, inner classes, nested interfaces, interface-abstract-class -- sounds too Repetitive!

BAD! --- Exception 'illegal type' from interface apparently because values being constants(?!)

    static interface userInfo
    {
            File startingFile=new File(".");
            String startingPath="dummy";
            try{
                    startingPath=startingFile.getCanonicalPath();
            }catch(Exception e){e.printStackTrace();}
    }

MANY WAYS TO DO IT: Interface, static inner class image VS non-static innner class image

import java.io.*;
import java.util.*;

public class listTest{
        public interface hello{String word="hello word from Interface!";}

        public static class staticTest{
                staticTest(){}
                private String hejo="hello hallo from Static class with image";
                public void printHallooo(){System.out.println(hejo);}
        }
        public class nonStatic{
                nonStatic(){}
                public void printNonStatic(){System.out.println("Inside non-static class with an image!");}
        }
        public static class staticMethodtest{
                private static String test="if you see mee, you printed static-class-static-field!";
        }

        public static void main(String[] args){
                //INTERFACE TEST
                System.out.println(hello.word);
                //INNNER CLASS STATIC TEST
                staticTest h=new staticTest();
                h.printHallooo();
                //INNER CLASS NON-STATIC TEST
                nonStatic ns=(new listTest()).new nonStatic();
                ns.printNonStatic();
                //INNER CLASS STATIC-CLASS STATIC FIELD TEST
                System.out.println(staticMethodtest.test);
        }
}

OUTPUT

hello word from Interface!
hello hallo from Static class with image
Inside non-static class with an image!
if you see mee, you printed static-class-static-field!

Related

A: 

You can't have actual code in an interface, only method signatures and constants. What are you trying to do?

Matthew Flaschen
+1  A: 

you cant put code in an interface, an interface only describes how an object will behave. Even when you use Classes, you should put this kind of code in a method, and not directly in the class body.

MeBigFatGuy
`s/should/must/` and `s/method/method, constructor or initializer block/`
Joachim Sauer
A: 

You cannot have code in interfaces. Just method signatures. Top level interfaces cannot be static.

I suggest you start your learning of Java here.

Strelok
Interfaces *can* be static.
Matthew Flaschen
Well, not a top level interface. I edited my answer.
Strelok
A: 

Looks like you want to write a class here.

fastcodejava
+2  A: 

I think you wanted to do this:

static class userInfo
    {
         public static void something() {
            File startingFile=new File(".");
            String startingPath="dummy";
            try{
                    startingPath=startingFile.getCanonicalPath();
            }catch(Exception e){e.printStackTrace();}
         }
    }
LucaB
+2  A: 

The problem is that you're writing code outside of a method. You do need a class for this and you must put your code inside a method. For example:

static class UserInfo
{
    public static void myMethod()
    {
        File startingFile = new File(".");
        String startingPath = "dummy";
        try
        {
            startingPath = startingFile.getCanonicalPath();
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
}

This does assume that java.io.File was imported.

You can then call UserInfo.myMethod();

You might also want to import java.util.IOException and catch an IOException instead of a general Exception.

Also, classes and interfaces start with a capital letter by Java conventions.

EDIT: To describe your recent comment on your question:

Use an interface when you want to force similar classes (Think different types of DVD players) to have the same basic functionality (playing dvds, stopping, pausing. You use an abstract class similarly, but when all of the classes will implement some of the same things the same way.

Jazzy Josh