1-5 序列化-内部类-待定其他知识

上一篇:
1-4 异常-接口和抽象类-socket通信原理-Runtime类-泛型-字节流和字符流

这里是easy的java基础面试
下面是总的阅览:

java基础
java集合
JVM
多线程
mysql_数据库
计算机网络
nosql_redis
设计模式
操作系统
消息中间件activeMq
SSM框架面试题
服务中间件Dubbo

目录

1-序列化

1-1一些资料

序列化是将对象编码成字节流以及从字节流中重新构建对象的操作。

序列化实现原理: 

serializable 该接口没用方法，只是一种标记，序列化传输时使用默认writeObject 和readObject，并通过反射调用ObjectInputStream和 ObjectOutputStream，如果没有设置serializable标识，则报错。

2-内部类

如果你不需要内部类对象与其外围类对象之间有联系，那你可以将内部类声明为 static。这通常称为嵌套类（nested class）。
Static Nested Class 是被声明为静态（static）的内部类，它可以不依赖
于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化。想要理解 static 应用于内部类时的含义，你就必须记住，
普通的内部类对象隐含地保存了一个引用，指向创建它的外围类对
象。然而，当内部类是 static 的时，就不是这样了。

嵌套类意味着：1. 嵌套类的对象，并不需要其外围类的对象。
2. 不能从嵌套类的对象中访问非静态的外围类对象。

如下所示代码为定义一个静态嵌套类
public class StaticTest{
	private static String name = "woobo";
	private String num = "X001";
	static class Person{ // 静态内部类可以用 public,protected,private 修饰
		// 静态内部类中可以定义静态或者非静态的成员
		private String address = "China";
		Private Static String x=“as”;
		public String mail = "kongbowoo@yahoo.com.cn";//内部类公有成员
		public void display(){
			//System.out.println(num);//不能直接访问外部类的非静态成员
			// 静态内部类不能访问外部类的非静态成员(包括非静态变量和非静态方法)
			System.out.println(name);//只能直接访问外部类的静态成员
			//静态内部类只能访问外部类的静态成员(包括静态变量和静态方法)
			System.out.println("Inner " + address);//访问本内部类成员。
		}
	}
	
	public void printInfo(){
		Person person = new Person();
		// 外部类访问内部类的非静态成员:实例化内部类即可
		person.display();
		//System.out.println(mail);//不可访问
		//System.out.println(address);//不可访问
		System.out.println(person.address);//可以访问内部类的私有成员
		System.out.println(Person.x);// 外部类访问内部类的静态成员：内部类.静态成员
		System.out.println(person.mail);//可以访问内部类的公有成员
	}
	public static void main(String[] args){
		StaticTest staticTest = new StaticTest();
		staticTest.printInfo();
	}
}

在静态嵌套类内部, 不能访问外部类的非静态成员, 这是由 Java 语法中"静态方法不能直接访问非静态成员"所限定.注意, 外部类访问内部类的的成员有些特别, 不能直接访问, 但可以通过内部类实例来访问, 这是因为静态嵌套内的所有成员和方法默认为静态的了.同时注意,
内部静态类 Person 只在类 StaticTest 范围内可见, 若在其它类中引用或初始化, 均是错误的.

2-1静态内部类和非静态内部类

2-1-1区别

静态内部类可以有静态成员，而非静态内部类无静态成员

静态内部类的非静态成员可以访问外部类的静态变量，而不可以访问外类的非静态成员

非静态内部类的非静态成员，可以访问外类的非静态成员变量(不论是private 还是成员方法。)

Outer.Inner in = new Outer().Inner() Inner是静态内部类， -----> 成了一个顶级类

2-1-2静态内部类

package com.xlg.InnerClassAll.静态内部类;

/**
 * @program: designpattern
 * @description: 外部类
 * @author: Mr.Wang
 * @create: 2020-09-22 14:28
 **/
public class Outer {

    private int outerVariable = 1;

    private int commonVariable  = 2;

    private static int outerStaticVariable = 3;

    static  {
        System.out.println("outer 的静态块被执行了......");
    }

    /**
     *  成员方法
     */
    public void outerMethod() {
        System.out.println("我是外部类的outerMethod方法。。");
    }
    public static void outerStaticMethod() {
        System.out.println("我是外部类的outerStaticMethod方法..");
    }
	
	// 静态内部类 
    public static class Inner {
        private int innerVariable = 10;
        private int commonVariable = 20;

        static {
            System.out.println("Outer.inner的 静态块执行了");
        }
        private static int innerStaticVariable = 30;

        // 内部类的成员方法
        public void innerShow() {
            System.out.println("innerVariable : "  + innerVariable);
            System.out.println("内部的 commonVariable : " + commonVariable);
            System.out.println("outerStaticVariable : " + outerStaticVariable);
            outerStaticMethod();
        }

        // 静态方法
        public static void innerStaticShow() {
            // 被调用时会先加载Outer类
            outerStaticMethod();
            System.out.println("outerStaticVariable ：" + outerStaticVariable);
        }
    }

    // 外部类的内部如何和内部类打交道
    public static void callInner() {
        System.out.println(Inner.innerStaticVariable);
        Inner.innerStaticShow();
    }
}

package com.xlg.InnerClassAll.静态内部类;

/**
 * @program: designpattern
 * @description: 其他类使用静态内部类
 * @author: Mr.Wang
 * @create: 2020-09-22 14:38
 **/
public class Other {

    public static void main(String[] args) {
        // 访问静态内部类的时候，Inner类被加载， 此时外部类未被加载。独立存在，不依赖于外部lei
        Outer.Inner.innerStaticShow();
        // 访问静态内部类的成员方法
        Outer.Inner inner = new Outer.Inner();
        inner.innerShow();
    }
}

执行结果： 

Outer.inner的 静态块执行了
outer 的静态块被执行了......
我是外部类的outerStaticMethod方法..
outerStaticVariable ：3
innerVariable : 10
内部的 commonVariable : 20
outerStaticVariable : 3
我是外部类的outerStaticMethod方法..

2-1-3成员内部类

package com.xlg.InnerClassAll.成员内部类;

/**
 * @program: designpattern
 * @description: 外部类 成员内部类的定义
 * @author: Mr.Wang
 * @create: 2020-09-22 10:58
 **/
public class Outer {

    private int outerVariable = 1;
    private int commonVariable = 2;

    private static int outerStaticVariable = 3;

    /**
     * @author Mr.wang        外部类普通方法
     * @date 2020/9/22 11:00
     * @param []
     * @return void
     */
    public void outerMethod() {
        System.out.println("我是 外部类的 outerMethod 普通方法");
    }

    public static void outerStaticMethod() {
        System.out.println("我是 外部类的outerStaticMethod的静态方法 ");
    }
    
    /**
     * 内部类
     */
    public class Inner {
        private int commonVariable = 20;

        public Inner() {

        }
        
        /**
         * 成员方法， 访问外部类信息(属性 ，，方法)
         */
        public void innerShow() {
            //  当和外部类冲突时， 直接引用属性名， 是内部类的成员属性
            System.out.println("内部类的commonVariable: " + commonVariable);
            // 内部类访问 外部属性
            System.out.println("outerVariable : " + outerVariable);
            // 当和外部类属性名重叠时， 可通过外部类名.this.属性名 访问
            System.out.println("外部类的commonVariable: " + Outer.this.commonVariable);
            System.out.println("outerStaticVariable: " + outerStaticVariable);
            // 访问外部类的方法
            outerMethod();
            outerStaticMethod();
        }
    }

    /**
     *  外部类访问内部类信息
     */
    public void outerShow(){
        Inner inner = new Inner();
        inner.innerShow();
    }
}

package com.xlg.InnerClassAll.成员内部类;
/**
 * @program: designpattern
 * @description: 其他类使用成员内部类
 * @author: Mr.Wang
 * @create: 2020-09-22 11:08
 **/
public class Other {
    public static void main(String[] args) {
        // 外部类对象
        Outer outer = new Outer();
        // 创建内部类
        Outer.Inner inner =  outer.new Inner();
        inner.innerShow();

        outer.outerShow();
        // 或者
        Outer.Inner kk = new Outer().new Inner();
    }
}

执行结果: 

内部类的commonVariable: 20
outerVariable : 1
外部类的commonVariable: 2
outerStaticVariable: 3
我是 外部类的 outerMethod 普通方法
我是 外部类的outerStaticMethod的静态方法 
内部类的commonVariable: 20
outerVariable : 1
外部类的commonVariable: 2
outerStaticVariable: 3
我是 外部类的 outerMethod 普通方法
我是 外部类的outerStaticMethod的静态方法 

2-1-4方法内部类

package com.xlg.InnerClassAll.方法内部类;

import java.awt.image.PackedColorModel;

/**
 * @program: designpattern
 * @description: 方法外部类
 * @author: Mr.Wang
 * @create: 2020-09-22 15:05
 **/
public class Outer {

    private int outerVariable = 1;
    private int commonVariable  = 2;
    private static int outerStaticVariable = 3;

    public void outerMethod() {
        System.out.println("我是 外部类的outerMethod方法 ");
    }

    public static void outerStaticMethod() {
        System.out.println("我是 外部类的outerStaticMethod方法 ");
    }

    /**
     *   程序的入口
     * @param args
     */
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.outerCreateMethod(100);
    }

    /**
     *  成员方法
     * @param value
     */
    public void outerCreateMethod(int value) {
        // 女性
        boolean sex = false;
        
        // 方法内部类 
        class Inner {
            private int innerVariable = 10;
            private int commonVariable = 20;

            /**
             *   局部类方法
             */
            public void innerShow() {

                System.out.println("innerVariable : " + innerVariable);
                // 方法的变量
                System.out.println("是否男性: "  + sex);
                // sex = true  报错
                System.out.println("参数value : " + value);
                // 调用外部类的 信息
                System.out.println("outerVariable : "+ outerVariable);
                System.out.println("方法内部类的 commonVariable ：" + commonVariable);
                System.out.println("外部类的 commonVariable : " + Outer.this.commonVariable);
                System.out.println("outerStaticVariable : " + outerStaticVariable);
                outerMethod();
                outerStaticMethod();
            }
        }
        // 局部类 只能在方法类使用
        Inner inner = new Inner();
        inner.innerShow();
    }
}

结果显示: 

innerVariable : 10
是否男性: false
参数value : 100
outerVariable : 1
方法内部类的 commonVariable ：20
外部类的 commonVariable : 2
outerStaticVariable : 3
我是 外部类的outerMethod方法 
我是 外部类的outerStaticMethod方法 

2-2匿名类

几点说明: 

匿名内部类是因为没有类名，可知道 匿名内部类不能定义构造器。

因为在创建匿名内部类时，会立即创建它的实例，可知匿名内部类不能是抽象类，必须实现接口或抽象父类的所有抽象方法。

匿名内部类会继承一个父类(只有一个) 或实现一个接口(只有一个)，实现父类/接口中的抽象方法，/ 添加自定义方法。

当匿名内部类和外类同名变量时，默认访问的是匿名内部类的变量(方法)，要访问外部类的static变量或者static方法，则需要加外类类名。

package com.xlg.InnerClassAll.匿名内部类;

/**
 * @program: designpattern
 * @description: 接口 中方法默认为 public
 * @author: Mr.Wang
 * @create: 2020-09-22 15:33
 **/
public interface IAnimal {
    void speak();
}

package com.xlg.InnerClassAll.匿名内部类;

/**
 * @program: designpattern
 * @description: 外部内，内部类
 * @author: Mr.Wang
 * @create: 2020-09-22 15:35
 **/
public class Outer {

    public static IAnimal getInnerInstance(String speak) {
        return new IAnimal() {
            @Override
            public void speak() {
                System.out.println(speak);
            }
        };
    }

    public static void main(String[] args) {
        // 实际山就是 一个冲写了方法的对象调用
        Outer.getInnerInstance("小狗汪汪汪！").speak();
    }
}
小狗汪汪汪！

下一篇:
2-1 集合