day13 object-oriented programming

Posted by andremta on Wed, 08 Sep 2021 04:44:33 +0200

1. Factory Method

What is the factory method?

Get Object by Method Call


1) Users cannot create objects directly. Creating objects that are too complex can be effortless in a factory (mobile phone) (singleton)

 2) Users do not want to participate in object creation


Comparison of abstract classes and interfaces

2. Internal Classes

Members of the class

Attributes: Describe the characteristics of things

Method: Describe the behavior of things

Pseudo members: constructors, statement blocks

Internal Class

What is an internal class?

Declare a class inside another class. The preceding class is called the inner class, and the latter is called the outer class.

Memory variable

Variables are scored by location

1. number variable: Variables declared outside of methods in a class that have a wide range and a long lifetime

1) Class variables: method areas with static modifications, subordinate to class templates, permanent lifetime, and stored in the heap

2) Instance variable: GC area stored in the heap with no static modification, life as long as object

2. Local variables: Variables declared in the method have a small range, short lifetime, and are stored on the stack along with the stack of the method

Classification of internal classes

1. Member internal classes: internal classes declared outside methods in classes

1) Nested Classes: static-modified, not strongly dependent, at the same level as external classes

Use is indistinguishable from internal classes

class Outer{
    public static class Inner2{//Nested classes, members of objects of external classes cannot be used directly
        public static int no = 10;

        public static void test4(){//Create a static method in a nested class
            System.out.println("static test4()...");

        private String name = "Nested Class";

        public Inner2(){//This is a parameterless constructor for nested classes

        public void test3(){//A non-static method was created in a nested class
            //System.out.println(;//Members of objects of external classes cannot be used directly

 public static void main2(String[] args) {
        Outer.Inner2.test4();//Static methods in nested classes can be called directly
       // Outer.Inner2.test3();//Non-static methods cannot be called directly in a static environment
        System.out.println(;//Static properties in nested classes can be called directly

        Outer.Inner2 inner2 = new Outer.Inner2();//Objects that can create nested classes
        inner2.test3();//Use this nested class object to invoke its non-static methods

2) Ordinary internal class: no static modification, subordinate to external class objects

      Members of external class objects can be freely used in internal class objects to replace common object associations

class Outer{

    private  String  name = "External Class";
    protected class Inner1{//Common internal class, subordinate to external class objects
        private  String name = "I am an internal class";

        //Ordinary internal classes do not allow ordinary static members, why??
        //Because adding a static will belong to both classes and objects, both modifications will cause it to change and conflict
//      public static int id = 2;
        public int id3;
        public static final int id1 = 3;//If it is static, it can only be modified by final, because final is unique and will not be modified by changes in external classes
        public  Inner1(){

        public void test1(){
            //Internal and external classes must be qualified if they have members with the same name
            System.out.println(;//Proximity principle
            System.out.println(;//The principle of proximity may or may not be limited
            System.out.println(;//The this of an external class must be qualified

public static void main1(String[] args) {
        Outer outer = new Outer();

        //Create internal class objects directly, through external class
        Outer.Inner1 oi1 = new Outer().new Inner1();

Differences between ordinary object associations and internal classes

Internal classes are deeper and more exaggerated object associations. Internal classes associate external classes for the purpose of replacing common object associations so that objects are closely related (interoperable)

Object association, only the public part of the associated object can be used

Internal classes are not as associated with objects

2. Local internal classes: internal classes declared in methods

1) Common Local Internal Class

2) Anonymous Internal Class (Super Focus): Temporarily use an interface to implement subclass objects, use up or scrap.

Parent Reference= new Parent () {

The class body is the class body of the parent's subclass.


99.99% of cases are used with interfaces, which usually have only one abstract method.

Interface Reference= new Interface () {

A class body is the class body of an interface's entity subclass and must implement all abstract methods in the interface


Use scenarios

Lazy to formally write a specific subclass to implement an interface.

Absolute singleton of created objects

Can only be used polymorphically

Note: $denotes the relationship between internal and external classes

interface I7{
    void hello(String s);
public static void main(String[] args) {
    Object o1 = new Object();//create object
    Object o2 = new Object() {};//Anonymous inner class, which is an anonymous subclass of Object
    //This writing omits declarations of specific subclasses and is suitable for one-time creation and use of objects
    I7 i7 = new I7() {
        //The class body part is the class body of the implementation subclass of the interface
        public void hello(String s) {

Create internal class object

Qualification cannot be omitted in a test class

Local variable cannot be weighted limit modifier


3. Enumeration

What is an enumeration?

Enumerations are a special type of object countability, using the enum keyword

Can enumeration types create objects?

Enumeration types cannot create objects because the underlying layer encapsulates the constructor

Three ways to get enumerated objects

1) Get points directly

2) Name acquisition, based on a given constant object name, to get a reference to the corresponding object

3) Get an array of objects that hold all enumerated objects

 Method of enumeration

Enumerate possible scenarios with switch

Constructors in enumerations must be private because they cannot create objects 

4. Exception handling

What is exception handling?

Exception: An abnormal condition that occurs during operation. If not handled, the program crashes

Note: Grammar errors and logic errors are not exceptions during development!

Exception Classification

1. Score by degree

        1) Error: Serious error.Serious issues that cannot be resolved by the java virtual machine.

        2) Exception: General problem.Exceptions caused by programming errors or accidental accidents

2. Divide them according to the way they are handled

        1) Checked exceptions: compile-time exceptions.Exceptions that must be checked and handled in the program, if not handled, compilation errors

Exceptions and their subclasses (except RuntimeException s): general issues that cannot be ignored

        2) Non-Checked Exceptions: Runtime Exceptions.Exceptions that can be checked and handled are not accepted, and if not handled, compilation errors will occur, but runtime errors will occur

Error and its subclasses: Too severe,

RuntimeException and its subclasses: too mild, too common

Both checked and non-checked exceptions can cause a program to crash, so it should be handled

Exception stack throw mechanism

Exception handling

Applicable to all exceptions

1. Capture


Statements that may throw exceptions;

}catch (exception type reference){

If an object of this exception type is actually thrown in the statement, it is caught here


}catch(Exception e){

//Make sure nothing goes wrong


Statements that must be executed regardless of what happened in the previous try catch;

The main function is to release hardware resources outside the GC zone here


Can there be multiple catch es in exception handling?

Exception handling actually protects the back, with multiple catches to prevent incomplete types, or with Exception, a super-invincible omnipotent clip that ensures absolute certainty, but it's better to use multiple different catches

Benefit: Reduce the scope of abnormal damage

What is finally?Why finally?

finally is a statement that must be executed regardless of what happened in the previous try catch;

Because its main function is to release hardware resources outside the GC zone, otherwise a resource leak will occur

This statement intercepts finally

public class TestException {
    public static void main(String[] args) {
        System.out.println("main begin");


            int n = Integer.parseInt(args[0]);
            int m = Integer.parseInt(args[1]);

        }catch (NumberFormatException e){
        }catch (ArithmeticException e){
        }catch (ArrayIndexOutOfBoundsException e){
        }catch (Exception e){

        System.out.println("main end");//Core Code

 The only statement that intercepts finally

Combination method:

        try catch

        try catch finally

        try finally

Understanding a small example of finally




What I'm learning today:

1) Plant method;

2) Internal classes;

3) Enumeration;

4) Exception handling

Topics: Java intellij-idea