In this page, we will learn about basics of OOPs. Object Oriented Programming is a paradigm that provides many concepts such as inheritance, data binding, polymorphism etc.
Simula is considered as the first object-oriented programming language. The programming paradigm where everything is represented as an object, is known as truly object-oriented programming language.
Smalltalk is considered as the first truly object-oriented programming language.
OOPs (Object Oriented Programming System)
Object means a real word entity such as pen, chair, table etc. Object-Oriented Programming is a methodology or paradigm to design a program using classes and objects. It simplifies the software development and maintenance by providing some concepts:
Object
Class
Inheritance
Polymorphism
Abstraction
Encapsulation
Object
Any entity that has state and behavior is known as an object. For example: chair, pen, table, keyboard, bike etc. It can be physical and logical.
Class
Collection of objects is called class. It is a logical entity.
Inheritance
When one object acquires all the properties and behaviours of parent object i.e. known as inheritance. It provides code reusability. It is used to achieve runtime polymorphism.
Polymorphism
When one task is performed by different ways i.e. known as polymorphism. For example: to convense the customer differently, to draw something e.g. shape or rectangle etc.
In java, we use method overloading and method overriding to achieve polymorphism.
Another example can be to speak something e.g. cat speaks meaw, dog barks woof etc.
Abstraction
Hiding internal details and showing functionality is known as abstraction. For example: phone call, we don't know the internal processing.
In java, we use abstract class and interface to achieve abstraction.
Encapsulation
Binding (or wrapping) code and data together into a single unit is known as encapsulation. For example: capsule, it is wrapped with different medicines.
A java class is the example of encapsulation. Java bean is the fully encapsulated class because all the data members are private here.
Advantage of OOPs over Procedure-oriented programming language
1)OOPs makes development and maintenance easier where as in Procedure-oriented programming language it is not easy to manage if code grows as project size grows.
2)OOPs provides data hiding whereas in Procedure-oriented prgramming language a global data can be accessed from anywhere.
3)OOPs provides ability to simulate real-world event much more effectively. We can provide the solution of real word problem if we are using the Object-Oriented Programming language.
What is difference between object-oriented programming language and object-based programming language?
Object based programming language follows all the features of OOPs except Inheritance. JavaScript and VBScript are examples of object based programming languages.
package com.cv.java.constructor;
/**
* @author Chandra Vardhan
*
*/ public class Child extends Parent {
// Implicit super constructor Parent() is undefined for default constructor.
// Must define an explicit constructor
// If the parent constructor throwing some Exception then child should throw same
// Exception or its parent Exception.
// Default constructor cannot handle exception type Exception thrown by
// implicit super constructor. Must define an
// explicit constructor
// If the parent cons throwing some Exception then child should throw
// Exception..
// But we can not write try and catch blocks inside the constructor
// Imporatant:
// If the parent is throwing any un-checked Exception then child should also
// throw the same Exception or its super Exception..
// But this is not applicable for the methods.... public Child() throws Exception {
/**
* @author Chandra Vardhan
*
*/ public class Parent {
// NOTE: If u did not provide public def cons...then
// Implicit super constructor Parent() is undefined for default constructor.
// Must define an explicit constructor
/*
* Parent() {
*
* }
*/
// Means parent cons should not be a private
/*
* private Parent() {
*
* }
*/
public Parent() throws Exception {
System.out.println("Parent()... Exception");
// throw new Exception();
}
public Parent(int i, int j) throws ArrayIndexOutOfBoundsException {
System.out.println("Parent(--)... ArrayIndexOutOfBoundsException ...");
//throw new ArrayIndexOutOfBoundsException();
}
// you have to provide default constructor also... public Parent(int i) {
System.out.println("Parent(-)... Exception");
}
}
package com.cv.java.constructor;
/**
* @author Chandra Vardhan
*
*/ public class ParentChildTest {
try { new Child(); new Child(1, 2); new Child(1);
} catch (Throwable e) {
e.printStackTrace();
}
}
}
/**
*
*/ package com.cv.java.inheritance;
/**
* @author Chandra Vardhan
*
*/ public class Audi extends Benz {
private String name;
public String getName() { return name;
}
public void setName(String name) { this.name = name;
}
public Audi() {
}
public Audi(String name) { this.name = name;
}
public void purchase() {
System.out.println("20L");
}
public int cost() {
System.out.println("20 lacks for the car:" + name); return 20;
}
}
/**
*
*/ package com.cv.java.inheritance;
/**
* @author Chandra Vardhan
*
*/ public class Benz extends Car {
private String nameOfCar=null;
public String getNameOfCar() { return nameOfCar;
}
public void setNameOfCar(String nameOfCar) { this.nameOfCar = nameOfCar;
}
public Benz() {
}
public Benz(String name) {
nameOfCar = name;
}
public static void main(String[] args) {
}
public void purchase() {
System.out.println("25L");
}
public int cost() {
System.out.println("25 lacks for the car:" + nameOfCar); return 25;
}
}
/**
*
*/ package com.cv.java.inheritance;
/**
* @author Chandra Vardhan
*
*/ public class Car {
public Car() {
}
public Car purchase(String name) {
if ("Benz".equals(name)) {
Benz b = new Benz(name); return b;
} else if ("Maruti".equals(name)) {
Maruti b = new Maruti(name); return b;
} else if ("Audi".equals(name)) {
Audi b = new Audi(name); return b;
} else { return new Car();
}
}
public int cost() {
System.out.println("undefined method:"); return 0;
}
}
/**
*
*/ package com.cv.java.inheritance;
/**
* @author Chandra Vardhan
*
*/ public class Maruti extends Audi { private String name;
public String getName() { return name;
}
public void setName(String name) { this.name = name;
}
public Maruti() {
}
public Maruti(String name) { this.name = name;
}
public static void main(String[] args) {
}
public void purchase() {
System.out.println("3L");
}
public int cost() {
System.out.println("2 lacks for the car:" + name); return 2;
}
}
/**
*
*/ package com.cv.java.inheritance;
/**
* @author Chandra Vardhan
*
*/ public class Tata extends Car {
public Tata() {
}
public Tata(String name) {
}
public static void main(String[] args) {
}
public void purchase() {
System.out.println("1L");
} public int cost() { return 0;
}
}
package com.cv.java.inheritance;
/**
* @author Chandra Vardhan
*
*/ public class Test {
public static void main(String[] args) {
String name = "Benz";
Car c = new Car();
Car o = c.purchase(name);
System.out.println(o.cost());
/**/
}
}
package com.cv.java.oops;
/**
* @author Chandra Vardhan
*
*/ public class ConstructorTest {
public ConstructorTest() { this(9);
System.out.println("ConstructorTest() cons...");
}
public ConstructorTest(int i) {
System.out.println("ConstructorTest(-) cons...");
// Means here compiler will place the code like--->super();
}
/**
* @author Chandra Vardhan
*
*/ public class Initialization {
String m3 = m1("5");// --->4
static String m = m1("2");// -->1
// Instance block....
{
m1("3");// --->3
}
static {
m1("4");// --->2
}
public Initialization() {
m1("1");// --->5
}
public static String m1(String msg) {
System.out.println(msg);
return msg;
}
public static void main(String[] args) {
new Initialization();
// Even though u comment this statement u will get an output like 2 and
// 4...
// means static variable and static block are not part of object
// creation..
}
}
package com.cv.java.oops;
/**
* @author Chandra Vardhan
*
*/ public class InstanceBlock {
// If u have software of jdk1.7 then u may not compile or run the program of
// a class which does not contain main(-) method...
public static InstanceBlock block2 = new InstanceBlock();
// Instance Block
{
System.out.println("Am from Instance Block...");
System.exit(0);
}
/*
* public static void main(String[] args) {
*
* new StaticBlock(); }
*/
}
/**
*
*/ package com.cv.java.oops;
/**
* @author Chandra Vardhan
*
*/ public class InstanceBlockVsConstructor {
private static int constructorCount = 0; private static int instanceBlockCount = 0;
// Writing static block is also not recommended... Because it will executed
// only once while loading class
/*
* static { ++count; }
*/
// Imp:If u increment the count in instance block then before the object
// creation the instance block will be executed irrespective of the
// constructors.
// Instance block
{
++instanceBlockCount;
}
// Problem here is one constructor calling another constructor then count
// will be increment even though object not created... public InstanceBlockVsConstructor() {
// this is not executed whenever we are executing child class...
System.out.println("Am from main():InstanceControlFlowBase");// --->7
// you
// will
// get 7
// whenever
// u r
// executing
// only
// base
// class..
}
public void m1() {
System.out.println("Am from m1():InstanceControlFlowBase");// --------->1
System.out.println("val of j===" + j);// --------->2
}
AmbuguityInOverloadingClassLevelPromotion overloading = new AmbuguityInOverloadingClassLevelPromotion();
overloading.m1("chote");
overloading.m1(new StringBuffer("chote"));
// overloading.m1(null);// In the promotion of the objects which class will
// match first that will be executed...In this case String and StringBuffer are in same level..
// that is why we are getting an compile time error......
}
}
package com.cv.java.overloading;
/**
* @author Chandra Vardhan
*
*/ public class Overloading {
overloading.m1(null);// In the promotion of the objects which class will
// match first that will be executed...In this case String is first that
// is why java.lang.String class executed...
Object object = overloading.clone();
System.out.println(object);
}
}
package com.cv.java.overloading;
/**
* @author Chandra Vardhan
*
*/ public class OverloadingDouble {
OverloadingPromotionPrimitive overloading = new OverloadingPromotionPrimitive();
overloading.m1();
overloading.m1(10, 11.8f);
overloading.m1(10.6f, 11);
// overloading.m1(10,11);//error...
// The method m1(int, float) is ambiguous for the type
// OverloadingPromotionPrimitive
}
}
package com.cv.java.overriding;
public abstract class AbstractChild extends AbstractParent {
// abstract method participate in over riding.
// writing child method possible.. And it may be abstract method.. public abstract void abstractCheck();
// abstract method participate in over riding.
// writing child method possible..
public void abstractCheck2() {
System.out.println("Am from CHILD");
System.out.println("abstract method participate in overriding...");
}
// non-abstract method participate in over riding.
// writing child method possible.. with abstract modifier.. public abstract void abstractCheck3();
}
package com.cv.java.overriding;
public abstract class AbstractParent {
// abstract method participate in over riding.
// writing child method possible.. And it may be abstract method.. public abstract void abstractCheck();
// abstract method participate in over riding.
// writing child method possible.. public abstract void abstractCheck2();
// non-abstract method participate in over riding.
// writing child method possible.. public void abstractCheck3() {
System.out.println("Am from PARENT");
System.out.println("non-abstract method participate in overriding...");
}
}
package com.cv.java.overriding;
/**
* @author Chandra Vardhan
*
*/ public class AbstractParentChildTest {
AbstractParent abstractParent = new AbstractSubChild();
abstractParent.abstractCheck();
abstractParent.abstractCheck2();
abstractParent.abstractCheck3();
System.out.println("===================================");
/*
* Am from PARENT non-abstract method participate in overriding... If we
* made AbstractParent as non-abstract class...
*/
// AbstractParent abstractParent2 = new AbstractParent();
// abstractParent2.abstractCheck3();
}
}
package com.cv.java.overriding;
/**
* @author Chandra Vardhan
*
*/ public class AbstractSubChild extends AbstractChild {
@Override public void abstractCheck() {
System.out.println("Am from CHILD:AbstractSubChild");
System.out.println("abstract method participate in overriding...");
}
@Override public void abstractCheck3() {
System.out.println("Am from CHILD:AbstractSubChild");
System.out.println("non-abstract method participate in overriding...");
}
}
/**
*
*/ package com.cv.java.overriding;
/**
* @author Chandra Vardhan
*
*/ public class ClassAsArgumentChild extends ClassAsArgumentParent {
public void m1(ClassAsArgumentParent a) {
System.out.println("m1() ClassAsArgumentChild : " + a);
}
public void m2(ClassAsArgumentChild a) {
System.out.println("m2() ClassAsArgumentChild : " + a);
}
public void m3(ClassAsArgumentChild a) {
System.out.println("m3() ClassAsArgumentChild : " + a);
}
}
/**
*
*/ package com.cv.java.overriding;
/**
* @author Chandra Vardhan
*
*/ public class ClassAsArgumentParent {
public void m1(ClassAsArgumentParent a) {
System.out.println("m1() ClassAsArgumentParent "+a);
}
public void m2(ClassAsArgumentParent a) {
System.out.println("m2() ClassAsArgumentParent "+a);
}
public void m3(ClassAsArgumentSubChild a) {
System.out.println("m3() ClassAsArgumentParent "+a);
}
}
/**
*
*/ package com.cv.java.overriding;
/**
* @author Chandra Vardhan
*
*/ public class ClassAsArgumentSubChild extends ClassAsArgumentChild {
public void m1(ClassAsArgumentParent a) {
System.out.println("m1() ClassAsArgumentSubChild : " + a);
}
public void m2(ClassAsArgumentChild a) {
System.out.println("m2() ClassAsArgumentSubChild : " + a);
}
public void m3(ClassAsArgumentSubChild a) {
System.out.println("m3() ClassAsArgumentSubChild : " + a);
}
}
/**
*
*/ package com.cv.java.overriding;
/**
* @author Chandra Vardhan
*
*/ public class ClassAsArgumentTest {
ClassAsArgumentParent a3 = new ClassAsArgumentSubChild();
a3.m1(a3);
a3.m3(new ClassAsArgumentSubChild());
System.out.println("===================================");
ClassAsArgumentChild b3 = new ClassAsArgumentSubChild();
b3.m2(b3);
System.out.println("===================================");
}
}
package com.cv.java.overriding;
/**
* @author Chandra Vardhan
*
*/ class ClassLevelChild extends ClassLevelParent {// It is also a default class...
// It can inherit public class also... means we can reduce the visibility
// in class level... But not in method level... public void publicCheck() {
System.out.println("Am from CHILD");
System.out.println("public method participate in overriding...");
}
}
package com.cv.java.overriding;
/**
* @author Chandra Vardhan
*
*/ public class ClassLevelParent {// It is a public class... And we can write child
// class as a default class... public void publicCheck() {
System.out.println("Am from PARENT");
System.out.println("public method participate in overriding...");
}
}
/**
*
*/ package com.cv.java.overriding;
/**
* @author Chandra Vardhan
*
*/ public class ClassLevelParentChildTest {
/**
* @author Chandra Vardhan
*
*/ public class ExceptionChild extends ExceptionParent {
// Remember:
// parent method can throw any exception... And child is not mandatory to
// throw those Exceptions.
// If the parent method not throw any Exception... And child should not
// throw CHECKED Exceptions. But child can throw UNCHECKED EXCEPTIONS.
// Parent method--->Exception
// Child method---->Its sub Exception or same Exception or any UNCHECKED
// Exception...
public void m1() {// throws Exception { this is not possible here because
// when a parent method throws any checked exception
// then child should throws that exception..
System.out.println("AM from child......");
}
public void m2() throws RuntimeException {
System.out.println("AM from child......");
}
public void m3() throws ArrayIndexOutOfBoundsException {
System.out.println("AM from child......");
}
public void m4() { // throws Exception { not possible here
System.out.println("AM from child......");
}
public void m5() throws ArrayIndexOutOfBoundsException {// Child can throw
// or skip the
// parent
// Exception...
System.out.println("AM from child......");
}
public void m6() throws ArrayIndexOutOfBoundsException {// Even though
// parent does not
// throw any
// exception
// child can throw UN-CHECKED Exception...
System.out.println("AM from child......");
}
public void m7() throws IOException, ArrayIndexOutOfBoundsException, IOException, NumberFormatException {
System.out.println("AM from child......");
}
// overrides com.cv.overriding.ExceptionParent.m8
// Exception IOException is not compatible with throws clause in
// ExceptionParent.m8()
/*
* public void m8() throws IOException {
*
* System.out.println("AM from child......");
*
* }
*/
// Exception InterruptedException is not compatible with throws clause in
// ExceptionParent.m9() overrides com.cv.overriding.ExceptionParent.m9
public void m9() throws FileNotFoundException {
// InterruptedException extends Exception--->means InterruptedException
// is the child class of Exception...
System.out.println("AM from child......");
}
public void m10() throws ArithmeticException, NumberFormatException, NullPointerException, ClassCastException {
// Child class can throw any Runtime Exception...
System.out.println("AM from CHILD...");
/**
* @author Chandra Vardhan
*
*/ public class ExceptionParent {
// Remember:
// parent method can throw any exception... And child is not mandatory to
// throw those Exceptions.
// If the parent method not throw any Exception... And child should not
// throw CHECKED Exceptions. But child can throw UNCHECKED EXCEPTIONS.
// Parent method--->Exception
// Child method---->Its sub Exception or same Exception or any UNCHECKED
// Exception...
public void m1() {
System.out.println("AM from parenT......");
}
public void m2() {
System.out.println("AM from parenT......");
}
public void m3() {
System.out.println("AM from parenT......");
}
public void m4() throws ArrayIndexOutOfBoundsException {
System.out.println("AM from parenT......");
}
public void m5() throws Exception {
System.out.println("AM from parenT......");
}
public void m6() {
System.out.println("AM from parenT......");
}
public void m7() throws Exception {
System.out.println("AM from parenT......");
}
public void m8() throws FileNotFoundException {
// FileNotFoundException is the child Exception of the IOException...
System.out.println("AM from parenT......");
}
public void m9() throws IOException {
// IOException child of the Exception...
System.out.println("AM from parenT......");
}
public void m10() throws IOException {
// IOException child of the Exception...
System.out.println("AM from parenT......");
}
}
/**
*
*/ package com.cv.java.overriding;
/**
* @author Chandra Vardhan
*
*/ public class ExceptionParentChildTest {
PrimitiveArgChild b2 = new PrimitiveArgChild();
b2.m1(10.9);
PrimitiveArgParent b3 = new PrimitiveArgChild();
b3.m2(10);
}
}
package com.cv.java.overriding;
/**
* @author Chandra Vardhan
*
*/ public class ReturnTypeModifierCheckChild extends ReturnTypeModifierCheckParent {
public Object m1(double x) {// overridden method.. Bcoz args are same...
System.out.println("double-arg method: Child");
return this;
}
public String coVarientReturn() {
System.out.println("coVarientReturn: CHILD"); return null;
}
public String coVarientReturn2() {// If you keep Object in place of
// String...//The return type is
// incompatible with
// P.coVarientReturn2()
// Means child should throw child class as a return type...
System.out.println("coVarientReturn2: CHILD"); return null;
}
// co-Varient Return types should not be allowed to primitive types... public double coVarientReturn3() {
System.out.println("coVarientReturn3: CHILD"); return 9;
}
// private not participate in overriding.
// CHILD Specific method... private void privateCheck() {
System.out.println("private not participate in overridding... : CHILD");
}
// final method not participate in overridding.
/*
* public final void finalCheck() { //public void finalCheck() { // Cannot
* override the final method from P
*
*
* System.out.println("Am from PARENT");
*
* System.out.println("final method not participate in overridding...");
*
* }
*/
// Non-final method participate in overriding.
// writing child method possible.. And it may be final method..
public final void nonFinalCheck() {
System.out.println("non-final method with final modifier participate in overriding... : CHILD");
}
// Non-final method participate in over riding.
// writing child method possible..
public void nonFinalCheck2() {
System.out.println("non-final with non-final modifier participate in overriding... : CHILD ");
}
@Override public String toString() { return "C []";
}
public static void main(String[] args) {
/*ModifierCheckParent p = new ModifierCheckParent();
p.coVarientReturn();
p.coVarientReturn2();
p.coVarientReturn3();
p.finalCheck();
p.nonFinalCheck();
p.nonFinalCheck2();*/
// PARENT method is not visible here first..
// p.privateCheck();//The method privateCheck() from the type P is not
// visible
ReturnTypeModifierCheckChild c = new ReturnTypeModifierCheckChild();
c.privateCheck();
ReturnTypeModifierCheckParent p = new ReturnTypeModifierCheckChild();
// PARENT method is not visible here first..
// p2.privateCheck();//The method privateCheck() from the type P is not
// visible
p.coVarientReturn();
p.coVarientReturn2();
p.coVarientReturn3();
p.finalCheck();
p.nonFinalCheck();
p.nonFinalCheck2();
p.m1(9);
}
}
package com.cv.java.overriding;
/**
* @author Chandra Vardhan
*
*/ public class ReturnTypeModifierCheckParent {
public Object coVarientReturn() {
System.out.println("coVarientReturn: Parent"); return null;
}
public String coVarientReturn2() {
System.out.println("coVarientReturn2: Parent"); return null;
}
// co-Varient Return types should not be allowed to primitive types...
// Means child should also return same data type. public double coVarientReturn3() {
System.out.println("coVarientReturn3: Parent"); return 9.99;
}
// private not participate in over riding. private void privateCheck() {
System.out.println("private not participate in overridding : PARENT");
}
// final method not participate in overriding.
// writing child method not possible.. public final void finalCheck() {
System.out.println("final method not participate in overridding : PARENT");
}
// Non-final method participate in over riding.
// writing child method possible.. And it may be final method.. public void nonFinalCheck() {
System.out.println("non-final method participate in overridding : PARENT");
}
// Non-final method participate in over riding.
// writing child method possible.. public void nonFinalCheck2() {
System.out.println("non-final method participate in overridding : PARENT");
}
@Override public String toString() { return "P []";
}
}
package com.cv.java.overriding;
/**
* @author Chandra Vardhan
*
*/ public class ReturnTypeModifierCheckParentChildTest {
// This instance method cannot override the static method from StaticParent
System.out.println("m1() Child");
return this;
}
*/
//This static method cannot hide the instance method from StaticParent...
public Object m2() {
System.out.println("m1() Child");
return new StaticChild();
}
// static method can hide the static method from StaticParent... public static Object m3() {
System.out.println("m3() Child");
return new StaticChild();
}
// instance method can override the instance method from parent StaticParent... public Object m4() {
System.out.println("m4() Child");
return new StaticChild();
}
}
package com.cv.java.overriding;
/**
* @author Chandra Vardhan
*
*/ public class StaticParent {
// instance method cannot override the static method
// Means writing overridden instance method is not possible for the static method...
public static Object m1() {
System.out.println("m1() Parent");
return new StaticParent();
}
// static method cannot hide the instance method from StaticParent...
// Means writing overridden static method is not possible for the instance method... public Object m2() {
System.out.println("m2() Parent");
return new StaticParent();
}
// static method can hide the static method in child StaticChild... public static Object m3() {
System.out.println("m3() Parent");
return new StaticParent();
}
// instance method can override the instance method in child StaticChild... public Object m4() {
System.out.println("m4() Parent");
return new StaticParent();
}
}
package com.cv.java.overriding;
/**
* @author Chandra Vardhan
*
*/ public class StaticTest {
//It is never recommended to call static method with the help of object... We have to call w.r.t Class name.
/**
* @param args
*/ public static void main(String[] args) {
System.out.println("===W.r.t Parent reference and Object===");
StaticParent staticParent = new StaticParent();
staticParent.m1();
staticParent.m2();
staticParent.m3();
staticParent.m4();
System.out.println("===W.r.t Child reference and Object===");
StaticChild child = new StaticChild();
child.m1();
child.m2();
child.m3();
child.m4();
System.out.println("===W.r.t Parent reference and child Object===");
StaticParent staticParent2 = new StaticChild();
StaticParent.m1();
staticParent2.m2();
StaticParent.m3();// Even though runtime object is child but it is
// executing parent method only...
staticParent2.m4();
}
}
package com.cv.java.overriding;
/**
* @author Chandra Vardhan
*
*/ public class VarArgArgumentTypeTest {
VarArgTypeArgumentChild c = new VarArgTypeArgumentChild();// Even though reference and object are child class
System.out.println("Runtime object : " + c.m1(15));
System.out.println("===W.r.t Child reference and object===");
VarArgChild argChild = new VarArgChild();
//argChild.m1(10);
argChild.m2(10);
argChild.m3(10);// Important case to consider... Bcoz even though object
// is of child type but the output is of parent type...
argChild.m4(10);
System.out.println("=================0-arg apram====================");
argChild.m1(9);//varArgParent
argChild.m2();//varArgChild
argChild.m3();//varArgChild
// argChild.m4();
argChild.m5(10.9);
System.out.println("===W.r.t Parent reference and child object===");
VarArgParent argParent2 = new VarArgChild();
//argParent2.m1(10);// Means over riding not applicable here...
// even though object is of child type but the output is of parent type...
argParent2.m2(10);
argParent2.m3(10);// Means over riding not applicable here...
// even though object is of child type but the output is of parent type...
argParent2.m4(10);
argParent2.m5(10.8);
}
}
package com.cv.java.overriding;
public class VarArgTypeArgumentChild extends SpecificTypeArgumentParent {
public Object m1(double... x) {//overloaded method.. Bcoz args are different...
System.out.println("double-arg method: Child");
return new VarArgTypeArgumentChild();
}
public String toString() { return "VarArgTypeArgumentChild []";
}
No comments:
Post a Comment