I've compiled a working example of all of this here. Go ahead and play with the classes. Feel free to reply to this or message me with any further questions.

I had a similar problem. I had been coding procedurally for about a decade and then had to learn Java. I found that it was the concept of OOP that gave me the trouble. Once I conceived of it, it all made sense. Since you said you're trying to learn Java, let me try to explain OOP with Java examples.

OOP programmers tend to slowly become obsessed with the classification (or "class") of things. There's a term "ISA" that becomes fairly important. It's the conjunction of the phrase "is a". To say "A ISA B" is to say that A is a special kind of B. For example, a poodle ISA dog. A dog ISA mammal. A mammal ISA animal. You can alos jump levels and say a poodle ISA animal. The idea behind OOP is that everything ISA object.

If I wanted to make this system in Java, I would write:

class Animal { //there is an implicit "extends Object" after "Animal"
    //class definition
}
class Mammal extends Animal {
    //class definition
}
class Dog extends Mammal {
    //class definition
}
class Poodle extends Dog {
    //class definition
}

If I also needed a Human in my program, I would also create:

class Human extends Mammal {
    //class definition
}

The other term is HASA (which is the conjunction of the phrase "has a"). A poodle HASA hair color (because Mammals have hair). It also HASA lifespan (because all Animals HASA lifespan). To represent this information, I would write:

class Animal { //there is an implicit "extends Object" after "Animal"
    float lifespan; //in years
}
class Mammal extends Animal {
    Color hairColor; //Java provides the Color class
}
class Dog extends Mammal {
    //class definition
}
class Poodle extends Dog {
    //class definition
}

Now, as for functions (or "methods", as they're called in Java), there are also things that each level of the classifications system can do. For instance, a Dog can bark, but an Animal can't necessarily bark (unless it ISA Dog). However, all Animals eat. Let's say we also have defined (somewhere else) something called "Food" (that way, we have something we can pass to the eat method, to specify what the Animal is eating). If we add these functions, we get:

class Animal { //there is an implicit "extends Object" after "Animal"
    float lifespan; //in years

    void eat(Food theFoodItem){
        System.out.println("Mmmm... I love eating "+theFoodItem.productName);
    }
}
class Mammal extends Animal {
    Color hairColor; //Java provides the Color class
}
class Dog extends Mammal {
    void bark(){
        System.out.println("woof.");
    }
}
class Poodle extends Dog {
    //class definition
}

If we had the above code (and we had "Food" defined somewhere), we could write the following:

Poodle fido = new Poodle();
fido.bark(); //outputs "woof"
Food fish = new Food("fish");
fido.eat(fish); //outputs "Mmmm... I love eating fish"

Now, fido can only bark() because it ISA Dog. You could also write "Animal fido = new Poodle()" (and why not? I mean, fido represents an Animal and a Poodle ISA Animal, right?). However, if you store fido into an Animal variable, you won't be able to get him to bark() (because Animals can't bark). You could, however, still get him to eat, because Animals eat.

Let's say you had a different type of dog, a Pitbull, like so:

class Pitbull extends Dog {
    //class definition
}

You can replace "Poodle" with "Pitbull" in the above code and it would behave in the same exact manner, because a Pitbull can do everything a Poodle can do. But let's say that a Pitbull had a distinct bark, different from most Dogs. Let's say that rather than a Pitbull going "woof", it went "bazinga". You could specify this in the following manner:

class Animal { //there is an implicit "extends Object" after "Animal"
    float lifespan; //in years

    void eat(Food theFoodItem){
        System.out.println("Mmmm... I love eating "+theFoodItem.productName);
    }
}
class Mammal extends Animal {
    Color hairColor; //Java provides the Color class
}
class Dog extends Mammal {
    void bark(){
        System.out.println("woof.");
    }
}
class Poodle extends Dog {
    //class definition
}
class Pitbull extends Dog {
            void bark(){
        System.out.println("bazinga.");
    }
}

After defining those classes, you can run the following code:

Poodle fido = new Poodle();
fido.bark(); //outputs "woof"
Food fish = new Food("fish");
fido.eat(fish); //outputs "Mmmm... I love eating fish"

And you would get the output:

woof
Mmmm... I love eating fish

However, if you replace "Poodle fido = new Poodle();" with "Pitbull fido = new Pitbull();", like so:

Pitbull fido = new Pitbull();
fido.bark(); //outputs "bazinga"
Food fish = new Food("fish");
fido.eat(fish); //outputs "Mmmm... I love eating fish"

You would get the output

bazinga
Mmmm... I love eating fish.

Now, if you change that line to "Dog fido = new Pitbull();", it would still output "bazinga" when you call "fido.bark();" because that's what Pitbulls do when they bark. It's a Dog, so Java knows it can bark. The Pitbull object knows how to bark. If you had written "Animal fido = new Pitbull();" and then tried to do a "fido.bark();", it wouldn't even compile. Java would say "Animals can't bark".