学习Java之day09

1.面向对象的理解

一、理解"万事万物皆对象" 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);
  }
   
}

2.自定义数组的工具类

public class ArrayUtil {
   // 求数组的最大值
   public int getMaxValue(int[] data) {
       if (data == null) {
           return -1;
      }

       if (data.length - 1 == 0) {
           return data[0];
      }

       int maxValue = data[0];
       for (int i = 0; i < data.length; i++) {
           if (maxValue <= data[i]) {
               maxValue = data[i];
          }
      }
       return maxValue;

  }

   // 求数组的最小值
   public int getMinValue(int[] data) {
       if (data == null) {
           return -1;
      }
       if (data.length - 1 == 0) {
           return data[0];
      }
       int minValue = data[0];
       for (int i = 0; i < data.length; i++) {
           if (minValue >= data[i]) {
               minValue = data[i];
          }
      }

       return minValue;
  }

   // 求数组的总和
   public int getSum(int[] data) {
       int sum = 0;
       for (int i = 0; i < data.length; i++) {
           sum += data[i];
      }

       return sum;
  }

   // 求数组平均数
   public int getAvg(int[] data) {
       return this.getSum(data) / data.length;
  }

   // 反转数组
   public void reverse(int[] data) {
       for (int i = 0; i < data.length / 2; i++) {
           int temp = data[i];
           data[i] = data[data.length - i - 1];
           data[data.length - i - 1] = temp;
      }
  }

   // 与上面的方法构成重载
   public void reverse(String[] data) {
  }

   // 数组的复制
   public int[] getCopyArray(int[] data) {
       int[] arr = new int[data.length];
       for (int i = 0; i < data.length; i++) {
           arr[i] = data[i];
      }
       return arr;
  }

   // 数组的排序
   // 冒泡排序
   public int[] sort(int[] data) {
       for (int i = 0; i < data.length; i++) {
           for (int j = 0; j < data.length - i - 1; j++) {
               if (data[j] > data[j + 1]) {
//                     int temp = data[j];
//                     data[j] = data[j+1];
//                     data[j+1] = temp;
                   swap(data, j, j + 1);
              }
          }
      }
       return data;
  }

   // 数组中交换两个位置的数
   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] + " ");
      }
       System.out.println();
  }
   //查找数组的指定元素
   public int getIndex(int[] data, int dest) {
       for (int i = 0; i < data.length; i++) {
          if(dest  == data[i]) {
              return i;
          }
      }
       return -1;//如果没有找到,就返回一个负数
  }
}

3. 变量的赋值

如果变量是基本数据类型的,那么赋值的就是变量保存的数据值。 如果变量是引用数据类型的,那么赋值的就是变量所保存的数据的地址值。

方法的形参的传递机制:值传递 1.形参:方法定义时,声明的小括号内的参数。 实参:方法调用时,实际传递给形参的数据。

2.值传递机制: 如果参数是基本数据类型,此时实参赋给形参的数据就是数据值 如果参数是引用数据类型,此时实参赋给形参的数据就是实参存储数据的地址值。

public class ValueTransferTest {
   public static void main(String[] args) {
       System.out.println("*******************基本数据类型**********************");
       int n = 10;
       int m = n;
       System.out.println("n= "+ n + " m = " + m);
       n = 20;
       System.out.println("n= "+ n + " m = " + m);
       System.out.println("*******************引用数据类型**********************");
       Order o1 = new Order();
       o1.orderId = 1001;
       Order o2 = new 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 );
       
  }
}

4.方法的重载

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

"两同一不同":同一个类,相同方法名
                      参数列表不同:参数个数不同,参数数据类型不同

2.举例 Arrays类中重载的sort()、binarySeaerch() 3.判断是否重载? 跟方法的权限修饰符,返回值类型,形参变量名,方法体都没有关系

4.在调用方法时,如何确定某一个指定的方法 方法名------->参数列表

public class OverLoadTest {
   public static void main(String[] args) {
       OverLoadTest test = new OverLoadTest();
       test.getSum("", 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) {
//
//   }

}

5.可变个数形参的方法

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,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]);
      }
  }
}

6. 递归方法的使用(了解)

1.递归方法:一个方法体内调用它自身。

  1. 方法递归包含了一种隐式的循环,它会重复执行某段代码,但这种重复执行无须循环控制。 递归一定要向已知方向递归,否则这种递归就变成了无穷递归,类似于死循环。


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:快排
}



posted @ 2021-12-23 10:34  天覆者  阅读(90)  评论(0)    收藏  举报