面向对象的基础篇_02

基础篇_02的主要内容

• 1、引用传递和值传递
• 2、链表
  

  ---

一丶引用传递和值传递

1、基本类型和引用类型在内存中的保存

|- Java中数据类型分为两大类，【基本类型】和【对象类型】。

• 基本类型的变量保存原始值，即它代表的值就是数值本身；
  
  • 这里的基本类型包括:byte,short,int,long,char,float,double,Boolean,returnAddress，etc...
• 引用类型的变量保存引用值。
  
  • "引用值"指向内存空间的地址，代表了某个对象的引用，而不是对象本身，对象本身存放在这个引用值所表示的地址的位置。
  • 引用类型包括：类类型，接口类型和数组。

2、变量的基本类型和引用类型的区别

|- 变量也有两种类型：【基本类型】和【引用类型】。

• 基本数据类型在声明时系统就给它分配空间:

int a;
a=10;//正确，因为声明a时就分配了空间

• 引用就不相同了，它声明时只给变量分配了引用空间，而不分配数据空间:

Date date;date=new Date();date.getDate();//执行实例化，开辟数据空间存放Date对象，然后把空间的首地址传给“今天到的日期”变量  System.out.println(date.getDate());//输出今天的日期/* *如果注释掉date=new Date();就会有异常抛出 *NullPointerException，意思就是说一个空的变量，一个空的栈内存。 *The local variable date may not have been initialized *也就是说对象的数据空间没有分配 */

3、引用传递和值传递

引用传递是Java的核心问题，引用传递的操作的核心就是内存地址的传递。
这里要用 【实际参数】 和 【形式参数】的概念来帮助理解，

• 值传递：
方法调用时，实际参数把它的值传递给对应的形式参数，函数接收的是原始值的一个copy，此时内存中存在两个相等的基本类型，即实际参数和形式参数，后面方法中的操作都是对形参这个值的修改，不影响实际参数的值。
  
  • 
    
    • 范例：

              public class Test01 {                    public static void change(int a){                        a=10000;                    }                    public static void main(String[] args) {                    int a=10;                    System.out.println(a);//10                    change(a);                    System.out.println(a);//10                    }                }

改变的是形式参数的值，结果不影响实际参数。

• 引用传递：也称为传地址。
方法调用时，实际参数的引用(地址，而不是参数的值)被传递给方法中相对应的形式参数，函数接收的是原始值的内存地址；在方法执行中，形参和实参内容相同，指向同一块内存地址，方法执行中对引用的操作将会影响到实际对象。
  
  • 
    
    • 范例：

                public class Test02 {                    public static void change(int []a){                        a[0]=50;                    }                    public static void main(String[] args) {                        int []a={10,20};                        System.out.println(a[0]);//10                        change(a);                        System.out.println(a[0]);//50                    }                }

这里传来的是地址，形式参数和实际参数有一样的地址，改变了地址中的内容

• 通过以下三个Demo来说明作用

class Demo{    private int count = 10 ;    public void setCount(int count){    this.count = count ;    }    public int getCount(){    return this.count ;    }};public class Demo01 {    public static void main(String args[]){        Demo d1 = new Demo() ;        d1.setCount(100) ;        fun(d1) ;        System.out.println(d1.getCount()) ;        //输出的结果为30    }    public static void fun(Demo d2){        d2.setCount(30) ;    }};

public class Demo02 {    public static void main(String args[]){        String str = "hello" ;            fun(str) ;        System.out.println(str) ;        //输出的结果是hello    }    public static void fun(String temp){        temp = "world" ;    }};

• 字符串的内容无法改变，改变的只是内存地址的指向。

class Demo{    private String str = "hello" ;    public void setStr(String str){        this.str = str ;        }    public String getStr(){        return this.str ;    }};public class Demo03 {    public static void main(String args[]){        Demo d1 = new Demo() ;        d1.setStr("world") ;        fun(d1) ;        System.out.println(d1.getStr()) ;        //最后的输出结果是！！！    }    public static void fun(Demo d2){        d2.setStr("!!!") ;    }};

二丶链表的认识（这里是说一个指针域的）

1、链表是一个个结点连接起来的长链。

• 链表包括两个部分
  
  • |-数据域：存放数据的区域。例如：姓名、地址、学号etc...
  • |-指针域：存放一个指针的区域。这个指针

class Node {    private String name ; // 保留节点名称    private Node next ;   // 保存下一个节点的引用    public Node(String name){  //含有参数的构造器来保存结点名称        this.name = name ;        //this.name中的name是Node类中的name        //= name 是传过来参数name    }    public String getName(){        return this.name ;    }    public void setNext(Node next){        this.next = next ;    }    public Node getNext(){        return this.next ;    }}public class Demo04 {    public static void main(String args[]){        Node na = new Node("A") ;        Node nb = new Node("B") ;        Node nc = new Node("C") ;            na.setNext(nb) ;//a的指针域指向b            nb.setNext(nc) ;//b的指针域指向c    }}

在栈内存中存放的是na，nb，nc
在堆内存中存放的是name：A、B、C 和next：nb、nc、null

• 第一个结点A的指针域na指向的是nb，所以堆内存中存放的是结点A到的name和nb。同理可得。
在设置好了关系之后，只能通过递归的方式完成全部输出。

public class Demo05 {    public static void main(String args[]){        Node na = new Node("车厢 A") ;        Node nb = new Node("车厢 B") ;        Node nc = new Node("车厢 C") ;            na.setNext(nb) ;            nb.setNext(nc) ;            print(na) ;    }    public static void print(Node node){        if(node != null){ // 避免空指向异常            System.out.println(node.getName()) ;            if(node.getNext() != null){                print(node.getNext()) ;            }        }    }}

自动的完成增加和输出的功能

• 需要考虑到以下的几个问题：
  
  • 每一个结点都要保存起来。设置一个可以保存节点关系的类：Node
  • 需要一个添加结点，并按照结点次序连接起来的类：Link
  • 第一个结点是头结点，必须保留好根节点，private封装起来

下面是一个链表的基本数据模型。

class Node {    private String name ; // 保留节点名称    private Node next ;  // 保存下一个节点的引用    public Node(String name){        this.name = name ;    }    public String getName(){        return this.name ;    }    public void setNext(Node next){        this.next = next ;    }    public Node getNext(){        return this.next ;    }    public void addNode(Node newNode){//添加结点        if(this.next == null){            this.next = newNode ;        } else {            this.next.addNode(newNode) ;  // 当前节点的下一个继续往下判断        }    }    public void printNode(){//输出结点        System.out.println(this.name) ;        if(this.next != null){            this.next.printNode() ;        }    }}class Link {  // 表示的是一个节点的操作类    private Node root ;  // 表示根节点    public void add(String name){  // 增加新节点        Node newNode = new Node(name) ;  // 新节点        if(this.root == null){  // 现在没有根节点            this.root = newNode ; // 第一个节点是根节点        } else {  // 应该排在最后            this.root.addNode(newNode) ;  // 向后面排队        }    }    public void print(){        this.root.printNode() ;//从根结点开始调用，这个函数的方法在类Node中    }}public class Test {    public static void main(String args[]){        Link link = new Link() ;        link.add("车厢 A") ;        link.add("车厢 B") ;        link.add("车厢 C") ;        link.add("车厢 D") ;        link.add("车厢 E") ;        link.print() ;    }}