每日一考

  1. 面向对象思想编程内容的三条主线分别是什么
    ① 类及类的成员：属性、方法、构造器；代码块、内部类；
    ② 面向对象的三大特征：封装、继承、多态
    ③ 其他关键字：this、super、abstract、interface、static、final、package、import
    面向对象的编程思想？
    （类、对象；面向对象的三大特征；）

  2. 谈谈你对面向对象中类和对象的理解，并指出二者关系
    类：抽象的、概念上的内容
    对象：实实在在存在的一个个体。
    对象是由类派生出来的。

  3. 面向对象思想的体现一：类和对象的创建和执行操作有哪三步？
    ①创建类
    ②new对象（类的实例化）
    ③调用类对象的结构：”对象.属性“ ”对象.方法“

  4. 画出如下代码在执行时的内存分配情况 ```java class Car{ String color = “red”; int num = 4; void show(){ int a = 10;

System.out.println(“color=”+color+”,num=”+num); } }

class CarTest { public static void main(String[] args) { Car c1 = new Car();
Car c2 = new Car(); c1.color = “blue”; c1.show(); c2.show(); } }

  2. <br />
  4. 5. 
  5. 类的方法内是否可以定义变量？是否可以调用属性？是否可以定义方法？是否可以调用方法？
  6. <br />是；是；否；是
  9. <a name="bfec0fd0"></a>
  10. ### 5.1对象数组的内存解析
  14. <a name="560ca558"></a>
  15. ### 5.2  匿名对象
  17. ```java
  18. package com.atguigu.java;
  19. /*
  20.  * 一、理解”万事万物皆对象“
  21.  * 1.在jav语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
  22.  *     >Scanner,String等
  23.  *     >文件：File
  24.  *     >网络资源：URL
  25.  * 2.涉及到Java语言与前端Html、后端数据库交互时，前后端的结构在Java层面交互时,都体现为类、对象
  26.  * 
  27.  * 二、内存解析的说明
  28.  * 1.引用类型的变量，只可能存储两类值：null 或 地址值(包含变量的类型)
  29.  * 
  30.  * 三、匿名对象的使用
  31.  * 1.理解：我们创建的对象，没有显示的赋给一个变量名，即为匿名对象
  32.  * 2.特征：匿名对象只能调用一次
  33.  * 3.使用
  34.  */
  35. public class InstanceTest {
  36.     public static void main(String[] args) {
  38.         Phone p = new Phone();
  39.         System.out.println(p);//地址值
  41.         p.sendEmail();
  42.         p.play();
  44.         //匿名对象
  45.         /*new Phone().sendEmail();
  46.         new Phone().play();*/
  48.         new Phone().price = 1999;
  49.         new Phone().showPrice();//0.0
  51.         //****************************
  52.         PhoneMall mall = new PhoneMall();
  53. //        mall.show(p);
  54.         //匿名对象的使用
  55.         mall.show(new Phone());//实参的值传递给形参
  57.     }    
  58. }
  60. class PhoneMall{
  62.     public void show(Phone phone){
  63.         phone.sendEmail();
  64.         phone.play();
  65.     }
  67. }
  69. class Phone{
  70.     double price;
  72.     public void sendEmail(){
  73.         System.out.println("发送邮件");
  74.     }
  76.     public void play(){
  77.         System.out.println("玩游戏");
  78.     }
  80.     public void showPrice(){
  81.         System.out.println("价格" + price);
  82.     }
  83. }

自定义工具类

  1. package com.atguigu.java;
  3. /*
  4.  * 自定义工具类
  5.  */
  6. public class ArrayUtil {    
  7.     //求数组的最大值
  8.     public int getMax(int[] arr){
  9.         int maxValue = arr[0];
  10.         for(int i = 1;i < arr.length;i++){
  11.             if(maxValue < arr[i]){
  12.                 maxValue = arr[i];
  13.             }
  14.         }
  15.         return maxValue;
  16.     }
  18.     //求数组的最小值
  19.     public int getMin(int[] arr){
  20.         int minValue = arr[0];
  21.         for(int i = 1;i < arr.length;i++){
  22.             if(minValue > arr[i]){
  23.                 minValue = arr[i];
  24.             }
  25.         }
  26.         return minValue;
  27.     }
  29.     //求数组的总和
  30.     public int getSum(int[] arr){
  31.         int sum = 0;
  32.         for(int i = 0;i <arr.length;i++){
  33.             sum += arr[i];
  34.         }
  35.         return sum;
  36.     }
  38.     //求数组的平均值
  39.     public int getAvg(int[] arr){
  40.         return getSum(arr) / arr.length;
  41.     }
  43.     //反转数组
  44.     public void reverse(int[] arr){
  45.         for(int i = 0;i < arr.length / 2;i++){
  46.             int temp = arr[i];
  47.             arr[i] = arr[arr.length - 1 -i];
  48.             arr[arr.length - 1 -i] = temp;
  49.         }
  50.     }
  52.     //复制数组
  53.     public int[] copy(int[] arr){
  54.         int[] arr1 = new int[arr.length];
  55.         for(int i =0;i < arr1.length;i++){
  56.             arr1[i] = arr[i];
  57.         }
  58.         return arr1;
  59.     }
  61.     //数组排序
  62.     public void sort(int[] arr){
  63.         //冒泡排序 
  64.         for(int i = 0;i < arr.length - 1;i++){
  65.                 for(int j = 0;j < arr.length - 1 - i;j++){
  66.                     if(arr[j] > arr[j+1] ){
  67.                         int temp = arr[j];
  68.                         arr[j] = arr[j+1];
  69.                         arr[j+1] = temp;
  70.                     }
  71.                 }
  72.         }
  73.     }
  75.     //遍历数组
  76.     public void print(int[] arr){
  77.         for(int i = 0;i <arr.length;i++){
  78.             System.out.print(arr[i] + "\t");
  79.         }
  80.     }
  82.     //查找指定元素
  83.     public int getIndex(int[] arr,int dest){
  85.         for(int i = 0;i < arr.length;i++){
  87.             if(dest == arr[i]){
  88.                 return i;
  89.             }
  90.         }
  91.         return -1;//返回负数，表示没找到
  92.     }        
  93. }
  1. package com.atguigu.java;
  3. public class ArrayUtilTest {
  4.     public static void main(String[] args){
  5.         ArrayUtil util = new ArrayUtil();
  6.         int[] arr = new int[]{32,34,32,5,65,-98,100};
  7.         int max = util.getMax(arr);
  8.         System.out.println(max);
  10.         util.sort(arr);
  12.         util.print(arr);
  14.         System.out.println("查找：");
  15.         int index = util.getIndex(arr, 5);
  16.         if(index >= 0){
  17.             System.out.println("找到了，索引地址为：" + index);
  18.         }else{
  19.             System.out.println("未找到");
  20.         }
  21.     }
  22. }

六、再谈方法

6.1 方法的重载

6.1.1 重载的概念:

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

“两同一不同”：

  • 同一个类、相同方法名

      1.            参数列表不同：参数个数不同，参数类型不同
  1. package com.atguigu.java1;
  3. /* 方法重载（overload）loading
  4.  * 1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
  5.  *         "两同一不同"：同一个类、相同方法名
  6.  *                     参数列表不同：参数个数不同，参数类型不同
  7.  * 2.举例.
  8.  *    Arrays类中重载的sort() / binarySearch()
  9.  *
  10.  * 3.判断是否重载
  11.  *    跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系
  12.  *
  13.  * 4.在通过对象调用方法时，如何确定某个指定的方法
  14.  *     方法名 ---> 参数列表
  15.  */
  17. public class OverLoadTest {
  19.     public static void main(String[] args) {
  20.         OverLoadTest test = new OverLoadTest();
  22.         //如果把1方法注释，依然不会报错，有自动类型提升int型赋给double型
  23.         test.getSum(1, 2);    
  24.     }
  26.     //如下的4个方法构成重载
  27.     //1.
  28.     /*public void getSum(int i,int j){
  29.         System.out.println("1");
  30.     }*/
  32.     //2.
  33.     public void getSum(double i,double j){
  34.         System.out.println("2");
  35.     }
  37.     //3.
  38.     public void getSum(String s,int i){
  39.         System.out.println("3");
  40.     }
  42.     //4.
  43.     public void getSum(int i,String s){
  44.         System.out.println("4");
  45.     }
  47.     /*public int getSum(int i,int j){//不算重载
  48.         return 0;
  49.     }*/
  51.     /*public void getSum(int m,int n){//不算重载
  53.     }*/
  55.     /*private void getSum(int i,int j){//不算重载
  57.     }*/    
  58. }

6.1.2 重载的特点：

与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。

6.1.3 重载示例：

//返回两个整数的和

int add(int x,int y){return x+y;}

//返回三个整数的和

int add(int x,int y,int z){return x+y+z;}

//返回两个小数的和

double add(double x,double y){return x+y;}

例如：

  1.  例如，System.out.println()方法就是典型的重载方法，其内部的声
  2. 明形式如下：
  3. public void println(byte x)
  4. public void println(short x)
  5. public void println(int x)
  6. public void println(long x)
  7. public void println(float x)
  8. public void println(double x)
  9. public void println(char x)
  10. public void println(double x)
  11. public void println()

6.1.4 练习

  1. 判 断：
  1. 1.判 断：
  2. 与void show(int a,char b,double c){}构成重载的有：
  3. a) void show(int x,char y,double z){} // no
  4. b) int show(int a,double c,char b){} // yes
  5. c) void show(int a,double c,char b){} // yes
  6. d) boolean show(int c,char b){} // yes
  7. e) void show(double c){} // yes
  8. f) double show(int x,char y,double z){} // no
  9. g) void shows(){double c} // no

  1. .编写程序，定义三个重载方法并调用。方法名为mOL。

    • 三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别 执行平方运算并输出结果，相乘并输出结果，输出字符串信息。

    • 在主类的main ()方法中分别用参数区别调用三个方法。

  2. 定义三个重载方法max()，第一个方法求两个int值中的最大值，第二个方
    法求两个double值中的最大值，第三个方法求三个double值中的最大值，
    并分别调用三个方法。 ```java package com.atguigu.exer;

/*

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

public class OverloadExer {

  1. //1.如下三个方法构成重载
  2. public void mOL(int i){
  3.     System.out.println(i * i);
  4. }
  5. public void mOL(int i,int j ){
  6.     System.out.println(i * j);
  7. }
  8. public void mOL(String s){
  9.     System.out.println(s);
  10. }
  12. //2.如下的三个方法构成重载
  13. public int max(int i,int j){
  14.     return (i >j)? i : j;
  15. }
  17. public double max(double d1,double d2){
  18.     return (d1 > d2)? d1 : d2;
  19. }
  21. public double max(double d1,double d2,double d3){
  22.     double max = (d1 > d2)? d1 : d2;
  23.     return (max > d3)? max : d3;
  24. }

}

  4. <a name="e36aea25"></a>
  5. ### 6.2 可变个数的形参
  7. JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。
  9. **说明：**
  11. 1. 声明格式：方法名(参数的类型名 ...参数名)
  12. 2. 可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个
  13. 3. 可变个数形参的方法与同名的方法之间，彼此构成重载
  14. 4. 可变参数方法的使用与方法参数部分使用数组是一致的
  15. 5. 方法的参数部分有可变形参，需要放在形参声明的最后
  16. 6. 在一个方法的形参位置，最多只能声明一个可变个数形参
  18. ```java
  19. package com.atguigu.java1;
  21. /*
  22.  * 可变个数形参的方法
  23.  * 
  24.  * 1.jdk 5.0新增的内容
  25.  * 2.具体使用
  26.  *     2.1 可变个数形参的格式，数据类型...变量名
  27.  *     2.2 当调用可变个数形参的方法时，传入的参数个数可以是，0个，1个，2个，多个
  28.  *     2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
  29.  *     2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载
  30.  *         换句话说：二者不能共存
  31.  *     2.5 可变个数形参在方法的形参中，必须声明在末尾（见方法5）
  32.  *     2.6 可变个数形参在方法的形参中，最多只能声明一个可变形参
  33.  */
  34. public class MethodArgsTest {
  36.     public static void main(String[] args) {
  38.         MethodArgsTest test = new MethodArgsTest();
  39.         test.show(12);
  40.         test.show("hello");//优先考虑方法2
  41.         test.show("hello","world");//方法3
  42.         test.show();//3.
  44.         test.show("AA","BB","CC");
  45.         //test.show(new String[]{"AA","BB","CC"});
  46.     }
  48.     //1.
  49.     public void show(int i){
  51.     }
  53.     //2.非常确定，优先考虑
  54.     /*public void show(String s){
  55.         System.out.println("show(String)");
  56.     }*/
  58.     //3.
  59.     public void show(String ... strs){//可变个数(和数组一样)
  60.         System.out.println("show(String...strs)");
  62.         for(int i = 0;i < strs.length;i++){
  63.             System.out.println(strs[i]);
  64.         }
  65.     }
  67.     //4.和方法3不能共存（编译器认为二者没区别）
  68.     /*public void show(String[] strs){
  70.     }*/
  72.     //5.报错（必须把可变个数形参声明在末尾，就像方法6一样）不能把可变的个数放在前面
  73.     //The variable argument type String of the method 
  74.     //show must be the last parameter
  75.     /*public void show(String ...strs,int i){
  77.     }*/
  79.     //6.
  80.     public void show(int i,String ...strs){
  82.     }
  83. }

6.3 方法参数的值传递机制[重点、难点]

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

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

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

    • 形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
    • 形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参
  1. package com.atguigu.java1;
  2. /*
  3. * 关于变量的赋值
  4. * 
  5. * 如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
  6. * 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
  7. */
  8. public class ValueTransferTest {
  10.    public static void main(String[] args) {
  12.        System.out.println("**********基本数据类型*********");
  13.        int m = 10;
  14.        int n = m;
  16.        System.out.println("m = " + m + " , n = " + n);
  18.        n = 20;
  20.        System.out.println("m = " + m + " , n = " + n);
  22.        System.out.println("**********引用数据类型*********");
  24.        Order o1 = new Order();
  25.        o1.orderId = 1001;
  27.        Order o2 = o1;//赋值以后：o1和o2的地址值相同，都指向堆空间同一个对象实体
  29.        System.out.println("o1.orderId = " + o1.orderId + 
  30.                ", o2.orderId" + o2.orderId);
  32.        o2.orderId = 1002;
  34.        System.out.println("o1.orderId = " + o1.orderId + 
  35.                ", o2.orderId" + o2.orderId);        
  36.    }
  37. }
  39. class Order{
  40.    int orderId;
  41. }

值传递：

  1. package com.atguigu.java1;
  3. /*
  4.  * 方法的形参的传递机制：值传递
  5.  * 
  6.  * 1.形参：方法定义时，声明的小括号内的参数
  7.  *        实参：方法调用时，实际传递给形参的数据
  8.  * 
  9.  * 2.值传递机制：
  10.  *     如果参数是基本数据类型，此时实参赋给形参的是，实参真实存储的数据值。
  11.  *     
  12.  * 
  13.  */
  14. public class ValueTransferTest1 {
  15.     public static void main(String[] args) {
  17.         //交换两个变量的值操作
  18.         int m = 10;
  19.         int n = 20;
  21.         System.out.println("m = " + m + ", n = " + n);
  22.         //交换两个变量的值操作
  23.         /*int temp = m;
  24.         m = n;
  25.         n = temp;*/
  27.         ValueTransferTest1 test = new ValueTransferTest1();
  28.         test.swap(m,n);//不是引用传递，所以不改变原有值
  30.         System.out.println("m = " + m + ", n = " + n);
  31.     }
  33.     public void swap(int m,int n){//形参
  34.         int temp = m;
  35.         m = n;
  36.         n = temp;
  38.     }
  39. }

引用传递：

  1. package com.atguigu.java1;
  3. /*
  4.  * 方法的形参的传递机制：值传递
  5.  * 
  6.  * 1.形参：方法定义时，声明的小括号内的参数
  7.  *        实参：方法调用时，实际传递给形参的数据
  8.  * 
  9.  * 2.值传递机制：
  10.  *     如果参数是基本数据类型，此时实参赋给形参的是，实参真实存储的数据值。（形参在栈中）
  11.  *     如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值
  12.  * 
  13.  */
  14. public class ValueTransferTest2 {
  16.     public static void main(String[] args) {
  17.         Data data = new Data();
  19.         data.m = 10;
  20.         data.n = 20;
  22.         System.out.println("m = " + data.m + ", n = " + data.n);
  24.         /*//交换m和n的值
  25.         int temp = data.m;
  26.         data.m = data.n;
  27.         data.n = temp;*/
  29.         //对象
  30.         ValueTransferTest2 V1 = new ValueTransferTest2();
  31.         V1.swap(data);
  33.         System.out.println("m = " + data.m + ", n = " + data.n);
  34.     }
  36.     public void swap(Data data){//传递过来的是地址值，指向之前开辟的空间
  37.         int temp = data.m;
  38.         data.m = data.n;
  39.         data.n = temp;
  40.     }
  41. }
  43. class Data{
  44.     int m;
  45.     int n;
  46. }

例题：

  1. public class TransferTest3 {
  2. public static void main(String args[]) {
  3. TransferTest3 test = new TransferTest3();
  4. test.first();
  5. }
  6. public void first() {
  7. int i = 5;
  8. Value v = new Value();
  9. v.i = 25;
  10. second(v, i);
  11. System.out.println(v.i);
  12. }
  13. public void second(Value v, int i) {
  14. i = 0;
  15. v.i = 20;
  16. Value val = new Value();
  17. v = val;
  18. System.out.println(v.i + " " + i);
  19. } }
  21. class Value {
  22. int i = 15;
  23. }

6.4 递归方法