Notes on interfaces, polymorphism, inner classes, and more!

1. Static

The static keyword can modify member variables and member methods

basic concept:

static member belongs to class
It can be accessed through the class name, and is generally modified with public
classname.propertyname; classname.methodname(); can also be accessed by object name (not recommended)

Memory explanation:

Static content is too static to be deployed with any object that belongs to a class, and static variables are also called class variables;
Static variables are assigned when the class is loaded (class level takes precedence over object level)
Multiple objects share a static variable. When one object modifies the variable, it will affect all objects

Static Notes:

Static can only access static! (because of load order)
Non-static can access static

2. Interface

Interface (English interface) in the Java programming language, is an abstract type, is a collection of abstract methods (functions), the interface is declared by interface
It makes up for the drawbacks of single inheritance in Java. Subclasses can implement one or more interfaces while inheriting a class to extend their functions.

Interface definition syntax

public interface interface name {
		public abstract void method name();
		public void method name();  //After compilation it is public abstract void method name();
		void method name(); //After compilation it is public abstract void method name();

Interface usage syntax

//class implements interface
public class C implement B ,A {    }

interface inherits interface
public interface D extends B,A{    }

2.1 Characteristics of the interface

  • Interface cannot be instantiated
  • The implementing class must implement all abstract methods in the interface, otherwise the class is a class containing abstract methods and should be defined as an abstract class
  • A class can implement multiple interfaces while inheriting other classes
  • An interface can inherit from multiple interfaces

2.2 Characteristics of members in interfaces

  • Ordinary methods become abstract public methods: add public abstract by default
  • Ordinary member variables become static variables, the default is added: public static final
  • default modifies the default method: subclasses can override or not override
  • The static method in the interface is called directly with the interface class name
public interface IA{
	//1. Static variables can be inherited by subclasses
	public static final int A = 10;
	int B = 20; //After compilation public static final int B = 20 ;
	public int C = 30;   //After compilation public static final int C =30;
	//2. Abstract methods are inherited by subclasses, forcing subclasses to override
	public abstract void show();
	void show1(); //After compilation: public abstract void show1(); 
	//3. Default methods are inherited by subclasses, and subclasses may or may not override them
	public default void show2(){
		Systeam.out.println("IA...>> default show2()........");
	//4. Static methods cannot be inherited by subclasses, only belong to this interface and can only be accessed through this interface name
	public static void show3(){
		Systeam.out,println("IA --->  static show3().....");


3. Polymorphism

Polymorphism: Multiple Forms of One Thing
Polymorphic code embodiment: parent class references point to subclass objects such as: Animal a = new Dog();
After polymorphic invocation: the method invoked is determined by the reference type!

3.1 Polymorphic correlation

  • Polymorphism Premise:

  • There must be an inheritance relationship or an implementation relationship

  • There must be a way for the subclass to override the parent class object (this only makes sense)

  • The advantage of polymorphism: improve code scalability

  • Disadvantage of polymorphism: cannot use methods specific to subclasses

Polymorphism case:

//Two parent classes/interfaces

public class Animal {

    public void eat() {
        System.out.println("eat fragrant...");


public interface Fliable {

    void qifei();
    void fei();
    void luodi();

public class Cat extends Animal{

    //catch mice
    public void catchMouse() {
        System.out.println("catch mice...");

    public void eat() {
        System.out.println("cat scratching...");

public class Dog extends Animal {

    public void lookHome() {
        System.out.println("Watching the house....");

    public void eat() {
        System.out.println("eat bones...");
public class Bird extends Animal implements Fliable{

    //tell the time
    public void baoshi() {
        System.out.println("cuckoo,Now"+new Date());

    public void eat() {
        System.out.println("peck to eat..");

    public void qifei() {
        System.out.println("wings fly");

    public void fei() {
        System.out.println("fly with wings");

    public void luodi() {
        System.out.println("fold the wings to the ground");

//polymorphic use
public static void main(String[] args) {

        Cat cat = new Cat();;
        Dog dog = new Dog();;
        Bird bird = new Bird();;
        System.out.println("======The above is before polymorphism=============");
        Animal animal = new Cat();;

        Animal animal2 = new Dog();;

        Animal animal3 = new Bird();;

        Fliable fliable = new Bird();

        //==========The following code reflects the benefits of polymorphism =======================
        Animal c = new Cat();  //Different subclass objects are passed into the method method. Although all eat methods are executed, the execution results are different.
        Animal d = new Dog();
        Animal b = new Bird();
//With polymorphism, you only need to define the parent class type and receive different subclass objects
public static void method(Animal a) {;

3.2 Up and down transition

The subclass object of the polymorphism itself is assigned to the parent class variable >> >> >> upward transformation For example: Animal a = new Dog();

Downcasting : coercion
Downcasting is that we can use instanceof to determine the type of object

Such as code:
//create breeder class

public class SiYangYuan {

    public void feed(Animal animal) { //Animal animal = new Cat() defines that the parent class variable can receive subclass objects
        //all animals have to eat;

        //Determine the type of object
        //If it's a cat, catch the mouse
        if(animal instanceof Cat) {  
            Cat cat = (Cat)animal;  //downcast
        //If it's a dog, watch the door
        if(animal instanceof Dog) { 
            Dog dog = (Dog)animal;  //downcast

4. Inner class

Member inner classes are defined at member locations, outside methods

Member inner class definition:

package com.itheima.demo09;

public class Outer{
    //Member variables
    private String name = "big power";
    //member method
    public void method(){...}
    //member inner class
     class Inner{
        public void innerMethod() {
            System.out.println("Member inner class method was called");
            //I am an inner class method

Member inner class object creation:

public class Demo09 {
    public static void main(String[] args) {
        //Create external class object
        Outer outer = new Outer();

        //Member inner class creates object
        Outer.Inner inner = Inner();
        Outer.Inner inner2 = new Outer().new Inner();


The compiled class file of the inner class of the member: Outer$ inner.class The inner class of the member is also an independent class file, which belongs to the outer class of Outer
The member inner class can be modified by modifiers such as private/public/static. If it is modified with static, the object creation method is as follows:

//If the member inner class is modified with static, the object is created in the following format
Outer.Inner inner = new Outer.Inner();

Local inner class definition:

public class Outer{
    //Member variables
    private String name = "big power";
    //member method
    public void method(){

        System.out.println("outer method was called");
        //local inner class
        class Inner2 {
            public void innerMethod2() {
                System.out.println("Local inner class method was called");
                //I am an inner class method

        //Local inner classes are defined, objects are created on-the-fly and used
        Inner2 inner2 = new Inner2();

The compiled class file of the local inner class: Outer $1Inner2.class Local inner class Note; the local inner class has a number

5. Anonymous inner classes

object of local inner class without class name


//Use a format that both defines a local inner class and creates objects of that class
  new parent type(){
      //Override method
  //The target parent class, in this case, a subclass object of this class is to be created
  public abstract class Animal {
    public abstract void eat();

  public static void main(String[] args) {
    //After creating an object, you can use polymorphism to assign the subclass object to the parent class reference
    Animal animal = new Animal(){

        public void eat() {
    //call method;

Tags: Java C++ Algorithm

Posted by ess14 on Wed, 31 Aug 2022 03:28:19 +0300