An add method to add objects in your custom java class

List<Object> weapons = new ArrayList<Object>();    

weapons.add(new Sword());     
weapons.add(new Gun());

try this.

You don't necessarily have to do a new Gun() when you instantiate. You can just do the following:

class Weapon
{
    private Gun gun;
    public Weapon()
    {
        gun = new Gun(); //etc.
    }
    //add more methods here. You can use gun.function() to invoke any functions
}

As for using a Weapon object, just declare public methods in the Weapon class and then invoke them in your methods.

For example, the add() function:

class Weapon
{
    ...
    public int val() { return 0; } // don't know, some random method.
}

Then on a different file:

int add(Weapon w)
{
    return Weapon.val() + 1111; //perform something here
}

I hope this answers your questions, it was a little bit unclear :|. Comment if you need more help.

Your question is a bit unclear to me, but I'll try my best.

If you want to have a List of Weapon, then you need to use inheritance. In your example, A Gun is-a Weapon. Therefore, you can do class Gun extends Weapon. Then, let's say you're using an ArrayList, you would instantiate it like:

List<Weapon> weapons = new ArrayList<Weapon>();

You can now call add with a Gun, or any other sub-class of Weapon like so:

weapons.add(new Gun()); //or
weapons.add(new Cannon());

If you actually need to add a Gun to a Weapon (Which doesn't really make sense...), you can use composition. See Shahar's answer for a more detailed explanation of this behavior.

Just to clarify, no matter what, I'm pretty sure creating a new Collection is not what you want to do here.

These are a lot of questions :-) let's enumerate them

1. creating a method called add() into an object makes this object a Collection? No. To be a Collection, a class must implement the interface java.util.Collection or implement any one of the subinterfaces or extend any of the subclasses that implement this interface. A list of them is available in the Collection javadoc - http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html
2. if I want to add an object into another, it must be via the constructor? e.g. new Weapon(new Gun())? Not necessarily. You can just create a Weapon w = new Weapon() and then add the Gun reference via a method such as w.setGun(new Gun()). Anyway, any constructor with one or more parameters must be declared explicitly in your class. Only the non-parameter constructor is available by default.

Now, let's suppose that you want to store a class Gun that is a subclass of a class Weapon. Then you first need to define the hierarchy between them, for example

class Weapon{       
}

class WeaponWithBlade extends Weapon{       
}

class Sword extends WeaponWithBlade{        
}

class Knife extends WeaponWithBlade{        
}

class Gun extends Weapon{       
}

and then you want to store all these weapons in a Weapon collection.

since all of them are subclasses of the Weapon class, it's valid to do something like this

    java.util.List<Weapon> weapons = new java.util.ArrayList<>();
    weapons.add(new Sword());
    weapons.add(new Gun());

notice that both List and ArrayList are collections (List is an interface and ArrayList is a concrete class that implements the List interface), parametrized to be collections of Weapons.

I hope this can help you.