Java基础（必知必会）二

（九）Java中的方法

1. 方法：所谓方法就是函数、过程，是语句的集合，它们在一起执行一个功能。
   1. 封装一段特定的业务逻辑功能
   2. 尽可能独立，一个方法只干一件事
   3. 方法可以被反复调用多次
   4. 可以减少代码重复，有利于代码维护
   5. 何时用：假设有一个功能，在很多地方都得使用，就将功能封装到一个方法
2. 方法的定义：五要素
   • 修饰词  返回值类型  方法名(参数列表){

   • 方法体---具体的业务逻辑功能实现

      }

     //无参无返回值
     public static void say(){
         System.out.println("大家好，我叫zhangsan，今年38岁了");
     }
     
     //有参无返回值
     public static void sayHi(String name){ //形参
         System.out.println("大家好，我叫"+name+"，今年38岁了");
     }
     
     //有参无返回值
     public static void sayHello(String name,int age){ //形参
         System.out.println("大家好，我叫"+name+"，今年"+age+"岁了");
     }
     
     //无参有返回值
     public static double getNum(){
         //若方法有返回值，则在方法中必须出现return关键字
         //并且return后的数的类型必须与返回值类型匹配
         //return "abc"; //编译错误
         return 8.88; //1)结束方法的执行  2)返回结果给调用方
     }
     
     //有参有返回值
     public static int plus(int num1,int num2){
         int num = num1+num2;
         return num; //返回的是num里面的那个数
         //return num1+num2; //返回的是num1与num2的和
     }
     
     //无参有返回值
     public static int[] testArray(){
         int[] arr = new int[10];
         for(int i=0;i<arr.length;i++){
             arr[i] = (int)(Math.random()*100);
         }
         return arr;
     }

3. 方法的调用：

   • 无返回值：方法名(有参传参)

     public class MethodDemo {
         public static void main(String[] args) {
             say(); //调用say()方法
     
             //sayHi(); //编译错误，有参则必须传参
             //sayHi(250); //编译错误，参数类型必须匹配
             sayHi("zhangsan"); //String name="zhangsan"  //实参
             sayHi("lisi"); //String name="lisi"          //实参
             sayHi("wangwu"); //String name="wangwu"      //实参
     
             sayHello("zhangsan",25); //实参 String name="zhangsan",int age=25
             sayHello("lisi",24); //实参
         }
     }

   • 有返回值：数据类型 变量 = 方法名(有参传参);

     //方法的演示
     public class MethodDemo {
         public static void main(String[] args) {
             double a = getNum(); //getNum()的值就是return后的那个数
             System.out.println(a); //8.88，模拟对返回值的后续操作
     
             int b = plus(5,6); //plus(5,6)的值就是return后的那个数
             System.out.println(b); //11，模拟对返回值的后续操作
     
             int m=5,n=6;
             int c = plus(m,n); //传递的是m和n里面的数
             System.out.println(c); //11，模拟对返回值的后续操作
     
             int[] d = testArray();
             System.out.println("长度为:"+d.length); //10，模拟对返回值的后续操作
             for(int i=0;i<d.length;i++){ //模拟对返回值的后续操作
                 System.out.println(d[i]);
             }
         }
     }

4. return

   • return 值; //1) 结束方法的执行 2) 返回结果给调用方-------用在有返回值的方法中

   • return; //1) 结束方法的执行--------------用在无返回值的方法

 (十）Java中的类和对象

1. 什么是类？什么是对象?

   1. 现实生活是由很多很多对象组成的，基于对象抽出了类

   2. 对象：软件中真实存在的单个个体/东西

      类：类型/类别，代表一类个体

   3. 类是对象的模板，对象是类的具体的实例

   4. 类中可以包含：

      1. 对象的属性/特征-----------------------------成员变量

      2. 对象的行为/动作/功能---------------------方法

   5. 一个类可以创建多个对象

2. 如何创建类？如何创建对象？如何访问成员？

   //创建类:
   public class Student {
       //成员变量
       String name;
       int age;
       String address;
       //方法
       void study(){
           System.out.println(name+"在学习...");
       }
       void sayHi(){
           System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);
       }
   }
   
   //创建对象:
   public class StudentTest {
       public static void main(String[] args) {
           //创建一个学生对象
           Student zs = new Student();
           //访问成员变量
           zs.name = "zhangsan";
           zs.age = 25;
           zs.address = "河北廊坊";
           //调用方法
           zs.study();
           zs.sayHi();
   
           Student ls = new Student();
           ls.name = "lisi";
           ls.age = 27;
           ls.address = "黑龙江佳木斯";
           ls.study();
           ls.sayHi();
   
           //1)创建了一个学生对象
           //2)给所有成员变量赋默认值
           Student ww = new Student();
           ww.study();
           ww.sayHi();
       }
   }

3. 方法的签名：方法名+参数列表

4. 方法的重载(overload/overloading)：-------------------更方便方法的调用

   1. 发生在同一类中，方法名相同，参数列表不同

   2.  编译器在编译时会根据方法的签名自动绑定方法

//演示方法的重载
class Aoo{
    void show(){}
    void show(String name){}
    void show(int age){}
    void show(String name,int age){}
    void show(int age,String name){}
    //int show(){ return 1; } //编译错误，重载与返回值类型无关
    //void show(String address){} //编译错误，重载与参数名称无关
}

//演示重载方法的调用
public class OverloadDemo {
    public static void main(String[] args) {
        Aoo o = new Aoo();
        o.show();
        o.show("zhangsan");
        o.show(25);
        o.show("zhangsan",25);
        o.show(25,"zhangsan");
    }
}

（十一）构造方法

1. 构造方法：构造函数、构造器、构建器----------------复用给成员变量初始化代码
   1. 作用：给成员变量赋初始值
   2. 与类同名，没有返回值类型(连void都没有)
   3. 在创建(new)对象时被自动调用
   4. 若自己不写构造方法，则编译器默认提供一个无参构造方法
   5. 若自己写了构造方法，则不再默认提供
   6. 构造方法可以重载
2. this：指代当前对象，哪个对象调用方法它指的就是哪个对象，只能用在方法中，方法中访问成员变量之前默认有个this
   1. this的用法：
      1. this.成员变量名------访问成员变量
         1. 当成员变量和局部变量同名时，若想访问成员变量则this不能省略，其它一般省略
      2. this.方法名()------调用方法(一般不用，了解)
      3. this()------调用构造方法(一般不用，了解)
3. 构造方法和this的演示

   class Student {
       //成员变量
       String name;
       int age;
       String address;
       //构造方法
       Student(String name,int age,String address){
           this.name = name;       //zs.name="zhangsan"
           this.age = age;         //zs.age=25
           this.address = address; //zs.address="LF"
       }
   
       //方法
       void study(){
           System.out.println(name+"在学习...");
       }
       void sayHi(){
           System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);
       }
   }
   
   //构造方法和this的演示
   public class ConsDemo {
       public static void main(String[] args) {
           //Student zs = new Student(); //编译错误，Student类没有无参构造
           Student zs = new Student("zhangsan",25,"LF");
           Student ls = new Student("lisi",26,"JMS");
           zs.sayHi();
           ls.sayHi();
       }
   }

4. null：表示空，没有指向任何对象。若引用的值为null，则该引用不能再进行任何点操作了，若操作则发生NullPointerException空指针异常。

（十二）Java中的继承

继承的概念：继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

1. 继承：
   1. 作用：代码复用，通过extends来实现继承
   2. 超类/父类：共有的属性和行为
   3. 派生类/子类：特有的属性和行为
   4. 派生类可以访问：派生类的+超类的，而超类不能访问派生类的
   5. 一个超类可以有多个派生类，但一个派生类只能继承一个超类------即单一继承
   6. 继承具有传递性
   7. Java规定：构造派生类之前必须先构造超类
      1. 在派生类构造方法中若没有调用超类构造方法，则默认super()调超类无参构造方法
      2. 在派生类构造方法中若自己调用了超类构造方法，则不再默认提供
         1. 注意：super()调用超类构造方法，必须位于派生类构造方法的第一行
2. super：指代当前对象的超类对象

   super的用法：

           super.成员变量名------------------------访问超类的成员变量(一般不用，了解)

           super.方法名()----------------------------调用超类的方法

           super()--------------------------------------调用超类的构造方法

   public class SuperDemo {
       public static void main(String[] args) {
           Boo o = new Boo();
       }
   }
   
   class Aoo{
       Aoo(){
           System.out.println("超类构造...");
       }
   }
   class Boo extends Aoo{
       Boo(){
           //super(); //默认的，写不写都在
           System.out.println("派生类构造...");
       }
   }
   
   class Coo{
       Coo(int a){
       }
   }
   class Doo extends Coo{
       Doo(){
           super(5); //调用超类的有参构造
       }
       /*
       //如下代码为默认的
       Doo(){
           super(); //超类若没有无参构造，则编译错误
       }
        */
   }

 （十三）向上造型和重写

1. 向上造型：
   1. 超类型的引用指向派生类的对象
   2. 能点出来什么，看引用的类型

      public class UploadDemo {
          public static void main(String[] args) {
              Aoo o1 = new Aoo();
              o1.a = 1;
              o1.show();
              //o1.b = 2;  //编译错误，超类不能访问派生类的
              //o2.test(); //编译错误
      
              Boo o2 = new Boo();
              o2.b = 1;
              o2.test();
              o2.a = 2;  //正确，派生类可以访问超类的
              o2.show(); //正确
      
              Aoo o3 = new Boo(); //向上造型
              o3.a = 1;
              o3.show();
              //o3.b = 2;  //编译错误，能点出来什么，看引用的类型
              //o3.test(); //编译错误
          }
      }
      
      class Aoo{
          int a;
          void show(){
          }
      }
      class Boo extends Aoo{
          int b;
          void test(){
          }
      }

2. 方法的重写(override/overriding)：重新写
   1. 发生在父子类中，方法名相同，参数列表相同------派生类中重写了超类的方法
   2. 重写方法被调用时，看对象的类型
   3. 重写需遵循"两同两小一大"原则：
      1. 两同： 方法名相同、参数列表相同
      2. 两小：
         1. 派生类方法的返回值类型小于或等于超类方法
            1. void和基本类型时，必须相等
            2. 引用类型时，可以小于或等于
         2. 派生类方法抛出的异常小于或等于超类方法
      3. 一大：
         1. 派生类方法的访问权限大于或等于超类方法
3. 重写与重载的区别：（常见面试题）

   1. 重写(override)：发生在父子类中，方法名相同，参数列表相同

   2. 重载(overload)：发生在同一类中，方法名相同，参数列表不同

---

        本文完！

        写在结尾:

        2022 年 9 月 21 日 一个java菜鸟，发布于北京海淀。

        好记性不如烂笔头，持续学习，坚持输出~今天是持续写作的第2天。可以点赞、评论、收藏啦。

---