Java学习第十八天

面向对象的思想概念

类（class）和对象（Object）是面向对象的核心概念

>类是对一类事物的描述，是抽象的、概念上的定义

>对象是实际存在的该类事物的每个个体，因而也被称为实例（instance）

"万事万物皆对象"

/*
 *  自定义数组的工具类
 * 
 * 
 */
public class ArrayUtil {
        
    //求数组的最大值
    public int getMax(int[] arr){
        int maxValue = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if(maxValue < arr[i]) {
                maxValue = arr[i];
            }
                
            
        }
        return maxValue;
    }
    //求数组的最小值
    
    public int getMin(int[] arr) {
        int minValue = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if(minValue > arr[i]);{
                
            minValue = arr[i];
            }
        }
        return minValue;
    }
    //求数组的总和
    
    public int getSum(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];    
            
        }
        return sum;
    }
    //求数组的平均值
    
    public int getAvg(int[] arr) {
        
        return getSum(arr) / arr.length;
    }
    //反转数组
    
    public void reverse(int[] arr) {
        for (int i = 0; i < arr.length / 2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length - i - 1];
            arr[arr.length - i -1] = temp;
            
        }
    }
    //复制数组
    
    public int[] copy(int[] arr) {
        int[] arr1 = new int[arr.length];
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = arr[i];
            
        }
        return arr1;
    }
    //数组排序
    
    public void sort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if(arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
                
            }
            
        }
    }
    //遍历数组
    
    public void print(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
            
        }
        System.out.println();
    }
    //查找指定元素
    public int getIndex(int[] arr,int dest) {
        
        for (int i = 0; i < arr.length; i++) {
            if(dest == arr[i]) {
                return i;
            }
            
        }
        return -1;//返回一个负数，表示没有找到
    }
}

方法的重载：

定义：在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或 参数类型不同即可

举例：

public void getSum(int i,int j) {
        System.out.println(i + j);
    }
    public void getSum(double d1,double d2) {
        
    }
    public void getSum(String s,int i) {
        
    }
    public void getSum(int i,String s) {
        
    }

可变形参的方法：

1.jdk5.0新增的内容
 * 2.具体使用：
 *     2.1 可变个数形参的格式：数据类型...变量名
 *     2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，一个，两个。。。
 *     2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
 *     2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组
 *         之间不构成重载。换句话说，二者不能共存。
 *     2.5 可变个数形参在方法形参中，必须声明在末尾                                                                             2.6 可变个数形参在方法形参中，最多只能声明一个可变形参。

public static void main(String[] args) {
        
        MethodArgsTest test = new MethodArgsTest();
        test.show(12);
        test.show("hello");
        test.show("hello","world");
        test.show();
    }
    
    public void show(int i) {
        
    }
//    public void show(String s) {
//        System.out.println("show String");
//    }
    public void show(String... strs) {
        System.out.println("show(String...strs)");
    }

方法参数的值传递机制：

方法必须由其所在类或对象调用才有意义。若方法含有参数：

形参：方法声明时的参数

实参：方法调用时实际传给形参的参数值

Java里方法的参数传递方式只有一种：值传递。即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参

形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参

public static void main(String[] args) {
        
        System.out.println("************基本数据类型*************");
        int m = 10;
        int n = m;
                
        System.out.println("m = " + m + "，n =" + n);
        
        n = 20;
        System.out.println("m = " + m + "，n =" + n);
        
        System.out.println("************引用数据类型**************");
        
        Order o1 = new Order();
        o1.orderId = 1001;
        
        Order o2 = o1;/*赋值以后，o1和o2的地址值相同，
                            都指向了堆空间中同一个对象实体*/        
        System.out.println("o1.orderId = " + o1.orderId + 
                ",o2.orderId =" + o2.orderId);//1001,1001
        
        o2.orderId = 1002;
        
        System.out.println("o1.orderId = " + o1.orderId + 
                ",o2.orderId =" + o2.orderId);//1002,1002
        
    }
}
class Order{
    int orderId;
}

/*
 * 方法形参的传递机制：值传递
 * 
 * 1.形参：方法定义时，声明的小括号内的参数
 *       实参：方法调用时，实际传递给形参的数据
 * 
 * 2.值传递机制：
 * 如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
 * 如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。
 * 
 * 
 */
public class ValueTransferTest1 {

    public static void main(String[] args) {
        
        int m = 10;
        int n = 20;
        
        System.out.println("m = " + m + "," + "n = " + n);
        //交换两个变量的值的操作
//        int temp = m;
//        m = n;
//        n = temp;
        
        ValueTransferTest1 test = new ValueTransferTest1();
        test.swap(m, n);
        
        
        System.out.println("m = " + m + "," + "n = " + n);
    }
    public void swap(int m,int n) {
            int temp = m;
            m = n;
            n = temp;
}
}

public static void main(String[] args) {
        
        Data data = new Data();
        
        data.m = 20;
        data.n = 10;
        
        System.out.println("m = " + data.m + ",n = " + data.n);
        
        //交换m和n的值
//        int temp = data.m;
//        data.m = data.n;
//        data.n = temp;
        ValueTransferTest2 test = new ValueTransferTest2();
        test.swap(data);
        
        System.out.println("m = " + data.m + ",n = " + data.n);
    }
    public void swap(Data data) {
        int temp = data.m;
        data.m = data.n;
        data.n = temp;
    }
}
class Data{
    int m;
    int n;

/*
 * 定义一个Circle类，包含一个double型的radius属性代表圆的半径
 * 一个findArea（）方法返回圆的面积
 * 
 * 
 * 
 */
public class Circle {
    double radius;//半径
    
    //求圆的面积
    public double findArea() {
        return Math.PI * radius * radius;
    }
}

/*
 * 考查参数的值传递
 * 
 * 定义一个类PassObject，在类中定义一个方法printAreas（），该方法的定义
 * 如下：public void printAreas(Circle c,int time)
 * 在printAreas方法中打印输出1到time之间的每个整数半径值，以及对应的面积。
 * 例如time为5，则输出半径1，2，3，4，5以及对应的圆面积
 * 
 * 在main方法中调用printAreas（）方法，调用完毕后输出当前半径值。
 */
public class PassObject {
    public static void main(String[] args) {
        PassObject test = new PassObject();
        
        Circle c = new Circle();
        
        test.printAreas(c, 5);
        
        System.out.println("now radius is " + c.radius);
    }
    
    public void printAreas(Circle c,int time) {
        
        System.out.println("Radius\t\tArea");
        
        
        for (int i = 0; i <= time; i++) {
            //设置圆的半径
            c.radius = i;
            double area = c.findArea();
            System.out.println(c.radius + "\t\t" + area);
            
        }
        
        c.radius = time + 1;
    }
}

递归方法（recursion）：

一个方法体内调用它自身

方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制

递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环

/*
 * 递归方法的使用（了解）
 * 
 * 
 * 
 */

import javax.swing.text.StyledEditorKit.ForegroundAction;

public class RecursionTest {

    public static void main(String[] args) {
        
    
    
    //例1：计算1-n之间所有自然数的和
        //方式1：
    int sum = 0;
    for(int i = 1;i <= 100;i++) {
        sum += i;
        
    }    
    System.out.println(sum);
        //方式2：
        RecursionTest test = new RecursionTest();
        int sum1 = test.getSum(100);
        System.out.println(sum1);
    }
    
    public int getSum(int n) {
        if(n == 1) {
            return 1;
            
        }else {
            return n + getSum(n - 1);
        }
            
    }
    //例2：计算1-n之间所有自然数的乘积
    public int getSum1(int n) {
        if(n == 1) {
            return 1;
            
        }else {
            return n * getSum1(n - 1);
        }
            
    }
    //例3：已知有一个数列：f（0） = 1，f（1） = 4，f（n + 2） = 
    //                                    2 * （n + 1）+ f（n）
    //其中n是大于0的整数，求f（10）的值
    public int f(int n) {
        if(n == 0) {
            return 1;
        }else if(n == 1){
            return 4;
        }else {
            return 2*f(n - 1) + f(n - 2);
        }
    }
    
    //例4：
    
    
    
}