/** * 内部类：在一个类的内部中定义的类 * 1. class Outer{ *      class Inner{} * } * 2. class Outer{ //方法内部类 *      public void doSomething(){ *          class Inner(){} *      } * } * 2*：1.方法内部类只能在定义该内部类的方法中实例化      *     2.方法内部类对象不能使用该内部类所在方法的非final局部变量 *      （原因：局部变量随着方法调用的结束而消失，而new出来的内部类对象的作用域是可以在方法外的） * 3. class Outer{ //静态内部类：没有外部类对象时也能够访问它，且仅能访问外部类的静态成员和方法 *          static class Inner{}  *     } *     Outer.Inner n = new Outer.Inner();  */public class Main {    public static void main(String[] args) {        Dog g1 = new Dog(); //产生外部类实例        Dog.ChildDog cg1 = g1.new ChildDog(); //实例化内部类对象，该方式一般不使用        g1.say();        g1.ChildSay();        cg1.say();    }}class Dog{ //会生成两个class文件    private String name = "kws";    public void say(){        System.out.println("I‘m a Dog, My name is "+name);    }    class ChildDog{ //内部类（成员内部类）        public void say(){            System.out.println("I‘m a ChildDog, My mom‘s name is "+name);        }    }    public void ChildSay(){        ChildDog cg1 = new ChildDog();        cg1.say();    }}

/** * 匿名内部类：没有名字的内部类，有三种 * 1.继承式 * 2.接口式 * 3.参数式 *  * 使用匿名内部类几个原则： * 1.不能有构造方法，只能有一个实例 * 2.不能定义任何静态成员、静态方法 * 3.不能是public, protected, private, static * 4.一定是在new的后面，用其隐含实现一个接口或实现一个类 * 5.匿名内部类为局部的，所以局部类的所有限制对其生效 *  * 内部类的作用： * 每个内部类都能独立地继承自一个（接口）实现，所以无论外部类是否已经继承了某个（接口的）实现， * 对于内部类都没有影响。如果没有内部类提供的可以继承多个具体或抽象的类的能力，一些设计与编程问题 * 就很难解决。从这个角度看，内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地 * 实现了“多重继承”。【JAVA只能是单继承】 */public class Main {    public static void main(String[] args) {        Dog d1 = new Dog(){ //1.继承式匿名内部类            public void say(){                System.out.println("我是一只匿名狗");            }        };        d1.say();                Child d2 = new Child(){ //2.接口式匿名内部类            public void talk(){                System.out.println("我是一只继承狗");            }        };        d2.talk();                ChildTalk(new Child(){ //3.参数式匿名内部类            public void talk(){                System.out.println("我是一只参数狗");            }        });    }    public static void ChildTalk(Child c){        c.talk();    }}class Dog{    protected String name;    Dog(){};    Dog(String name){        this.name = name;    }    public void say(){        System.out.println("I‘m a Dog, My name is "+name);    }}class maleDog extends Dog{    public maleDog(String name){        super(name);    }    public void say(){        System.out.println("I‘m a maleDog, My name is "+name);    }}interface Child{    public void talk();}

/** * 链表的实现 */public class Main {    public static void main(String[] args) {        NodeManager nm = new NodeManager();        nm.printNode();        nm.addNode("node1");        nm.addNode("node2");        nm.addNode("node3");        nm.addNode("node4");        nm.addNode("node5");        nm.printNode();        nm.delNode("node3");        nm.printNode();        nm.delNode("node1");        nm.printNode();    }}class NodeManager{    private Node root; //根结点    public void addNode(String name){        if(root==null){            root = new Node(name);        }else{            root.add(name);        }    }    public void delNode(String name){        if(root!=null){            if(root.name.equals(name)){                root = root.next;            }else{                root.del(name);            }        }    }    public void printNode(){        if(root!=null){            System.out.print(root.name+"-->");            root.print();        }else{            System.out.println("NULL");        }    }    class Node{        private String name;        private Node next;        public Node(String name){ this.name = name; }        public void add(String name){            if(this.next==null){                this.next = new Node(name);            }else{                this.next.add(name);            }        }        public void del(String name){            if(this.next!=null){                if(this.next.name.equals(name)){                    this.next = this.next.next;                }else{                    this.next.del(name);                }            }        }        public void print(){            if(this.next!=null){                System.out.print(this.next.name+"-->");                this.next.print();            }else{                System.out.println("NULL");            }        }    }}

/** * 八种基本数据类型的包装类 * 基本类型      包装类        父类 * 1.int        Integer      (Number) * 2.char       Character    (Object) * 3.float      Float        (Number) * 4.double     Double       (Number) * 5.boolean    Boolean      (Object) * 6.byte       Byte         (Number) * 7.short      Short        (Number) * 8.long       Long         (Number) *  * 基本数据类型 --> 包装类    ：  装箱操作 * 包装类 --> 基本数据类型    ：  拆箱操作 */public class Main {    public static void main(String[] args) {        Long x1 = new Long(100); //手动装箱        Long x2 = 100L; //自动装箱        long x3 = x2; //自动拆箱        long x4 = x1.longValue(); //手动拆箱                String s1 = "123456";        int d1 = Integer.parseInt(s1);        Integer d2 = Integer.valueOf(s1);        System.out.println(d1+" "+d2);                Integer w1 = new Integer(100);        Integer w2 = new Integer(100);        System.out.println(w1==w2); //false        Integer w3 = -128;        Integer w4 = -128;        System.out.println(w3==w4); //true        //Integer直接赋值时，当值为1个字节以内的数时，将使用同一个对象(-128~127)        //Byte Short Long Integer 享元设计模式    }        /**     * 享元模式：使用共享对象，用来尽可能减少内存使用量以及分享资讯给尽可能多的相似对象；     * 它适用于大量对象只是重复因而导致无法令人接受的使用大量内存。     * 通常对象中的部分状态是可以分享。常见做法是把它们放在外部数据结构，当需要使用时再将它们传递给享元。     * #运用共享技术有效的支持大量细粒度的对象【例如游戏中的子弹】     */}

/** * 包：用于对多个java源文件的管理，就像我们的文件目录 * 定义一个包：package com.vince  【只能出现在代码中的第一句】 * 运行时必须指定包名   例： java com.vince.Main  或   java com/vince/Main *  * 访问修饰符 * 作用域：       同一个类     同包     不同包子类     不同包非子类 * public          true       true       true           true * protected       true       true       true           false   * 默认            true       true       false          false * private         true       false      false          false */