Java-笔记9

package com.atguigu.java;
/*
 * 一、理解“万事万物皆对象”
 * 1.在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
 *         >Scanner,String等
 *         >文件：File
 *         >网络资源：URL
 * 2.涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。
 * 
 * 二、内存解析的说明
 * 1.引用类型的变量，只可能存储两类值：null  或  地址值（含变量的类型）
 * 
 * 三、匿名对象的使用
 * 1.理解：我们创建的对象，没有显式的赋给一个变量名。即为匿名对象
 * 2.特征：匿名对象只能调用一次。
 * 3.使用：如下
 * 
 */
public class InstanceTest {
    public static void main(String[] args) {
        Phone p = new Phone();
//        p = null;
        System.out.println(p);
        
        p.sendEmail();
        p.playGame();
        
        
        //匿名对象
//        new Phone().sendEmail();
//        new Phone().playGame();
        
        new Phone().price = 1999;
        new Phone().showPrice();//0.0
        
        //**********************************
        PhoneMall mall = new PhoneMall();
//        mall.show(p);
        //匿名对象的使用
        mall.show(new Phone());
        
    }
}

class PhoneMall{
    
    
    public void show(Phone phone){
        phone.sendEmail();
        phone.playGame();
    }
    
}


class Phone{
    double price;//价格
    
    public void sendEmail(){
        System.out.println("发送邮件");
    }
    
    public void playGame(){
        System.out.println("玩游戏");
    }
    
    public void showPrice(){
        System.out.println("手机价格为：" + price);
    }
    
}

 

package com.atguigu.java;

/*
 * 自定义数组的工具类
 * 
 */
public class ArrayUtil {

    // 求数组的最大值
    public int getMax(int[] arr) {
        int maxValue = arr[0];
        for (int i = 1; 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 = 1; 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 void reverse(String[] arr){
        
    }

    // 复制数组
    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 - 1; 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;
                    //错误的：
//                    swap(arr[j],arr[j + 1]);
                    //正确的：
                    swap(arr,j,j + 1);
                }

            }

        }
    }
    
    //错误的：交换数组中指定两个位置元素的值
//    public void swap(int i,int j){
//        int temp = i;
//        i = j;
//        j = temp;
//    }
    //正确的：交换数组中指定两个位置元素的值
    public void swap(int[] arr,int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = 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;//返回一个负数，表示没有找到
    }

}

package com.atguigu.java;

public class ArrayUtilTest {
    public static void main(String[] args) {
        
        ArrayUtil util = new ArrayUtil();
        int[] arr = new int[]{32,34,32,5,3,54,654,-98,0,-53,5};
        int max = util.getMax(arr);
        System.out.println("最大值为：" + max);
        
        System.out.println("排序前：");
        util.print(arr);
        
        
        
        util.sort(arr);
        System.out.println("排序后：");
        util.print(arr);
        
//        System.out.println("查找：");
//        int index = util.getIndex(arr, -5);
//        if(index >= 0){
//            System.out.println("找到了，索引地址为：" + index);
//        }else{
//            System.out.println("未找到");
//        }
        
        
//        util.reverse(arr);
    }
}

 

 

package com.atguigu.java1;
/*
 * 方法的重载（overload）  loading...
 * 
 * 1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
 *     
 *  "两同一不同":同一个类、相同方法名
 *            参数列表不同：参数个数不同，参数类型不同
 * 
 * 2. 举例：
 *    Arrays类中重载的sort() / binarySearch()
 * 
 * 3.判断是否是重载：
 *    跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！
 *    
 * 4. 在通过对象调用方法时，如何确定某一个指定的方法：
 *      方法名 ---> 参数列表
 */
public class OverLoadTest {
    public static void main(String[] args) {
        
        OverLoadTest test = new OverLoadTest();
        test.getSum(1,2);
        
        
    }
    
    //如下的4个方法构成了重载
    public void getSum(int i,int j){
        System.out.println("1");
    }
    
    public void getSum(double d1,double d2){
        System.out.println("2");
    }
    
    public void getSum(String s ,int i){
        System.out.println("3");
    }
    
    public void getSum(int i,String s){
        System.out.println("4");
    }
    
    //如下的3个方法不能与上述4个方法构成重载
//    public int getSum(int i,int j){
//        return 0;
//    }
    
//    public void getSum(int m,int n){
//        
//    }
    
//    private void getSum(int i,int j){
//        
//    }
    
    
}

 

package com.atguigu.exer;
/*
 * 1.编写程序，定义三个重载方法并调用。方法名为mOL。
    三个方法分别接收一个int参数、两个int参数、一个字符串参数。
    分别执行平方运算并输出结果，相乘并输出结果，输出字符串信息。
    在主类的main ()方法中分别用参数区别调用三个方法。
    
    2.定义三个重载方法max()，
    第一个方法求两个int值中的最大值，
    第二个方法求两个double值中的最大值，
    第三个方法求三个double值中的最大值，
    并分别调用三个方法。

 * 
 * 
 */
public class OverloadExer {
    
    //1. 如下的三个方法构成重载
    public void mOL(int i){
        System.out.println(i * i);
        
    }
    public void mOL(int i,int j){
        System.out.println(i * j);
    }
    
    public void mOL(String s){
        System.out.println(s);
    }
    
    //2.如下的三个方法构成重载
    public int max(int i,int j){
        return (i > j)? i : j;
    }
    public double max(double d1,double d2){
        return (d1 > d2)? d1 : d2;
    }
    public double max(double d1,double d2,double d3){
        double max = (d1 > d2)? d1 : d2;
        return (max > d3)? max : d3;
    }
}

 

package com.atguigu.java1;
/*
 * 可变个数形参的方法
 * 
 * 1.jdk 5.0新增的内容
 * 2.具体使用：
 *   2.1 可变个数形参的格式：数据类型 ... 变量名
 *   2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
 *   2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
 *   2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
 *   2.5 可变个数形参在方法的形参中，必须声明在末尾
 *      2.6  可变个数形参在方法的形参中,最多只能声明一个可变形参。
 * 
 */
public class MethodArgsTest {
    
    public static void main(String[] args) {
        
        MethodArgsTest test = new MethodArgsTest();
        test.show(12);
//        test.show("hello");
//        test.show("hello","world");
//        test.show();
        
        test.show(new String[]{"AA","BB","CC"});
        
    }
    
    
    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)");
        
        for(int i = 0;i < strs.length;i++){
            System.out.println(strs[i]);
        }
    }
    //不能与上一个方法同时存在
//    public void show(String[] strs){
//        
//    }
    
    //The variable argument type String of the method 
    //show must be the last parameter
//    public void show(String ...strs,int i){
//        
//    }
    
}

 

 

package com.atguigu.java1;
/*
 * 
 * 关于变量的赋值：
 * 
 *  如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
 *  如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
 * 
 */
public class ValueTransferTest {
    
    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);
        
        o2.orderId = 1002;
        
        System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
        
    }
    
}

class Order{
    
    int orderId;
    
}

 

 

package com.atguigu.java1;
/*
 * 方法的形参的传递机制：值传递
 * 
 * 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;
    }
}

 

 

package com.atguigu.java1;

public class ValueTransferTest2 {
    
    public static void main(String[] args) {
        
        Data data = new Data();
        
        data.m = 10;
        data.n = 20;
        
        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;
    
}

 

package com.atguigu.java1;

public class ArrayPrintTest {
    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3};
        System.out.println(arr);//地址值

        char[] arr1 = new char[]{'a','b','c'};
        System.out.println(arr1); //abc

    }
}

 

 

package com.atguigu.exer1;
/*
 * 考查参数的值传递
 * 
 * 定义一个类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");
        int i = 1;
        for(;i <= time;i++){
            //设置圆的半径
            c.radius = i;
            double area = c.findArea();
            System.out.println(c.radius + "\t\t" + area);
        }
        
        //
//        c.radius = time + 1;
        c.radius = i;
        
    }
}

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

 

 

 

 

package com.atguigu.java2;

/*
 * 递归方法的使用
 * 1.递归方法：一个方法体内调用它自身。
 * 2. 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
 * 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

 * 
 * 
 * 
 * 
 */
public class RecursionTest {

    public static void main(String[] args) {

        // 例1：计算1-100之间所有自然数的和
        // 方式一：
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        System.out.println(sum);
        // 方式二：
        RecursionTest test = new RecursionTest();
        int sum1 = test.getSum(100);
        System.out.println(sum1);
        
        System.out.println("*****************");
        int value = test.f(10);
        System.out.println(value);

    }

    // 例1：计算1-n之间所有自然数的和
    public int getSum(int n) {// 3

        if (n == 1) {
            return 1;
        } else {
            return n + getSum(n - 1);
        }

    }

    // 例2：计算1-n之间所有自然数的乘积: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*f(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 f(n + 2) - 2 * f(n + 1);
            return 2*f(n - 1) + f(n - 2);
        }
    }

    //例4：斐波那契数列
    
    //例5：汉诺塔问题
    
    //例6：快排

}