I am fairly new to coding please help me understand how to use inheritance in android with Java. Let me explain my question with an example :
Like there is a parent class called "Animal" which includes "name" and "age" and has two subclasses "Dog" and "Cat". The "Dog" class has "name", "age", "food" and the "Cat" class has "name", "age", "breed" as their attributes.
From my understanding the best practice is to make:
Animal class with the attribute of "name", "age" + constructor and getter and setter
public class Animal{
private String name;
private int age;
public Animal() {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
Dog class extends of Animal class with an attribute of "food" and put getter and setter
private String food;
public String getFood() {
return food;
}
public void setFood(String food) {
this.food = food;
}
}
Cat class extends of Animal class with an attribute of "breed" and put getter and setter
private String breed;
public String getBreed() {
return breed;
}
public void setBreed(String breed) {
this.breed = breed;
}
}
MainActivity should be like
public class MainActivity extends AppCompatActivity {
ArrayList<Animal> mAnimal = new ArrayList<>();
#Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Dog dog = new Dog();
dog.setName("The Dog");
dog.setAge(2);
dog.setFood("Bone");
Cat cat = new Cat();
cat.setName("The Cat");
cat.setAge(1);
cat.setBreed("Persian");
mAnimal.add(dog);
mAnimal.add(cat);
}
}
Now Since there are three classes and each class has a different attribute, How to implement listview to show a list of all animals and their foods or breeds (depends on which one they have) in Mainactivity?
I would really appreciate your answers in advance
Your question Refers to Inheritance but also to polymorphism.
create a super class and sub classes
class Animal {
protected String name;
protected int age;
public void animalSound() {
System.out.print("The animal makes a sound");
}
}
class Cat extends Animal {
private boolean isLivesAtHome;
//getters & setters
//override function from super class
public void animalSound() {
System.out.print("The Cat says meow");
}
}
class Dog extends Animal {
private boolean isWasVaccinatedAgainstRabies;
//getters & setters
//override function from super class
public void animalSound() {
System.out.print("The dog says bow wow");
}
}
run this on Main function like this:
class Main {
public static void main(String[] args) {
Animal myAnimal = new Animal(); // Create a Animal object - Super Class
Animal myCat = new Cat(); // Create a Cat object
Animal myDog = new Dog(); // Create a Dog object
ArrayList<Animal> arr = new ArrayList<>();
arr.add(myCat);
arr.add(myDog);
arr.add(myAnimal);
//simple for loop
for (int i = 0; i < arr.size(); i++){
//if the object is a Cat instance
if(arr.get(i) instanceof Cat){
//change Cat instance variable
((Cat)arr.get(i)).setLivesAtHome(true);
System.out.println("I'm a Cat");
}
//print animalSound function
arr.get(i).animalSound();
}
}
}
This code print's:
I'm a Cat
The Cat says meow
The dog says bow wow
The animal makes a sound
This example show Polymorphism and inheritance concept using single ArrayList.
The list is of animals. Of the Super Class type.
A dog is also an animal, a cat is also an animal (by inheritance) so you can add them to the Animal List.
If you want to refer a particular object (like the Cat in the example code), you have to use 'instance of' operator for Casting.
for more info you can read about Inheritance and Polymorphism.
You can do like this or similar to this.
Models:
Animal:
public class Animal {
Dog dog;
Cat cat;
public Animal(Dog dog, Cat cat) {
this.dog = dog;
this.cat = cat;
}
public Animal() {
}
public Dog getDog() {
return dog;
}
public void setDog(Dog dog) {
this.dog = dog;
}
public Cat getCat() {
return cat;
}
public void setCat(Cat cat) {
this.cat = cat;
}
Dog:
public class Dog {
String name;
String age;
String food;
public Dog(String name, String age, String food) {
this.name = name;
this.age = age;
this.food = food;
}
public String getFood() {
return food;
}
public void setFood(String food) {
this.food = food;
}
Cat:
public class Cat {
String name;
String age;
String breed;
public Cat(String name, String age, String breed) {
this.name = name;
this.age = age;
this.breed = breed;
}
public String getBreed() {
return breed;
}
public void setBreed(String breed) {
this.breed = breed;
}
MainActivity.java:
public class TestActivity extends AppCompatActivity {
#Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_test);
Animal animal = new Animal();
animal.setDog(new Dog("tomi", "6","Roti"));
List<Animal> animals = new ArrayList<>();
animals.add(animal);
Log.d("Jay", animals.toString());
}
What you are askings reffers to polymorphism. It means subclass inherits everything from it's superclass.
To achieve what you want you would create your objects like:
Animal dog = new Dog();
((Dog) dog).setBreed("Terrier"); //This is called Casting
...
Animal cat = new Cat();
...
And then in your ListView when showing data you can check if your object is instance of particular object, like this:
if(dog instanceof Dog)
textView.setText(((Dog) dog).getBreed());
Related
public class Pet
{
private String name;
private String type;
public Pet(String n, String t)
{
name = n;
type = t;
}
public String getType(){
return type;
}
public String getName(){
return name;
}
public void speak()
{
System.out.println("grr!");
}
public static void main(String[] args)
{
Pet p = new Pet("Sammy","hamster");
System.out.println(p.getType());
p.speak();
Dog d = new Dog("Fido");
System.out.println(d.getType());
d.speak();
//Cat c = new Cat("Fluffy");
//System.out.println(c.getType());
//c.speak();
}
}
class Dog extends Pet
{
public Dog(String name){
super(name);
}
public void speak(){
System.out.println("Woof");
}
}
// Add a Cat class
How do I add "type" to this without adding another String to my parameter?
I've tried other ways that obviously didn't work but I still tried anyway. So how do I add another object to my super class from Pet without adding more to my parameter?
Constructor with one parameter for the dog class:
public Dog(String name) {
super(name, "dog");
}
I have abstract class Animal and inheritance classes Fish and Dog.
I need to create various objects of fish and dogs and give them names and breeds and also make methods of the way they move.
Finally i need to create an array of them and do 4 random prints that will show their name and breed.
Main Class:
public class JavaApplication38 {
public static void main(String[] args) {
Animal[] arr = new Animal[20];
arr[0] = new Fish("Riby", "Sea Fish");
arr[1] = new Dog("Any", "Great Dane");
arr[2] = new Fish("Ribytsa", "River fish");
arr[3] = new Dog("Jackie", "Pug");
arr[4] = new Fish("Bobi", "Mix");
arr[5] = new Dog("Ruby", "Labrador");
}
}
Animal class
public abstract class Animal {
public Animal(String name, String breed){
}
public Animal(){
}
public abstract void moving();
}
Dog class
Public class Dog extends Animal{
private String breed;
private String name;
public Dog(){
}
public Pas(String name, String breed){
this.name = name;
this.breed =breed;
}
#Override
public void moving() {
System.out.print("Walk\n");
}
}
Fish class
public class Fish extends Animal {
private String breed;
private String name;
public Fish(){
}
public Fish(String name, String breed){
this.name = name;
this.breed= breed;
}
#Override
public void moving(){
System.out.print("Swims\n");
}
}
The question is, what do i have to write in a loop to print names and breeds via array?
The problem was that you defined name and breed separately in each subclass of Animal. You need to make name and breed instance variables in Animal. That way, Java knows that every single Animal has a name and breed.
public abstract class Animal {
private String name;
private String breed;
public Animal(String name, String breed) {
this.name = name;
this.breed = breed;
}
public getName() { return name; }
public getBreed() { return breed; }
public abstract void moving();
}
public class Dog extends Animal {
public Dog(String name, String breed) {
super(name, breed);
}
#Override
public void moving(){
System.out.print("Walks\n");
}
}
public class Fish extends Animal {
public Fish(String name, String breed) {
super(name, breed);
}
#Override
public void moving(){
System.out.print("Swims\n");
}
}
Now you can print the name and breed for any Animal, whether it's a Dog or Fish.
Animal[] arr = new Animal[6];
arr[0] = new Fish("Riby", "Sea Fish");
arr[1] = new Dog("Any", "Great Dane");
arr[2] = new Fish("Ribytsa", "River fish");
arr[3] = new Dog("Jackie", "Pug");
arr[4] = new Fish("Bobi", "Mix");
arr[5] = new Dog("Ruby", "Labrador");
for (Animal a : arr) {
System.out.println(a.getName() + " " + a.getBreed());
a.moving();
}
This question has been asked in a C++ context but I'm curious about Java. The concerns about virtual methods don't apply (I think), but if you have this situation:
abstract class Pet
{
private String name;
public Pet setName(String name) { this.name = name; return this; }
}
class Cat extends Pet
{
public Cat catchMice() {
System.out.println("I caught a mouse!");
return this;
}
}
class Dog extends Pet
{
public Dog catchFrisbee() {
System.out.println("I caught a frisbee!");
return this;
}
}
class Bird extends Pet
{
public Bird layEgg() {
...
return this;
}
}
{
Cat c = new Cat();
c.setName("Morris").catchMice(); // error! setName returns Pet, not Cat
Dog d = new Dog();
d.setName("Snoopy").catchFrisbee(); // error! setName returns Pet, not Dog
Bird b = new Bird();
b.setName("Tweety").layEgg(); // error! setName returns Pet, not Bird
}
In this sort of class hierarchy, is there any way to return this in a way that doesn't (effectively) upcast the the object type?
If you want to avoid unchecked cast warnings from your compiler (and don't want to #SuppressWarnings("unchecked")), then you need to do a little more:
First of all, your definition of Pet must be self-referential, because Pet is always a generic type:
abstract class Pet <T extends Pet<T>>
Secondly, the (T) this cast in setName is also unchecked. To avoid this, use the "getThis" technique in the excellent Generics FAQ by Angelika Langer:
The "getThis" trick provides a way to
recover the exact type of the this
reference.
This results in the code below, which compiles and runs without warnings. If you want to extend your subclasses, then the technique still holds (though you'll probably need to genericise your intermediate classes).
The resulting code is:
public class TestClass {
static abstract class Pet <T extends Pet<T>> {
private String name;
protected abstract T getThis();
public T setName(String name) {
this.name = name;
return getThis(); }
}
static class Cat extends Pet<Cat> {
#Override protected Cat getThis() { return this; }
public Cat catchMice() {
System.out.println("I caught a mouse!");
return getThis();
}
}
static class Dog extends Pet<Dog> {
#Override protected Dog getThis() { return this; }
public Dog catchFrisbee() {
System.out.println("I caught a frisbee!");
return getThis();
}
}
public static void main(String[] args) {
Cat c = new Cat();
c.setName("Morris").catchMice();
Dog d = new Dog();
d.setName("Snoopy").catchFrisbee();
}
}
How about this old trick:
abstract class Pet<T extends Pet>
{
private String name;
public T setName(String name) { this.name = name; return (T) this; }
}
class Cat extends Pet<Cat>
{
/* ... */
}
class Dog extends Pet<Dog>
{
/* ... */
}
No, not really. You could work around it by using covariant return types (thanks to McDowell for the correct name):
#Override
public Cat setName(String name) {
super.setName(name);
return this;
}
(Covariant return types are only in Java 5 and above, if that's a concern for you.)
It's a bit convoluted, but you can do this with generics:
abstract class Pet< T extends Pet > {
private String name;
public T setName( String name ) {
this.name = name;
return (T)this;
}
public static class Cat extends Pet< Cat > {
public Cat catchMice() {
System.out.println( "I caught a mouse!" );
return this;
}
}
public static class Dog extends Pet< Dog > {
public Dog catchFrisbee() {
System.out.println( "I caught a frisbee!" );
return this;
}
}
public static void main (String[] args){
Cat c = new Cat();
c.setName( "Morris" ).catchMice(); // error! setName returns Pet, not Cat
Dog d = new Dog();
d.setName( "Snoopy" ).catchFrisbee(); // error! setName returns Pet, not Dog
}
}
public class Pet<AnimalType extends Pet> {
private String name;
public AnimalType setName(String name) {
this.name = name; return (AnimalType)this;
}
}
and
public class Cat extends Pet<Cat> {
public Cat catchMice() {return this;}
public static void main(String[] args) {
Cat c = new Cat().setName("bob").catchMice();
}
}
This question has been asked in a C++ context but I'm curious about Java. The concerns about virtual methods don't apply (I think), but if you have this situation:
abstract class Pet
{
private String name;
public Pet setName(String name) { this.name = name; return this; }
}
class Cat extends Pet
{
public Cat catchMice() {
System.out.println("I caught a mouse!");
return this;
}
}
class Dog extends Pet
{
public Dog catchFrisbee() {
System.out.println("I caught a frisbee!");
return this;
}
}
class Bird extends Pet
{
public Bird layEgg() {
...
return this;
}
}
{
Cat c = new Cat();
c.setName("Morris").catchMice(); // error! setName returns Pet, not Cat
Dog d = new Dog();
d.setName("Snoopy").catchFrisbee(); // error! setName returns Pet, not Dog
Bird b = new Bird();
b.setName("Tweety").layEgg(); // error! setName returns Pet, not Bird
}
In this sort of class hierarchy, is there any way to return this in a way that doesn't (effectively) upcast the the object type?
If you want to avoid unchecked cast warnings from your compiler (and don't want to #SuppressWarnings("unchecked")), then you need to do a little more:
First of all, your definition of Pet must be self-referential, because Pet is always a generic type:
abstract class Pet <T extends Pet<T>>
Secondly, the (T) this cast in setName is also unchecked. To avoid this, use the "getThis" technique in the excellent Generics FAQ by Angelika Langer:
The "getThis" trick provides a way to
recover the exact type of the this
reference.
This results in the code below, which compiles and runs without warnings. If you want to extend your subclasses, then the technique still holds (though you'll probably need to genericise your intermediate classes).
The resulting code is:
public class TestClass {
static abstract class Pet <T extends Pet<T>> {
private String name;
protected abstract T getThis();
public T setName(String name) {
this.name = name;
return getThis(); }
}
static class Cat extends Pet<Cat> {
#Override protected Cat getThis() { return this; }
public Cat catchMice() {
System.out.println("I caught a mouse!");
return getThis();
}
}
static class Dog extends Pet<Dog> {
#Override protected Dog getThis() { return this; }
public Dog catchFrisbee() {
System.out.println("I caught a frisbee!");
return getThis();
}
}
public static void main(String[] args) {
Cat c = new Cat();
c.setName("Morris").catchMice();
Dog d = new Dog();
d.setName("Snoopy").catchFrisbee();
}
}
How about this old trick:
abstract class Pet<T extends Pet>
{
private String name;
public T setName(String name) { this.name = name; return (T) this; }
}
class Cat extends Pet<Cat>
{
/* ... */
}
class Dog extends Pet<Dog>
{
/* ... */
}
No, not really. You could work around it by using covariant return types (thanks to McDowell for the correct name):
#Override
public Cat setName(String name) {
super.setName(name);
return this;
}
(Covariant return types are only in Java 5 and above, if that's a concern for you.)
It's a bit convoluted, but you can do this with generics:
abstract class Pet< T extends Pet > {
private String name;
public T setName( String name ) {
this.name = name;
return (T)this;
}
public static class Cat extends Pet< Cat > {
public Cat catchMice() {
System.out.println( "I caught a mouse!" );
return this;
}
}
public static class Dog extends Pet< Dog > {
public Dog catchFrisbee() {
System.out.println( "I caught a frisbee!" );
return this;
}
}
public static void main (String[] args){
Cat c = new Cat();
c.setName( "Morris" ).catchMice(); // error! setName returns Pet, not Cat
Dog d = new Dog();
d.setName( "Snoopy" ).catchFrisbee(); // error! setName returns Pet, not Dog
}
}
public class Pet<AnimalType extends Pet> {
private String name;
public AnimalType setName(String name) {
this.name = name; return (AnimalType)this;
}
}
and
public class Cat extends Pet<Cat> {
public Cat catchMice() {return this;}
public static void main(String[] args) {
Cat c = new Cat().setName("bob").catchMice();
}
}
This question has been asked in a C++ context but I'm curious about Java. The concerns about virtual methods don't apply (I think), but if you have this situation:
abstract class Pet
{
private String name;
public Pet setName(String name) { this.name = name; return this; }
}
class Cat extends Pet
{
public Cat catchMice() {
System.out.println("I caught a mouse!");
return this;
}
}
class Dog extends Pet
{
public Dog catchFrisbee() {
System.out.println("I caught a frisbee!");
return this;
}
}
class Bird extends Pet
{
public Bird layEgg() {
...
return this;
}
}
{
Cat c = new Cat();
c.setName("Morris").catchMice(); // error! setName returns Pet, not Cat
Dog d = new Dog();
d.setName("Snoopy").catchFrisbee(); // error! setName returns Pet, not Dog
Bird b = new Bird();
b.setName("Tweety").layEgg(); // error! setName returns Pet, not Bird
}
In this sort of class hierarchy, is there any way to return this in a way that doesn't (effectively) upcast the the object type?
If you want to avoid unchecked cast warnings from your compiler (and don't want to #SuppressWarnings("unchecked")), then you need to do a little more:
First of all, your definition of Pet must be self-referential, because Pet is always a generic type:
abstract class Pet <T extends Pet<T>>
Secondly, the (T) this cast in setName is also unchecked. To avoid this, use the "getThis" technique in the excellent Generics FAQ by Angelika Langer:
The "getThis" trick provides a way to
recover the exact type of the this
reference.
This results in the code below, which compiles and runs without warnings. If you want to extend your subclasses, then the technique still holds (though you'll probably need to genericise your intermediate classes).
The resulting code is:
public class TestClass {
static abstract class Pet <T extends Pet<T>> {
private String name;
protected abstract T getThis();
public T setName(String name) {
this.name = name;
return getThis(); }
}
static class Cat extends Pet<Cat> {
#Override protected Cat getThis() { return this; }
public Cat catchMice() {
System.out.println("I caught a mouse!");
return getThis();
}
}
static class Dog extends Pet<Dog> {
#Override protected Dog getThis() { return this; }
public Dog catchFrisbee() {
System.out.println("I caught a frisbee!");
return getThis();
}
}
public static void main(String[] args) {
Cat c = new Cat();
c.setName("Morris").catchMice();
Dog d = new Dog();
d.setName("Snoopy").catchFrisbee();
}
}
How about this old trick:
abstract class Pet<T extends Pet>
{
private String name;
public T setName(String name) { this.name = name; return (T) this; }
}
class Cat extends Pet<Cat>
{
/* ... */
}
class Dog extends Pet<Dog>
{
/* ... */
}
No, not really. You could work around it by using covariant return types (thanks to McDowell for the correct name):
#Override
public Cat setName(String name) {
super.setName(name);
return this;
}
(Covariant return types are only in Java 5 and above, if that's a concern for you.)
It's a bit convoluted, but you can do this with generics:
abstract class Pet< T extends Pet > {
private String name;
public T setName( String name ) {
this.name = name;
return (T)this;
}
public static class Cat extends Pet< Cat > {
public Cat catchMice() {
System.out.println( "I caught a mouse!" );
return this;
}
}
public static class Dog extends Pet< Dog > {
public Dog catchFrisbee() {
System.out.println( "I caught a frisbee!" );
return this;
}
}
public static void main (String[] args){
Cat c = new Cat();
c.setName( "Morris" ).catchMice(); // error! setName returns Pet, not Cat
Dog d = new Dog();
d.setName( "Snoopy" ).catchFrisbee(); // error! setName returns Pet, not Dog
}
}
public class Pet<AnimalType extends Pet> {
private String name;
public AnimalType setName(String name) {
this.name = name; return (AnimalType)this;
}
}
and
public class Cat extends Pet<Cat> {
public Cat catchMice() {return this;}
public static void main(String[] args) {
Cat c = new Cat().setName("bob").catchMice();
}
}