System is a class, that has a public static field out. So it’s more like
class System
{
public static PrintStream out;
}
class PrintStream
{
public void println ...
}
This is a slight oversimplification, as the PrintStream class is actually in the java.io package, but it’s good enough to show the relationship of stuff.
private transient Object[] elementData;
this.elementData=new Object[initial capacity];
List<String> myList=new ArrayList<String>();
List<String> myList=new ArrayList<String>(5);
When we create an ArrayList in this way, constructor with an integer argument is invoked and will internally create an array of Object with the size, specified in the constructor argument, which happens to be 5 in this case.
So what happens internally is a new Array is created with size 1.5*currentSize and the data from old Array is copied into this new Array.
Internally an ArrayList uses an Object[].
Capacity vs Size
The capacity is how many elements the list can potentially accommodate without reallocating its internal structures.
The size is the number of elements in the list
If you allocate a new array with arr = new Employee[100], the size of that array (arr.length) is going to be 100. It has 100 elements. All the elements are initially null (as this is an array of object references), but still, there are 100 elements.
If you do something like list = new ArrayList
Internally, it’s true that the ArrayList allocates enough place to put 100 items before it needs to extend its capacity, but that’s an internal implementation detail, and the list presents its content to you as “no items stored”. Only if you actually do list.add(something), you’ll have items in the list.
So although the list allocates storage in advance, the API with which it communicates with the program tells you there are no items in it. The null items in its internal array are not available to you – you cannot retrieve them or change them.
An ArrayList is just one way to represent an abstract list, and the capacity of an ArrayList is an implementation detail of how the system implements the logical list.
An ArrayList stores the elements of a list by using an actual array “under the covers.” The actual realization of the array in computer memory has a certain size when it is allocated; this size is the ArrayList’s capacity. The ArrayList emulates a variable-sized list by storing the logical length of the list in addition to the fixed-length array. Thus if you have an ArrayList with a capacity 10 which contains 4 logical elements, the ArrayList can be represented as a length and an array
(4) | e1 | e2 | e3 | e4 | __ | __ | __| __ | __ | __ |
where the (4) is the logical length of the list and ‘__’ represent data that is ignored because it is not part of the logical list. If you attempt to access the 5th element of this ArrayList, it will throw an exception because it knows that the fifth element has not been initialized. If we then append an extra element e5 to the list, the ArrayList becomes
(5) | e1 | e2 | e3 | e4 | e5 | __ | __ | __ | __ | __ |
Note that the capacity has not changed, while the logical length has, because the underlying array is still able to handle all the data in the logical list.
If you manage to add more than ten elements to this list, the ArrayList will not break. The ArrayList is an abstraction meant to be compatible with all array operations. Rather, the ArrayList changes its capacity when its logical length exceeds its original capacity. If we were to add the elements (a1, a2, …, a7) to the above list, the resulting ArrayList might look like
(12) | e1 | e2 | e3 | e4 | e5 | a1 | a2 | a3 | a4 | a5 | a6 | a7 | __ | __ | __ | __ | __ | __ | __ | __ |
with a capacity of 20.
Once you have created an ArrayList, you can ignore the capacity in all programming that follows; the logic is unaffected. However, the performance of the system under certain kinds of operations can be affected. Increasing the capacity, for instance, might well involved allocating a larger array, copying the first array into the second and then performing the operations. This can be quite slow compared to, e.g. the same operation on a linked list. Thus it is sensible to choose the capacity of an ArrayList to be bigger than, or at least comparable to, the actual number of elements expected in the real runtime environment.
Is there a Way to Create ArrayList of Fixed size in Java
List<String> fixedSizeList = Arrays.asList(new String[100]);
You cannot insert new Strings to the fixedSizeList (it already has 100 elements). You can only set its values like this:
fixedSizeList.set(7, "new value");
What would be the Output of the Following Code
List<Employee> employees = new ArrayList<>(100); int size = employes.size();
size will be 0 while the initial capacity is 100.
Yes. An interface can extend multiple interfaces, as shown here:
interface Maininterface extends inter1, inter2, inter3{
// methods
}
A single class can also implement multiple interfaces
interface A
{
void test();
}
interface B
{
void test();
}
class C implements A, B
{
@Override
public void test() {
}
}
Single implementation works for both.
Yes.You can use any kind of method in an abstract class
public abstract class AbstractDAO{
public void save(){
validate();
//save
}
private void validate(){ // we are hiding this method
}
}
Private Constructors
If Private constructor is the only constructor of the class, then the reason is clear: to prevent subclassing. Some classes serve only as holders for static fields/methods and do not want to be either instantiated or subclassed. Note that the abstract modifier is in this case redundant—with or without it there would be no instantiation possible. The abstract modifier is also bad practice because it sends wrong signals to the class’s clients. The class should in fact have been final.
Abstract Class with Private Constructor is same as Final Class. Both serves the same purpose.
POJO Plain Old Java Object. Basically a class with attributes and its getters and setters.
public class User
{
private String name;
private int age;
public void setName(String name){
this.name = name;
}
public String getName(){
return this.name;
}
//same for age
}
POJO vs Java Beans
A JavaBean is a Java object that satisfies certain programming conventions:
Advantages of Bean
Advantages of POJO
Spring vs EJB
App servers written to support the EJB standard can, in theory, be ported from one compliant Java EE app server to another. But that means staying away from any and all vendor-specific extensions that lock you in to one vendor.
Spring ports easily between app servers (e.g., WebLogic, Tomcat, JBOSS, etc.) because it doesn’t depend on them
Spring Boot offers an even better way to write applications without Java EE app servers. You can create an executable JAR and run it on a JVM.
The Spring framework sits on top of the application servers and service libraries. Service integration code (e.g. data access templates) resides in the framework and is exposed to the application developers. In contrast, the EJB 3 framework is integrated into the application server and the service integration code is encapsulated behind an interface. EJB 3 vendors can thus optimize the performance and developer experience by working at the application server level. For example, they can tie the JPA engine closely to JTA transaction management. Another example is clustering support which is transparent to EJB 3 developers
Spring vs J2EE
Strictly speaking, Spring is a framework while Java EE is a specification which is implemented by various softwares such as JBoss and Glassfish.
The greatest difference is that Spring is an actual library while JavaEE is an API that has to be implemented. Depending on the JAVA EE container you could find a full implementation (e.g. Glassfish), a partial implementation (e.g. Tomcat) a full implementation with extra sugar (e.g. JBoss and others).
Is it possible to create Object for abstract class?
abstract class my {
public void mymethod() {
System.out.print("Abstract");
}
}
class poly {
public static void main(String a[]) {
my m = new my() {};
m.mymethod();
System.out.println(m.getClass().getSuperclass());
}
}
No, we can’t.The abstract super class is not instantiated by us but by java.
In the above code we are creating object for anonymous class.
my m = new my() {};
When the above code is compiled will result in following class file creation
My.class Poly$1.class // Class file corresponding to anonymous subclass Poly.class
anonymous inner type allows you to create a no-name subclass of the abstract class
When the above code is run the output would be
Output
Abstract class my
Now lets override the method in anonymous inner class like one below.
abstract class my {
public void mymethod() {
System.out.print("Abstract");
}
}
class poly {
public static void main(String a[]) {
my m = new my() {
public void mymethod() {
System.out.print("Overridden in anonymous class");
}
};
m.mymethod();
System.out.println(m.getClass().getSuperclass());
}
}
Output
Overridden in anonymous class class my
Anonymous inner class with same name as abstract class are child classes of abstract class.
There may be times where one may think that I can extend parent class instead of implementing interface. Lets see whats When to choose inheritance over an interface and interface over inheritance.
inheritance over an interface
The main drawback of interfaces is that they are much less flexible than classes when it comes to allowing for the evolution of APIs. Once you ship an interface, the set of its members is fixed forever. Any additions to the interface would break existing types implementing the interface.
A class offers much more flexibility. You can add members to classes that you have already shipped. As long as the method is not abstract (i.e., as long as you provide a default implementation of the method), any existing derived classes continue to function unchanged.
interface over inheritance
Lets take the following code
Mammal.java
public abstract class Animal
{
public void abstract mate();
public void abstract feed();
}
Now the above abstract class has two methods mate() and feed().
public class Dog extends Animal
{
}
public class Cat extends Animal
{
}
Now we have Dog and Cat concrete classes extending Animal.
we have few more classes extending Animal
public class Giraffe extends Animal{}
public class Rhinoceros extends Animal{}
public class Hippopotamus extends Animal{}
Now the classes Dog and Cat are pet animals. So it should implement pet behavior. This can be done in two ways.
Now implementing interface is easy compared to overriding method defined in base class because
public class parakeets extends Animal
{
.
.
public boolean canFly()
{
return true;
}
}
Instead you can declare a interface flyable and implement the interface method without making changes to base class
public class parakeets extends Animal implements flyable
{
.
.
public boolean canFly()
{
return true;
}
}
Scenario 1:
If you have a clear analysis and Design in UML then you can start with the interface.
Scenario 2:
The interface shows up when you need to refactor common features out of several classes.Until you have multiple classes with common features, it’s hard to foresee what the interface should be.
Write a class and extract interface later. Usually the reason for extracting an interface is the need for a second implementation of that interface (often as a mock for unit testing)
Maven acts as both a dependency management tool – it can be used to retrieve jars from a central repository or from a repository you set up – and as a declarative build tool. The difference between a “declarative” build tool and a more traditional one like ant or make is you configure what needs to get done, not how it gets done. For example, you can say in a maven script that a project should be packaged as a WAR file, and maven knows how to handle that.
Maven relies on conventions about how project directories are laid out in order to achieve its “declarativeness.” For example, it has a convention for where to put your main code, where to put your web.xml, your unit tests, and so on, but also gives the ability to change them if you need to.