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
*/