To elaborate on classes in Java

Objective

Recently in the study of "Java Programming ideas" learned the internal class

Class is not the kind of everyday use can also tell the flowers are not ...

In fact, in Java, the types of classes and the use of a variety of different patterns. Among them are mainly

General class

Inner class (nested Class)

Anonymous class

Abstract class

Static class

Sealing class

Let's talk about this a lot first. Next, we will start with the application scenario, the definition, the instantiation, these 3 aspects, and learn the basic knowledge about the class.

General-Class application scenarios

The origin of the class is rooted in the feather of flock together. The same characteristics and behavior extraction (attributes and methods) of the world, summarized into a type. is the most common and basic unit of our programming world.

Defined

 Public class Cat { public Cat (String _color) {    this. color=_color;}  // Properties  Public  // Method (behavior)publicvoid  run () {System.out.println (color + "The cat is coming to you gracefully");}} C.run ();

This is how the most basic classes are used.

Inner class
Application Scenarios
Inner classes are also called nested classes.
Can be subdivided into non-static inner classes, static inner classes,
It is used in a wide variety of scenarios and
Defined

Non-static inner class

 Public classInnerclasstest {PrivateString name;  Publicinnerclasstest (String name) { This. name=name; }   Public class Inner{ PublicString GetName () {returnname; }    }     PublicInner Getinnerclass () {return NewInner (); }}

You can see the portion of my color change. It is defined in a normal class (external Class), it also has its own properties and methods, it can access the member variables of the external class, in addition, in order to facilitate, generally in the external definition of a method, to provide references externally, can also be used internally

Instantiation of

1         Innerclasstest innerclasstest=New innerclasstest ("Zhang San"); 2         Innerclasstest.inner Inner=innerclasstest. New Inner (); 3         System.out.println (Inner.getname ()); 4         Innerclasstest.inner s= innerclasstest.getinnerclass (); 5         System.out.println (S.getname ());

As you can see, if you need to access the inner class, you first need to have a reference to the parent class. That is, the outer class instantiation of the first row
Lines 2nd and 4th show 2 ways to instantiate non-static inner classes. One is. New inner class  another is to get an object by calling a method in an external class

Static Inner class
Application Scenarios
Static internal class usage is relatively uncommon, see Builder mode
Defined

1  Public  classInnerclasstest {2     Private StaticString name;3      Publicinnerclasstest (String name) {4Name=name;5     }6 7     Public Staticclassinner{8         public Static String GetName () {9             returnname;Ten         } One     } A      PublicInner Getinnerclass () { -         return Newinner (); -     } the}

Instantiation of
It is important to note that the inner class itself is static if it is to set the method to a static method.

String name= InnerClassTest.Inner.getName ();
Because it is a static class, it does not require an instance of the class, the direct external classes point out the line, but because the external class name is not assigned, so print out name is null

Anonymous class
Anonymous classes are known as anonymous inner classes and are also consistent with internal classes
Usage Scenarios
The reason for it to be said alone is that there are very many scenarios. Simplify the code, for only one or two small methods of interface, do not have to create an interface file, elegant a lot of first to raise a chestnut

Defined

        New DataTemplate (). Exectue (new   Idatamanager() {            @Override            publicvoid  Process () {                System.out.println ("Implementation of the interface implementation Method");            }        });

As can be seen from the discoloration section, this is an interface, and the interface is normally not new. In the class can be used arbitrarily, as long as the implementation of the interface method can be.

This way of use, everywhere

New TimerTask () {           @Override           publicvoid  run () {                          }       }

   New Runnable () {           @Override           publicvoid  run () {                          }       };

is not very familiar, do asynchronous tasks, scheduled tasks commonly used to.

    New Comparator () {            @Override            publicint  Compare (Object O1, Object O2) {                 return 0;            }            @Override            Publicboolean  equals (Object obj) {                return false ;            }        };

is not more familiar with, do a sort of comparison when often used. In Java, anonymous classes are everywhere.

This shorthand method is equivalent to

 Public class Implements Comparator {    @Override    publicint  Compare (Object O1, Object O2) {         return 0;}    }

Abstract class

Abstract class As the name implies, the common characteristics of abstraction, extraction of common behavior, subclass to achieve. Keyword abstract   
Add abstract to a class it can have no abstract method. Conversely, if an abstract modifies a method in a class, it is called an abstract class, and the class must be given an abstract adornment
Usage Scenarios
Abstraction is an important concept in object-oriented software engineering, and abstract classes and interfaces are similar and can be overridden by subclasses. The difference is that the interface has no method body, and the abstract class can have the property and method body normally, and can have its own common method.
  For example, the next single binding card, card class is an abstract class, sub-categories have bank cards, credit cards, membership cards, points card, supermarket joint card. They all have common attributes, such as card number, type, and common payment behavior.
Common with abstract factories, belong to the most common design patterns, the next single business logic will also see the abstract figure. Different types of orders perform different sub-class logic (e.g., regular orders, treasure-taking, patchwork, gift-giving)
Defined

 Public Abstract class Implements Comparator {    @Override    publicint  Compare (Object O1, Object O2) {         return 0;}    }

This abstract class can inherit an interface, it can not need an abstract method, but the abstract class cannot be instantiated, because it is not an image, it requires subclass inheritance

 Public class extends nimingtest {}

Instantiation of

New Abstractchildclasstest (). compare ();

At this point, you can access all of the public methods of the parent class, and if the parent class has an abstract method, the subclass must implement this method, unless the same is an abstract class.

At this point, add an abstract method to the abstract class, let the subclass inherit

 Public Abstract class Implements Comparator {    @Override    publicint  Compare (Object O1, Object O2) {         return 0;    }      Public Abstract   String getName ();}

Sub-class

 Public class extends nimingtest {    @Override    public  String getName () {        returnnull ;    }}

Use

     New Abstractchildclasstest (). Compare ();      New Abstractchildclasstest (). GetName ();

Can also bypass the like, write their own anonymous class, dealing with an interface can also be used for abstract class

New nimingtest () {            @Override            public  String getName () {                return "";            }        };

It can be seen that the abstract class, which cannot be new before, can actually skip the inherited environment and implement the abstract method directly in an anonymous way.

When using the

    New nimingtest () {            @Override            public  String getName () {                return "XSS";            }        }. GetName ();        SYSTEM.OUT.PRINTLN (name);

Static class

Static classes are a special existence because there is only one copy of the metadata in the entire memory. So there is no possibility of instantiation, in fact, static inner class is considered static class.

Keyword static

Keywords cannot be decorated with classes (external classes only) and can only be used for member variables and methods. Any class that has a method that is modified by static, we call him static class.

Static variables, static blocks, static methods static internal classes

Usage Scenarios

Places that are typically used for tool classes or similar enumeration of member variables to compare fixed values

Defined

The following code shows static variables, static blocks, static methods, static internal classes

Public  class Staticclasstest {
    static {
        System.out.println ("Static block initialization work");
    }
    public static int count;
    public static int getsum (int a,int b) {
        return a+b;
    }
    public static Class staticinnerclass{
        public void Register () {
            SYSTEM.OUT.PRINTLN ("Only registered channel");
        }
    }
}

Instantiation of

No instantiation is required for static correlation, only one copy in memory

        (Staticclasstest.getsum);        Staticclasstest.count= 2;

Sealing class

Sealed classes are also called final classes. There is no difference between a normal class and a property. Unique attribute: cannot be inherited like this

Keyword: final

Usage Scenarios

The person who created the class felt the class and the need not to extend it, and no one could extend it, adding the class to the final decoration so that it could not be inherited

Defined

final class Innertestmain {}

Instantiation of

Just like the normal class, new is good. The sealing class is seldom seen in daily use and is not widely used

Summarize

Listed a circle down, only to find that the protagonist is the inner class.

To calculate, non-static inner class, anonymous inner class, static inner class, abstract inner class, abstract static inner class. There are also LAMDA expressions, which are also anonymous classes to use.

The knowledge about classes is here.

To elaborate on classes in Java