day7 面向对象（二）

2018-06-18 02:24:25来源：未知阅读 ()

　　匿名类对象

　　创建的类的对象是匿名的。当我们只需要一次调用类的对象时，我们就可以考虑使用匿名的方式创建类的对象。特点是创建的匿名类的对象只能够调用一次！

package day007;

//圆的面积
class circle {
    double radius;
    public double getArea() {
        // TODO Auto-generated method stub
        return Math.PI * radius * radius;
    }
    
    public void setRadius(double r){
        radius = r;
    }
    
    public double getRadius(){
        return radius;
    }
    
    public void show(){
        System.out.println("我是一个圆");
    }
    
}


public class lambda{
    public void printArea(circle c, int time){
        System.out.println("radius"+"\t"+"area");
        for(int i =1;i<= time;i++){
            c.setRadius(i);
            System.out.println(c.getRadius() + "\t" + c.getArea());
        }
    }
    
    public static void main(String[] args){
        lambda p = new lambda();
        circle c = new circle();//新的圆半径为0
        p.printArea(c, 5);
        
        new circle().show();//这个对象就是匿名对象，只使用一次后就无法再次调用
    }
}

对象作为参数传递

　　在上面这个例子里，我们使用new circle()直接调用circle的方法。这个对象就是匿名类对象，这个对象产生时，在内存堆中开辟内存存储了数据，但是在栈中并没有相应的变量名指向这块内存地址，那么我们无法再第二次调用这个匿名类，即我们不可以使用此类再次调用circle类的属性与方法。

　　在java虚拟机中，这个匿名类对象很快就被垃圾回收机制收走了，切记，当我们某个类对象只需要使用一次的情况，我们才会考虑使用匿名类对象。

　　可变个数的行参的方法：

　　格式：对于方法的形参：数据类型 ... 形参名;

　　可变个数的形参的方法与同名的方法之间构成重载;

　　可变个数的形参在调用时，个数从0开始，到无穷多个都可以。

　　使用可变多个形参的方法与方法的形参使用数组是一致的。

　　若方法中存在可变个数的形参，那么一定要声明在方法形参的最后。

　　在一个方法中，最多声明一个可变个数的形参。

package day007;

public class javaArgs {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        javaArgs jargs = new javaArgs();
        jargs.getSum(1,2,3,4);
        new javaArgs().getSum(123,223);
        jargs.getSum("求和是", 2,3,5,8);
    }
//    public int getSum(int ... args){
    public void getSum(int ... args){
        int sum = 0;
        //args使用与数组一致
        for(int i = 0; i<args.length;i++){
            sum += args[i];
        }
        System.out.println(sum);
//        return sum;
        
    }
    //重载，可变个数的形参声明在方法形参的最后
    public void getSum(String s,int ... args){
        int sum = 0;
        for(int i = 0; i<args.length;i++){
            sum += args[i];
        }
        System.out.println(s + ":"+ sum);
        
    }
}

java的*args的使用

　　java中形参与实参

　　形参：方法声明时，方法小括号内的参数，实参：调用方法时，实际传入的参数的值。

　　我们之前做的两个值转换：

package day007;

public class TestArgsTransfer {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //两个值转换
        int i = 10;
        int j = 5;
        System.out.println("i:" + i + " j:" + j);
        int temp = i;
        i = j;
        j = temp;
        System.out.println("i:" + i + " j:" + j);
        
        
    }

}

两个值交换

　　然后你可能会想用一个类封装一个方法完成交换。然后你写了这样一个方法。

package day007;

public class TestArgsTransfer {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //两个值转换
        int i = 10;
        int j = 5;
        
        //封装到类方法
        TestArgsTransfer tt = new TestArgsTransfer();
        System.out.println("i:" + i + " j:" + j);
        tt.swap(i, j);//将i的值传递给m，j的值传递给n
        System.out.println("i:" + i + " j:" + j);
    }
    
    //定义一个方法，交换两个变量的值
    public void swap(int m,int n){
        int temp = m;
        m = n;
        n = temp;
        System.out.println("m:" + m + " n:" + n);
    }

}

你写的封装方法

　　结果是你的i和j根本就没有变，为什么呢？

　　简单来说就是i与j是你定义的类属性，你将i，j作为实参传到了类方法里面，类方法swap里的两个变量发生了位置转换，但是main中的两个值并没有发生任何变化，在内存中的表现如上图，调用swap方法时，会在栈中存两个swap的局部变量，这两个变量的值交换了，但是main的变量未发生改变。

　　那我们要如何做呢。

package day007;

public class TestArgsTransfer1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        TestArgsTransfer1 tt = new TestArgsTransfer1();
        DataSwap ds = new DataSwap();
        
        System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);
        
        tt.swap(ds);
        System.out.println(ds);
        
        System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);
    }
    
    //交换元素的值
    public void swap(DataSwap d){
        int temp = d.i;
        d.i = d.j;
        d.j = temp;
        System.out.println(d);//打印引用变量d的值
    }
}

class DataSwap{
    int i = 10;
    int j = 5;
}

形参是引用数据类型

　　这里swap方法传入的是一个引用数据类型ds，相当于d与ds一致都指向同一个堆空间，那么在swap中完成两个值的交换。

　　练习一下，下面代码的执行结果是什么：

class Value {
    int i = 15;
}

class TestValue {
    public static void main(String argv[]) {
        TestValue t = new TestValue();
        t.first();
    }

    public void first() {
        int i = 5;
        Value v = new Value();
        v.i = 25;
        second(v, i);
        System.out.println(v.i);
    }

    public void second(Value v, int i) {
        i = 0;
        v.i = 20;
        Value val = new Value();
        v = val;
        System.out.println(v.i + " " + i);
    }
}

　　分析：

　　第一步，定义了TestValue类，在类的main函数中，生成一个实例t，并在堆中开辟内存（0x0001），在栈中定义t指向堆中内存0x0001。实例调用实例的first方法。

　　第二步，在栈中有局部变量i值为5,一个新的变量v，指向堆中新开辟内存（0x0011），v的局部变量i值为25,将v与当前局部变量i=5作为实参传给second方法。

　　第三步，局部变量i的值改为0,v的局部变量i变为20,定义一个新变量val指向堆中先开辟内存（0x0111），second中实参v指向内存（0x0111）

　　第四步，此时打印v.i值为内存0x0111中的i，值为15,i为局部空间中的变量i为0,first打印的v.i值为20（实参传入first，v本身未发生指向的改变）。

　　面向对象：封装

　　我们考虑不让对象来直接作用属性，而是通过"对象.方法"的形式，来控制对象对属性的访问。实际情况中，对属性的要求就可以通过方法来体现。

　　两种方法：①将类的属性私有化，②提供公共的方法（setter & getter）来实现调用。

package day007;

public class java_private {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Animal an = new Animal();
//        an.legs = 4;//飘红
        an.setLegs(4);
        an.getLegs();
    }

}

class Animal{
    private String name;
    private int legs;
    
    public void setLegs(int l){
        legs = l;
    }
    
    public int getLegs(){
        System.out.println(legs);
        return legs;
    }
}

私有封装

　　权限修饰符

　　构造器

　　也就是构造方法，但是与python的__init__有相似之处，但是不完全一致。

　　构造器的作用：①创建对象 ②给创建的对象的属性赋值（创建对象的话，相当于python中的__new__与__init__的作用）。

　　1.设计类时，若不显式声明类的构造器的话，程序会默认提供一个空参的构造器

　　默认加()就相当于调用了构造器了，类比python加()后实例化即调用了构造方法。

　　2.一旦显式的定义类的构造器，那么默认的构造器就不再提供。

　　3.如何声明类的构造器。格式：权限修饰符类名(形参){ }。

　　 4.类的多个构造器之间构成重载。

　　类对象的属性赋值的先后顺序：①属性的默认初始化 ②属性的显式初始化③通过构造器给属性初始化 ④通过"对象.方法"的方式给属性赋值。

package day007;

public class init {
    public static void main(String[] args) {
        Person p1 = new Person();
        System.out.println(p1.getName() + ":" + p1.getAge());
        String str = new String("hello");
        System.out.println(str);
        
        Person p2 = new Person("jeff");
        System.out.println(p2.getName());
        System.out.println(p2.getAge());
        
        Person p3 = new Person("frank",23);
        System.out.println("name:" + p3.getName() + " age:" + p3.getAge());
        //体会属性赋值的过程
        Person p4 = new Person();
        System.out.println("name:" + p4.getName() + " age:" + p4.getAge());
        
        Person p5 = new Person(12);
        System.out.println("name:" + p5.getName() + " age:" + p5.getAge());
    }
}


class Person{
    //属性
    private String name;
    private int age = 1;
    
    //构造器
    public Person(String n){
        name = n;
    }
    public Person(){
//        age = 10;
//        name = "张三";
    }
    public Person(int a){
        age = a;
    }
    public Person(String n,int a){
        name = n;
        age = a;
    }
    
    //方法
    public void setName(String n){
        name = n;
    }
    public void setAge(int a){
        age = a;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
}