Java变量及其传递、内部类(4.9-4.10)

 
 

变量及其传递 & 内部类

 

一、 Java变量及其传递

1.1 基本数据变量与引用型变量

1. 📒Java变量:
 (1). 基本型变量(8种)
   char,byte,short,int,long,float,double,boolean
 (2). 引用型变量：对象,接口,数组

举例：
    public class MyDate{
	private int day=12;
	private int month=6;
	private int year=1900;
	public MyDate(int y,int m,int d){
		year=y;
		month=m;
		day=d;}
          void addYear()
	{   year++;}
         public void display(){
	System.out.println(year+"-"+month
             +"-"+day);
	}

    public static void main(String[] args){
       MyDate m,n;
       m=new MyDate(2003,9,22);
       n=m;     "//n和m指向同一个地址"
       n.addYear();
       m.display();
       n.display();
       System.out.println(m.toString());
       System.out.println(n.toString());	
    }
    }
      /*运行结果
       2004-9-22
       2004-9-22
       MyDate@11a698a
       MyDate@11a698a
      */

 
 

1.2 成员变量与局部变量

**成员变量与局部变量有没有区别?** 成员变量若为static的称为类变量，否则称为成员变量，而局部变量是在方法体内的变量。 (1) 📒从语法形式上看，成员变量是属于类或接口的，而局部变量是在方法中定义的变量或方法的参变量； 成员变量可以被public，private，static等修饰，而局部变量则不能被访问控制符及static修饰；成员 变量及局部变量都可以被final修饰。 (2) 📒从变量在内存中的存储方式看，成员变量是对象的一部分，而对象是存在于堆中的，而局部变量是 存在于栈中的。 (3) 📒从变量在内存中的存在时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变 量随着方法的调用而产生，随着方法调用结束而自动消失。 (4) 📒成员变量如果没有赋初值，则会自动以该类型的默认值（0,false,null等）赋值；而局部变量则不会 自动赋值，必须显示地赋值后才能使用。

class A{
         int a;
         void m(){
            int b;
            System.out.println(a);  //合法的，a的值为0
            System.out.println(b);  //不合法，编译不通过
           }
        }

 
 

1.3 变量的传递

1. 📒按值传递:当将一个参数传递给一个函数时，函数接收的是原始值的一个副本。因此，如果函数修改了该参数，仅改变副本，而原始值保持不变。(传递8种基本型变量)
2. 📒按引用传递:当将一个参数传递给一个函数时，函数接收的原始值的内存地址，而不是值的副本，因此，如果修改了该参数，调用代码中的原始值也随之改变。(传递对象,接口,数组)
Java中的参数传递比C++简单,按值传递所有参数,制作所有参数的副本,而不管它们的类型。

例1：
class TestTransOfValue
{
  public static void main(String args[])
  {
    int val;
    StringBuffer sb1, sb2;
    val = 10;
    sb1 = new StringBuffer("apples");
    sb2 = new StringBuffer("pears");
    System.out.println("val is " + val);
    System.out.println("sb1 is " + sb1);
    System.out.println("sb2 is " + sb2);
    System.out.println("");

System.out.println("calling modify");
    //按值传递所有参数
    modify(val, sb1, sb2);
    System.out.println("returned from modify");
    System.out.println("");
    System.out.println("val is " + val);
    System.out.println("sb1 is " + sb1);
    System.out.println("sb2 is " + sb2);
  }

public static void modify(int a, StringBuffer r1,
                         StringBuffer r2)
  {
    System.out.println("in modify...");
    //在方法中修改基本类型变量的值
    a = 0;  
    //在方法中修改对象引用值的副本
    r1 = null;  //1
    //在方法中修改副本的对象实体值
    r2.append(" taste good");
    System.out.println("a is " + a);
    System.out.println("r1 is " + r1);
    System.out.println("r2 is " + r2);
  }
}
运行后输出：
val is 10
sb1 is apples
sb2 is pears
calling modify in modify...
a is 0
r1 is null
r2 is pears taste good 
returned from modify
val is 10
sb1 is apples
sb2 is pears taste good 
/*关于这里的sb1和r1：
当参数传到modify后，r1和sb1指向同一个地址，若改变了r1指向的地址，并不会更改sb1指向的地址。这个时候就
相当于看作两个指针了。
关于sb2和r2：
sb2和r2指向同一个地址，这个地址指向的值(实体值)被改变了，则结束后sb2和r2的实体值也就相应的改变了。
*/

例2：
class Swap
{ 
 public static void main(String args[])
  {
    Integer a, b;
    a = new Integer(10);
    b = new Integer(50);
    System.out.println("before swap...");
    System.out.println("a is " + a);
    System.out.println("b is " + b);
    swap(a, b);
    System.out.println("after swap...");
    System.out.println("a is " + a);
    System.out.println("b is " + b);
}

 public static void swap(Integer a, Integer b)
  {
    Integer temp = a;
    a = b;
    b = temp;
    System.out.println("in swap...");
    System.out.println("a is " + a);
    System.out.println("b is " + b);
  }
}
/*
运行后输出：
before swap...
a is 10
b is 50
in swap…
a is 50
b is 10
after swap...
a is 10
b is 50 
*/

**参数传递总结：** (1) Java按值传递所有参数,制作所有参数的副本,而不管它们的类型 (2) 对于基本类型的变量形参修改了并不能反映到函数外面的实参 (3) 对于引用类型的变量，在形参中修改了对象实体值可以反映到实参，在形参中修改了对象引用值， 不能反映到实参

 
 

1.4 引用型变量的实体值、引用值比较

1. 📒参数传递总结：
(1) 比较基本类型的数据: ==和!=
(2) 如果要比较引用型变量是否相同,可以直接用==和!=吗? 答：不能

==和!=用来比较引用型变量时（只能比较引用值（地址）是不是相等）,只能判断运算符两边引用的是不是同一个对象,即对象的地址值（或对象引用值）！！！！！
如何比较两个对象的内容(对象实体值)是否相同?
用equls()方法：

**2. 📒引用型变量比较总结：** (1) 比较两个变量是否同一个对象（即对象引用值是否相同），用==和!= (2) 比较两个变量的内容是否相同用equals方法 (3) **自己定义的类如果要支持equals方法必须重写从Object类继承来的equals方法(比如前面的String类 是java自己的类就不需要重写equals，但是Employee类就是自己定义的类则需要重写equals)** Object类中的equals方法： public boolean equals(Object obj){ return (this==obj); }

equals示例1:
class EqualsTest{
  public static void main(String[] arguments)
  {
     String str1,str2;
     str1="Free the bound periodicals.";
     str2=str1;
     System.out.println("String1: "+str1);
     System.out.println("String2: "+str2);
     System.out.println("Same object? "+(str1==str2));      //true
     str2=new String(str1);
     System.out.println("String1: "+str1);
     System.out.println("String2: "+str2);
     System.out.println("Same object? "+(str1==str2));      //false
     System.out.println("Same value? "+str1.equals(str2));  //true
     String str3,str4;
     str3="busy";
     str4="busy"; //str4=new String("busy")或str4=new String(str3) 
     System.out.println("String3: "+str3);
     System.out.println("String4: "+str4);
     System.out.println("Same object? "+(str3==str4));       //true
     System.out.println("Same value? "+str3.equals(str4));   //true 
     String str5,str6;
     str5="str5busy";
     str6="str6busy";
     System.out.println("String5: "+str5);
     System.out.println("String6: "+str6);
     System.out.println("Same object? "+(str5==str6));      //false
     System.out.println("Same value? "+str5.equals(str6));  //false 	
   }
}

equals示例2：
import java.util.*;
public class EqualsTest {
     public EqualsTest() {    }    
     public static void main(String[] args){
     Employee alice1=new Employee("Alice",75000,1987,12,15);
     Employee alice2=alice1;
     Employee alice3=new Employee("Alice",75000,1987,12,15);
     Employee bob=new Employee("Bob",50000,1989,10,1);
     System.out.println("alice1==alice2: "+(alice1==alice2));    //true
     System.out.println("alice1==alice3: "+(alice1==alice3));    //false 
     System.out.println("alice1.equals(alice3): "+alice1.equals(alice3));  //true
     System.out.println("alice1.equals(bob): "+alice1.equals(bob));   //false 
     System.out.println("bob.toString(): "+bob);  
  }
}

class Employee{
    private String name;
    private double salary;
    private Date hireDay; 
    public Employee(String n,double s,int year,int month,int day){
            name=n;
            salary=s
        hireDay=new Date(year,month,day);
    }
    public String getName(){     return name;     }
    public double getSalary(){   return salary;    }
    public Date getHireDay(){   return hireDay; }
    public void raiseSalary(double byPercent){
            double raise=salary*byPercent/100;
            salary+=raise;
 }

public boolean equals(Object otherObject){     //子类覆盖了Object的equals方法
  if(this==otherObject) return true;
  if(otherObject==null) return false;
  if(getClass()!=otherObject.getClass())
  return false;
  Employee other=(Employee)otherObject;
  return name.equals(other.name)&&
              salary==other.salary&&hireDay.equals(other.hireDay); 
                        //子类覆盖了Object的toString方法
 }
 public String toString(){
  return getClass().getName()+
           "[name="+name+",salary="+salary+",hireDay="+hireDay+"]";
 }
 private String name;
 private double salary;
 private Date hireDay;
}  

 
 

二、 内部类

2.1 内部类的定义与使用

1. 📒内部类的定义：将类的定义置入一个用于封装它的类（外部类）里。
注意：
内部类不能与外部类同名（否则，编译器无法区分内部类与外部类），如果内部类还有内部类，内部类的内部类不能与它的任何一层外部类同名。
作用：
逻辑分组, 隐藏细节

/*内部类结合多态可以很方便的隐藏类的细节(包括类名)
*/
interface Contents{
  int value();
}
interface Destination {
  String readLabel();
}
class Goods{
    private class Content implements Contents{  //"private class Contentimplements Contents" 
        private int i=11;
        public int value(){
  return i;
    }
  }
    protected class GDestination    //"protected class GDestination implements Destination"
    implements Destination{
      private String label;
  private GDestination(String whereTo){
    label=whereTo;
  }
public String readLabel(){
    return label;}}
public Contents cont(){
  return new Content();
  }
public Destination dest(String s){
  return new GDestination(s);
  }
  }
public class TestGoods {   //"public class TestGoods"
    public static void main(String[] args){
         Goods g=new Goods();
         Contents c=g.cont();
         Destination d=g.dest("Beijing");
    }
}

2. 📒内部类对象的创建：创建非静态内部类的对象时一定要确保已经有一个外部类对象。
(1) 利用外部类的方法创建并返回，因为方法是由外部类对象调用的，那创建该内部类对象时，一定已经拥有了所属的外部类对象了
public Contents cont(){      Goods g=new Goods();
return new Content();       Contents c=g.cont();
}

(2) 创建内部类还可以在除外部类中的其它类中，但是要确保该类具有访问内部类的权限，并且已经创建了一个外部类对象。格式如下：

outerObject=new outerClass(Constructor Parameters);
outerClass.innerClass innerObject = outerObject.new InnerClass(Constructor Parameters);

 Goods g1=new Goods();
 Goods.Content c1=g.new Content(); 
OR
 Goods g1=new Goods();
 Goods.GDestination d1=g1.new GDestionation(); 

 
3. 📒内部类的修饰符：
（1）public、protected、private和缺省：访问权限修饰符，用来限定内部类的访问权限，
  一般的外部类是不能用protected和private修饰的。访问权限修饰符的限定和成员变量的限定一样。
（2）final:表明内部类不能继承。
（3）abstract：抽象内部类，不能被实例化。
（4）static：表明一个静态内部类。

4. 📒静态内部类：
和普通的非静态内部类有较大的不同，使用时要遵循如下原则：
（1）实例化static内部类时，在new前面不需要用对象变量；
（2）static内部类中不能访问其外部类的非static属性及方法，即只能访问static成员；
（3）static方法中不能访问非static的属性及方法，也不能不带前缀地new一个非static的内部类。

class A
{
      private int x;
      void m(){
  new B();
     }

     static void sm(){
      //在外部类的静态方法中
     //不能直接创建内部类对象
     //new B();//!!error
    }
class B
{
      B(){x=5;}
  }//B类结束
}//A类结束
class Outer
{
  static class Inner
  {
  }
}

class TestInnerStatic
{
  public static void main(String[] args)  
  {
    //创建非静态内部类B的对象a_b和ab
    A.B a_b=new A().new B();
    A a=new A();
    A.B ab=a.new B();
    
    //创建静态内部类Inner的对象oi，不需要外部类Outer的对象
    Outer.Inner oi=new Outer.Inner();
    //Outer.Inner oi2=Outer.new Inner();//!!error
    //Outer.Inner oi3=new Outer().new Inner();//!!error
  }
}

 
5. 📒内部类中访问外部类的成员：
(1) 内部类中是可以直接访问外部类的其他属性与方法的，即使它们是private的。
(2) 如果内部类中有与外部类同名的属性与方法，可以使用下面的格式来表达外部类的引用，从而区分外部类和内部类的同名的属性与方法：
outerClass.this

 
 

2.2 方法和作用域中的内部类

内部类也可以是局部的，它可以定义在一个方法甚至一个代码块之内。
(1) 内部类中是可以直接访问外部类的其他属性与方法的，即使它们是private的。
(2) 如果内部类中有与外部类同名的属性与方法，可以使用下面的格式来表达外部类的引用，从而区分外部类和内部类的同名的属性与方法：
outerClass.this

例1: 方法中的内部类:
interface Destination {
  String readLabel();
}

public class Goods2 {
  String a="Goods2";
     public Destination dest(String s) {
          class GDestination implements Destination {
            private String label;
            private GDestination(String whereTo) {
             label = whereTo;
             System.out.println("access outer class:"+a);
               }
               public String readLabel() { return label; }
          }
          return new GDestination(s);
     }
public static void main(String[] args) {
          Goods2 g= new Goods2();
          Destination d = g.dest("Beijing");
          }
}
/*在方法dest（）中定义了一个内部类，最后由这个方法返回这个内部类的对象。如果在用一个内部类的时候仅需要创建它的一个对象并传给外部，就可以这样做。
*/

 
方法中定义内部类的注意点:
(1) 方法中定义的类，在其它地方使用时，没有类的名字，一般用其父类来引用这样的变量。
(2) 同局部变量一样，方法中的内部类前面不能用public，private，protected修饰，也不能用static修饰，但可以被final或abstract修饰。
(3) 方法中的内部类，可以访问其外部类的成员;若是static方法中的内部类，可以访问外部类的static成员。
(4) 方法中的内部类中，不能访问该方法的局部变量，除非是final的局部变量。

 

例2: 作用域中的内部类:
public class Goods3{
     private void internalTracking(boolean b) {
          if(b) {
               class TrackingSlip {
                    private String id;
                    TrackingSlip(String s) {
                         id = s;
                    }
                    String getSlip() { return id; }
               }
              TrackingSlip ts = new TrackingSlip("slip");
               String s = ts.getSlip();
          } 
     }
 public void track() { internalTracking(true); }
     public static void main(String[] args) {
          Goods3 g= new Goods3();
          g.track();
     }
}

 
 

2.3 匿名内部类

匿名类： 类或方法中定义的一种没有类名的特殊内部类。
作用：当需要创建一个类的对象而且用不上它的名字时，使用内部类可以使代码看上去简洁清楚。
语法规则如下：
new interfacename(){……};
或new superclassname(){……};

注意：
(1) 这种类不取名字，而直接用其父类的名字或者它所实现的接口的名字；
(2) 类的定义与创建该类的一个对象同时进行，即类的定义前面有一个new，没有类的首部，对象的创建和类体共同构成一个匿名类表达式，后面以“;”结束；
(3) 类中不能定义构造方法，因为它没有名字。

interface Contents{
  int value();
}
public class Goods4 {
     public Contents cont(){
          //返回匿名类对象，该匿名类继承了Contents接口
          return new Contents(){
               private int i = 11;
               public int value() { 
                    return i; 
               }
          };
     }
 public static void main(String[] args)
     {
      Goods4 g=new Goods4();
      Contents c=g.cont();
     }
}

---

---