JAVA笔记8__内部类/链表的实现/包装类、享元设计模式/包、访问修饰符

/**
 * 内部类：在一个类的内部中定义的类
 * 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
 */