Untitled
unknown
plain_text
a year ago
32 kB
5
Indexable
javacore.organization.oop.classhierarchies 1. abstraction 1.1. demo 1.1.1. Demo //truu tuong hoa du lieu la qua trinh an di mot so chi tiet nhat dinh va chi hien thi thong can thiet cho nguoi dung //lop truu tuong khong the duoc dung de tao ra cac doi tuong nhu cac lop binh thuong khac //Abstract class abstract class Animal{ //Abstract method public abstract void animalSound(); public void sleep(){ System.out.println("zzz"); } } class Pig extends Animal{ public void animalSound(){ System.out.println("The pig says: wee wee"); } } class Diem extends Hinh{ public Diem(ToaDo toaDo) { super(toaDo); } @Override public double tinhDienTich() { // TODO Auto-generated method stub return 1; } } class HinhTron extends Hinh{ private double r; public HinhTron(ToaDo toaDo, double r) { super(toaDo); this.r = r; } public double getR() { return r; } public void setR(double r) { this.r = r; } @Override public double tinhDienTich() { // TODO Auto-generated method stub return Math.PI*r*r; } } class HinhChuNhat extends Hinh{ private int chieuRong, chieuDai; public HinhChuNhat(ToaDo toaDo, int chieuRong, int chieuDai) { super(toaDo); this.chieuRong = chieuRong; this.chieuDai = chieuDai; } @Override public double tinhDienTich() { // TODO Auto-generated method stub return chieuRong * chieuDai; } } public class Demo { public static void main(String[] args) { Pig myPig = new Pig(); myPig.animalSound(); myPig.sleep(); ToaDo td1 = new ToaDo(5,5); ToaDo td2 = new ToaDo(7,9); ToaDo td3 = new ToaDo(8,1); Hinh h1 = new Diem(td1); Hinh h2 = new HinhTron(td2, 2); Hinh h3 = new HinhChuNhat(td3, 3 , 5); System.out.println(h1.tinhDienTich()); System.out.println(h2.tinhDienTich()); System.out.println(h3.tinhDienTich()); } } ####################### 1.1.2. Hinh public abstract class Hinh { protected ToaDo toaDo; public Hinh(ToaDo toaDo) { this.toaDo = toaDo; } public ToaDo getToaDo() { return toaDo; } public void setToaDo(ToaDo toaDo) { this.toaDo = toaDo; } public abstract double tinhDienTich(); } ################################## 1.1.3. ToaDo public class ToaDo { int x, y; public ToaDo(int x, int y) { this.x = x; this.y = y; } public int getX() { return x; } public void setX(int x) { this.x = x; } public int getY() { return y; } public void setY(int y) { this.y = y; } } ####################################### 1.2. example 1.2.1. Animal abstract class Animal { private String name; public Animal(String name) { this.name = name; } public abstract void eat(); public abstract void breathe(); public String getName() { return name; } } ####################################### 1.2.2. Bird abstract class Bird extends Animal implements CanFly{ public Bird(String name) { super(name); } @Override public void eat() { System.out.println(getName() + " is pecking"); } @Override public void breathe() { System.out.println("Breathe in, breathe out, repeat"); } @Override public void fly() { System.out.println(getName() + " is flapping its wings"); } } ######################################### 1.2.3. CanFly public interface CanFly { void fly(); } ######################################## 1.2.4. Dog class Dog extends Animal { public Dog(String name) { super(name); } @Override public void eat() { System.out.println(getName() + " is eating"); } @Override public void breathe() { System.out.println("Breathe in, breathe out, repeat"); } } ########################################## 1.2.5. Main /* * Abstract class va Interface deu khong the duoc khoi tao, va chung co the chua ca method duoc khai bao ma co hoac khong * co trien khai * * Trong Abstract class co the khai bao cac truong khong phai static hoac final, va xac dinh public, protected, private * methods * Mot Abstract class chi co the ke thua tu mot lop cha nhung co the implement nhieu interfaces */ public class Main { public static void main(String[] args) { Dog dog = new Dog("Yorkie"); dog.breathe(); dog.eat(); Bird bird = new Parrot("Parrot"); bird.breathe(); bird.eat(); bird.fly(); Parrot parrot = new Parrot("Australia ringnec"); parrot.breathe(); parrot.eat(); parrot.fly(); Penguin penguin = new Penguin("Emperor"); penguin.fly(); } } ############################################## 1.2.6. Parrot public class Parrot extends Bird{ public Parrot(String name) { super(name); } @Override public void fly() { System.out.println("Flitting from branch to branch"); } } ########################################### 1.2.7. Penguin public class Penguin extends Bird{ public Penguin(String name) { super(name); } @Override public void fly() { super.fly(); System.out.println("I'm not very good at that, can I go for a swim instead?"); } } ########################################### 1.3. AbstractClassVsInterface public class AbstractClassVsInterface { /* Below you can see a list of some important differences between these two concepts: an abstract class can have abstract and non-abstract instance methods while an interface can have abstract or default instance methods; an abstract class can extend another abstract or regular class and an interface can only extend another interface; an abstract class can extend only one class while an interface can extend any number of interfaces; an abstract class can have final, non-final, static, non-static variables (regular fields) while an interface can only have static final variables; an abstract class can provide an implementation of an interface but an interface cannot provide an implementation of an abstract class; an abstract class can have a constructor and an interface cannot; in an abstract class, the keyword abstract is mandatory to declare a method as an abstract one while in an interface this keyword is optional. */ } // Using abstract classes and interfaces together interface ManagedDevice { void on(); void off(); } abstract class AbstractDevice implements ManagedDevice { protected String serialNumber; protected boolean on; public AbstractDevice(String serialNumber) { this.serialNumber = serialNumber; } protected void setOn(boolean on) { this.on = on; } } class Kettle extends AbstractDevice { protected double volume; public Kettle(String serialNumber, double volume) { super(serialNumber); this.volume = volume; } @Override public void on() { // do complex logic to activate all electronic components setOn(true); } @Override public void off() { // do complex logic to stop all electronic components setOn(false); } } ######################################## 2. encapsulation 2.1. Demo /* * Tinh dong goi (Enscapsulation): dam bao du lieu nhay cam duoc an khoi nguoi dung -> khai bao thuoc tinh la rieng tu va cung cap cac phuong thuc get va set cong khai de truy cap va cap nhat gia tri cua bien rieng tu * Che giau di mot so du lieu, ham, phuong thuc de da bao cac du lieu do duoc su dung dung cach */ public class Demo { public class Person{ private String name; //getter public String getName(){ return name; } //setter public void setName(String newName){ this.name = newName; //this de chi doi tuong hien tai } } } ######################################### 2.2. Main public class Main { public static void main(String[] args) { Player player = new Player(); player.name = "Thieu"; player.health = 100; player.weapon = "Sword"; int damage = 10; player.loseHealth(damage); System.out.println("Remaining health of player = " + player.healthRemaining()); player.loseHealth(damage); System.out.println("Remaining health of player = " + player.healthRemaining()); EnhancedPlayer enhancedPlayer = new EnhancedPlayer("Thieu", 50, "Sword"); System.out.println("Initial health of enhanced player is " + enhancedPlayer.getHealth()); } } class EnhancedPlayer { private String name; private int hitPoints = 100; private String weapon; public EnhancedPlayer(String name, int health, String weapon) { this.name = name; if (health > 0 && health <= 200) { this.hitPoints = health; } this.weapon = weapon; } public void loseHealth(int damage) { this.hitPoints -= damage; if (hitPoints <= 0) { System.out.println("Player knocked out"); } } public int getHealth() { return hitPoints; } } class Player { public String name; public int health; public String weapon; public void loseHealth(int damage) { this.health -= damage; if (health <= 0) { System.out.println("Player knocked out"); } } public int healthRemaining() { return this.health; } } ########################################## 3. inheritance 3.1. Demo //Subclass and Superclass //Neu khong muon class khac ke thua class hien tai thi dung tu khoa final o truoc class hien tai //Trong Java khong co da ke thua //Ke thua bieu dien moi quan he giua hai lop cha - con (IS-A relationship) public class Demo { public static class Human{ protected String name; protected int yearOfBirth; public Human(String name, int yearOfBirth) { this.name = name; this.yearOfBirth = yearOfBirth; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getYearOfBirth() { return yearOfBirth; } public void setYearOfBirth(int yearOfBirth) { this.yearOfBirth = yearOfBirth; } public void eat(){ System.out.println("yummy"); } public void drink(){ System.out.println("uwu"); } public void sleep(){ System.out.println("hmhm"); } } public static class Student extends Human { private String className; private String shoolName; public Student(String name, int yearOfBirth, String className, String shoolName) { super(name, yearOfBirth); this.className = className; this.shoolName = shoolName; } public String getClassName() { return className; } public void setClassName(String className) { this.className = className; } public String getShoolName() { return shoolName; } public void setShoolName(String shoolName) { this.shoolName = shoolName; } public void doHomework(){ System.out.println("Done!"); } } public static void main(String[] args) { Human cn = new Human("Thieu", 1999); cn.eat(); cn.drink(); cn.sleep(); Student hs = new Student("Thieu", 1999, "Lop 17", "SRV"); hs.eat(); hs.drink(); hs.sleep(); hs.doHomework(); } } ########################################## 3.2. Main public class Main { public static void main(String[] args) { Animal animal = new Animal("Animal", 1, 1, 5, 5); Dog dog = new Dog("Yorkie", 8, 20, 2, 4, 1, 20, "long silky"); dog.eat(); System.out.println(dog.getSize()); } } class Animal { private String name; private int brain; private int body; private int size; private int weight; public Animal(String name, int brain, int body, int size, int weight) { this.name = name; this.brain = brain; this.body = body; this.size = size; this.weight = weight; } public String getName() { return name; } public int getBrain() { return brain; } public int getBody() { return body; } public int getSize() { return size; } public int getWeight() { return weight; } public void eat() { System.out.println("Animal eat"); } public void move() { System.out.println("Animal move"); } } class Dog extends Animal { private int eyes; private int legs; private int tail; private int teeth; private String coat; public Dog(String name, int size, int weight, int eyes, int legs, int tail, int teeth, String coat) { super(name, 1, 1, size, weight); this.eyes = eyes; this.legs = legs; this.tail = tail; this.teeth = teeth; this.coat = coat; } @Override public void eat() { System.out.println("Dog eat"); } @Override public void move() { super.move(); } public void chew() { System.out.println("Dog chew"); } } ####################################### 4. interfaces 4.1. demo 4.1.1. Demo //Mot interface la mot "ban thiet ke" cua mot lop - la mot abstract class -> chi chua hang so va phuong thuc truu tuong //Muc dich: de dat duoc tinh truu tuong hoan toan va da ke thua trong java interface MayTinhBoTui{ public abstract double cong(double a, double b); //tu abstract co hay khong deu duoc public double tru(double a, double b); public double nhan(double a, double b); public double chia(double a, double b); } class MayTinhCasioFX500 implements MayTinhBoTui{ @Override public double cong(double a, double b) { // TODO Auto-generated method stub return a+b; } @Override public double tru(double a, double b) { // TODO Auto-generated method stub return a-b; } @Override public double nhan(double a, double b) { // TODO Auto-generated method stub return a*b; } @Override public double chia(double a, double b) { // TODO Auto-generated method stub return a/b; } } class MayTinhVinacal500 implements MayTinhBoTui{ @Override public double cong(double a, double b) { // TODO Auto-generated method stub return a+b; } @Override public double tru(double a, double b) { // TODO Auto-generated method stub return a-b; } @Override public double nhan(double a, double b) { // TODO Auto-generated method stub return a*b; } @Override public double chia(double a, double b) { // TODO Auto-generated method stub return a/b; } } interface SapXepInterface{ public void sapXepTang(double[] arr); public void sapXepGiam(double[] arr); } class SapXepChen implements SapXepInterface{ @Override public void sapXepTang(double[] arr) { // TODO Auto-generated method stub int i, j; double key; int n = arr.length; for(i = 1; i < n; i++){ key = arr[i]; j = i - 1; while(j >= 0 && arr[j] > key){ arr[j+1] = arr[j]; j = j - 1; } arr[j+1] = key; } } @Override public void sapXepGiam(double[] arr) { // TODO Auto-generated method stub int i, j; double key; int n = arr.length; for(i = 1; i < n; i++){ key = arr[i]; j = i - 1; while(j >= 0 && arr[j] < key){ arr[j+1] = arr[j]; j = j - 1; } arr[j+1] = key; } } } class SapXepChon implements SapXepInterface{ @Override public void sapXepTang(double[] arr) { // TODO Auto-generated method stub int i, j, minIndex; int n = arr.length; for(i = 0; i < n - 1; i++){ minIndex = i; for(j = i + 1; j < n; j++){ if(arr[j] < arr[minIndex]) minIndex = j; } double tmp = arr[i]; arr[i] = arr[minIndex]; arr[minIndex] = tmp; } } @Override public void sapXepGiam(double[] arr) { // TODO Auto-generated method stub int i, j, maxIndex; int n = arr.length; for(i = 0; i < n - 1; i++){ maxIndex = i; for(j = i + 1; j < n; j++){ if(arr[j] > arr[maxIndex]) maxIndex = j; } double tmp = arr[i]; arr[i] = arr[maxIndex]; arr[maxIndex] = tmp; } } } class PhanMemMayTInh implements MayTinhBoTui, SapXepInterface{ @Override public double cong(double a, double b) { // TODO Auto-generated method stub return a+b; } @Override public double tru(double a, double b) { // TODO Auto-generated method stub return a-b; } @Override public double nhan(double a, double b) { // TODO Auto-generated method stub return a*b; } @Override public double chia(double a, double b) { // TODO Auto-generated method stub return a/b; } @Override public void sapXepTang(double[] arr) { // TODO Auto-generated method stub int i, j; double key; int n = arr.length; for(i = 1; i < n; i++){ key = arr[i]; j = i - 1; while(j >= 0 && arr[j] > key){ arr[j+1] = arr[j]; j = j - 1; } arr[j+1] = key; } } @Override public void sapXepGiam(double[] arr) { // TODO Auto-generated method stub int i, j; double key; int n = arr.length; for(i = 1; i < n; i++){ key = arr[i]; j = i - 1; while(j >= 0 && arr[j] < key){ arr[j+1] = arr[j]; j = j - 1; } arr[j+1] = key; } } } public class Demo { public static void main(String[] args) { System.out.println("Test cau a: "); MayTinhCasioFX500 mfx500 = new MayTinhCasioFX500(); MayTinhVinacal500 mvn500 = new MayTinhVinacal500(); System.out.println("5+3 = " + mfx500.cong(5,3)); System.out.println("4x5 = " + mvn500.nhan(4,5)); System.out.println("Test cau b: "); double[] arr1 = new double[] {5,1,3,4,8,0,5}; double[] arr2 = new double[] {6,7,2,9,2,4,5}; SapXepChen sxc = new SapXepChen(); SapXepChon sxchon = new SapXepChon(); sxc.sapXepTang(arr1); sxchon.sapXepGiam(arr2); for(double i : arr1){ System.out.print(i + " "); } System.out.println(); for(double i : arr2){ System.out.print(i + " "); } System.out.println(); System.out.println("Test cau c: "); PhanMemMayTInh pmmt = new PhanMemMayTInh(); System.out.println("3+5 = " + pmmt.cong(3, 5)); double[] arr3 = new double[] {6,7,2,9,2,4,5}; pmmt.sapXepTang(arr3); for(double i : arr3){ System.out.print(i + " "); } System.out.println(); } } ################################################## 4.1.2. ITelephone public interface ITelephone { void powerOn(); void dial(int phoneNumber); void answer(); boolean callPhone(int phoneNumber); boolean isRinging(); } ################################################## 4.1.3. Main class Gearbox { private boolean clutchIsIn; public void operateClutch(String inOrOut) { this.clutchIsIn = inOrOut.equalsIgnoreCase("in"); } } class DeskPhone implements ITelephone { private int myNumber; private boolean isRinging; public DeskPhone(int myNumber) { this.myNumber = myNumber; } @Override public void powerOn() { System.out.println("No action taken, desk phone does not have a power button"); } @Override public void dial(int phoneNumber) { System.out.println("Now ringing " + phoneNumber + " on desk phone"); } @Override public void answer() { if (isRinging) { System.out.println("Answering the desk phone"); isRinging = false; } } @Override public boolean callPhone(int phoneNumber) { if (phoneNumber == myNumber) { isRinging = true; System.out.println("Ring ring"); } else { isRinging = false; } return isRinging; } @Override public boolean isRinging() { return isRinging; } public void abc() { System.out.println("HEHE"); } } class MobilePhone implements ITelephone { private int myNumber; private boolean isRinging; private boolean isOn = false; public MobilePhone(int myNumber) { this.myNumber = myNumber; } @Override public void powerOn() { isOn = true; System.out.println("Mobile phone powered up"); } @Override public void dial(int phoneNumber) { if (isOn) { System.out.println("Now ringing " + phoneNumber + " on mobile phone"); } else { System.out.println("Phone is switched off"); } } @Override public void answer() { if (isRinging) { System.out.println("Answering the mobile phone"); isRinging = false; } } @Override public boolean callPhone(int phoneNumber) { if (phoneNumber == myNumber && isOn) { isRinging = true; System.out.println("Melody ring"); } else { isRinging = false; System.out.println("Mobile phone not on or number different"); } return isRinging; } @Override public boolean isRinging() { return isRinging; } } public class Main { public static void main(String[] args) { ITelephone timsPhone = new DeskPhone(123456); timsPhone.powerOn(); timsPhone.callPhone(123456); timsPhone.answer(); timsPhone = new MobilePhone(654321); timsPhone.powerOn(); timsPhone.callPhone(654321); timsPhone.answer(); } } ############################################## 4.2. DeclaringFunctionality interface MyInterface { int INT_CONSTANT = 0; // it's a constant, the same as public static final int INT_CONSTANT = 0 void instanceMethod1(); void instanceMethod2(); // The staticMethod() is just a regular static method. static void staticMethod() { System.out.println("Interface: static method"); } // The default method defaultMethod() has an implementation, but it can be overridden in subclasses. default void defaultMethod() { System.out.println("Interface: default method. It can be overridden"); } // The privateMethod has an implementation as well and can be used to decompose default methods. private void privateMethod() { System.out.println("Interface: private methods in interfaces are acceptable but should have a body"); } } class MyClass implements MyInterface { @Override public void instanceMethod1() { System.out.println("Class: instance method1"); } @Override public void instanceMethod2() { System.out.println("Class: instance method2"); } } public class DeclaringFunctionality { public static void main(String[] args) { DrawingTool pencil = new Pencil(); DrawingTool brush = new Brush(); MyInterface instance = new MyClass(); instance.instanceMethod1(); instance.instanceMethod2(); instance.defaultMethod(); MyInterface.staticMethod(); } } interface DrawingTool { void draw(Curve curve); } class Pencil implements DrawingTool { @Override public void draw(Curve curve) { } } class Brush implements DrawingTool { @Override public void draw(Curve curve) { } } class Curve { } ############################################ 4.3. DefaultFunction /* Default function trong interface co the duoc override hoac khong Truong hop mot class implement hai interface deu co cung default function (cung ten) thi bat buoc phai trien khai default function do trong class, neu khong se xay ra loi bien dich */ interface Feature { default void action() { System.out.println("Default action"); } } class FeatureImpl implements Feature { @Override public void action() { System.out.println("FeatureImpl-specific action"); } } public class DefaultFunction { public static void main(String[] args) { // Feature.action() // Khong the goi default function cua interface mot cach truc tiep new Feature() { }.action(); Feature feature = new FeatureImpl(); feature.action(); // FeatureImpl-specific action } } interface Movable { void stepAhead(); void turnLeft(); void turnRight(); default void turnAround() { turnLeft(); turnLeft(); } } interface Jumpable { void jump(); void turnLeftJump(); void turnRightJump(); default void turnAround() { turnLeftJump(); turnLeftJump(); } } class Spiderman implements Movable, Jumpable { // define an implementation for abstract methods public void stepAhead() { } public void turnLeft() { } public void turnRight() { } public void jump() { } public void turnLeftJump() { } public void turnRightJump() { } // define an implementation for conflicting default method @Override public void turnAround() { // define turnaround for Spiderman Movable.super.turnAround(); // default } } ######################################### 5. overriding 5.1. Main class Animal{ protected String name; public Animal(String name) { this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } public void eat(){ System.out.println("eating..."); } public void makeSound(){ System.out.println("........."); } public void sleep(){ System.out.println("zzzzzzzzz"); } } class Dog extends Animal{ public Dog(){ super("Dog"); } //@Override public void eat() { System.out.println("an xuong!"); } @Override public void makeSound() { System.out.println("Go go"); } } class Cat extends Animal{ public Cat() { super("Cat"); } //@Override public void eat() { System.out.println("an ca!");; } @Override public void makeSound() { System.out.println("meow meow"); } } public class Main { public static void main(String[] args) { Dog d = new Dog(); d.eat(); d.makeSound(); d.sleep(); Animal an = new Cat(); an.eat(); } } ##################################################### 6. polymorphism 6.1. Demo class Animal { public void animalSound() { System.out.println("The animal makes a sound"); } } class Pig extends Animal { public void animalSound() { System.out.println("The pig says: wee wee"); } } class Dog extends Animal { public void animalSound() { System.out.println("The dog says: bow wow"); } } public class Demo { public static void main(String[] args) { Animal myAnimal = new Animal(); // Create a Animal object Animal myPig = new Pig(); // Create a Pig object Animal myDog = new Dog(); // Create a Dog object myAnimal.animalSound(); myPig.animalSound(); myDog.animalSound(); } } #################################### 6.2. Main public class Main { public static void main(String[] args) { for (int i = 1; i < 11; i++) { Movie movie = randomMovie(); System.out.println("Movie #" + i + " : " + movie.getName() + "\n" + "Plot: " + movie.plot() + "\n"); } } public static Movie randomMovie() { int randomNumber = (int) (Math.random() * 5) + 1; System.out.println("Random number generated was: " + randomNumber); return switch (randomNumber) { case 1 -> new Jaws(); case 2 -> new IndependenceDay(); case 3 -> new MazeRunner(); case 4 -> new StarWars(); case 5 -> new Forgetable(); default -> null; }; } } class Movie { private String name; public Movie(String name) { this.name = name; } public String plot() { return "No plot here"; } public String getName() { return name; } } class Jaws extends Movie { public Jaws() { super("Jaws"); } public String plot() { return "A shark eats lots of people"; } } class IndependenceDay extends Movie { public IndependenceDay() { super("Independence Day"); } @Override public String plot() { return "Aliens attempt to take over planet earth"; } } class MazeRunner extends Movie { public MazeRunner() { super("Maze runner"); } @Override public String plot() { return "Kids try and escape a maze"; } } class StarWars extends Movie { public StarWars() { super("Star wars"); } @Override public String plot() { return "Imperial Forces try to take over the universe"; } } class Forgetable extends Movie { public Forgetable() { super("Forgetable"); } } ############################################# 6.3. Test public class Test { public static void main(String[] args) { new TeamLead(1); } public static class TeamLead extends Programmer { private final int numTeamLead; public TeamLead(int numTeamLead) { super(numTeamLead); this.numTeamLead = numTeamLead; employ(); } protected void employ() { System.out.println(numTeamLead + " teamlead"); } } public static class Programmer { private final int numProgrammer; public Programmer(int numProgrammer) { this.numProgrammer = numProgrammer; employ(); } private void employ() { System.out.println(numProgrammer + " programmer"); } } } ######################################### 7. RuntimeTypeChecking /* A variable of a base class can always refer to an object of a subclass. We can determine the actual type of the referred object at runtime. - the instanceof operator that can be used for testing if an object is of a specified type - java reflection that can be used to obtain an object representing the class. */ public class RuntimeTypeChecking { public static void main(String[] args) { Shape circle = new Circle(); // the reference is Shape, the object is Circle Shape rect = new Rectangle(); // the reference is Shape, the object is Rectangle boolean circleIsCircle = circle instanceof Circle; // true boolean circleIsRectangle = circle instanceof Rectangle; // false boolean circleIsShape = circle instanceof Shape; // true boolean rectIsRectangle = rect instanceof Rectangle; // true boolean rectIsCircle = rect instanceof Circle; // false boolean rectIsShape = rect instanceof Shape; // true // Pay attention, the type of the object in question should be a subtype (or the type) of the specified class. Circle c = new Circle(); // boolean circleIsRect = c instanceof Rectangle; // Inconvertible types Shape s = new Shape(); boolean sIsCircle = s instanceof Circle; // false // Pattern matching for instanceof Object obj = " "; if (obj instanceof String str && str.length() > 0) { if (str.isBlank()) { System.out.println("The variable is empty or contains only a whitespace"); } } // Use reflection boolean equalsCircle = circle.getClass() == Circle.class; // true boolean equalsShape = circle.getClass() == Shape.class; // false boolean rectangle = circle.getClass() == Rectangle.class; // false boolean isInstanceOfCircle = Circle.class.isInstance(circle); // true boolean isInstanceOfShape = Shape.class.isInstance(circle); // true boolean isInstanceOfRectangle = Rectangle.class.isInstance(circle); // false boolean circleIsRect = Rectangle.class.isInstance(c); // false } } class Shape { } class Circle extends Shape { } class Rectangle extends Shape { }
Editor is loading...
Leave a Comment