5~8 方法、数组、IDEA使用、面向对象

5 方法

5.1 方法定义和调用

5.1.1 什么是方法method？

方法（method）是一段用来完成特定功能的代码片段，类似于其它语言的函数（function）。
方法用于定义该类或该类的实例的行为特征和功能实现。方法是类和对象行为特性的抽象。方法类似于面向过程中的函数。
面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是属于类和对象的。

5.1.2 方法的详细说明

• 形式参数：在方法声明中用于接收外界传入的数据。
• 实参：调用方法时实际传给方法的数据。
• 返回值：方法在执行完毕后返还给调用它的环境的数据。
• 返回值类型：事先约定的返回值的数据类型，如无返回值，必须显示指定为void。

格式：

修饰符 方法返回值类型 方法名(形参列表){
    方法体;
    return 方法返回值;
}

可变参数...
修饰符：
权限修饰符private、friendly(default)、protected、public
关键字abstract、final、static、synchronized

访问级别	访问控制修饰符	同类	同包	子类	不同包
公开	public	允许	允许	允许	允许
受保护	protected	允许	允许	允许	不允许
默认	没有修饰符	允许	允许	不允许	不允许
私有	private	允许	不允许	不允许	不允许

5.2 方法重载OverLoad

5.2.1 什么是方法的重载

方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。调用时，会根据不同的参数自动匹配对应的方法。
注意本质：重载的方法，实际是完全不同的方法，只是名称相同而已！

5.2.2 构成方法重载的条件

• 不同的含义：形参类型、形参个数、形参顺序不同
• 只有返回值不同不构成方法的重载
• 只有形参的名称不同，不构成方法的重载

【扩充】

package com.liweixiao.test03;

/**
 * @author:LiWeixiao
 * @date:2023/2/24
 * @description:
 */
public class Test {
    public static void main(String[] args){
        add(5);
        //级别：byte,short,char-->int-->long-->float--->double
    }

    public static void add(double num1){
        System.out.println("------2");
    }
    public static void add(float num1){
        System.out.println("------3");
    }
    public static void add(long num1){
        System.out.println("------4");
    }
    /*public static void add(int num1){
            System.out.println("------1");
    }*/
}

6 数组

6.1 数组的学习

数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）来访问它们。

6.2 数组的三种初始化方式

• 静态初始化
  eg:
  int[] arr = {12,23,45};
  int[] arr = new int[]{12,23,45};
  注意：
  1.new int[3]{12,23,45};-->错误
  2.int[] arr ;
  arr = {12,23,45}; --->错误
• 动态初始化
  eg:
  int[] arr ;
  arr = new int[3]
  arr[0] = 12;
  arr[1] = 23;
  arr[2] = 45;
• 默认初始化
  int[] arr = new int[3]; ---> 数组有默认的初始化值
  基本数组类型的数组的默认初始化值：
  byte[]、short[]、int[]、long[]：0
  float[]、double[]：0.0
  char[]：'\u0000'
  boolean[]：false
  引用数组类型的数组的默认初始化值：null

6.3 Arrays工具类

为了方便我们对数组进行操作，系统提供一个类Arrays，将它当做工具类来使用。

import java.util.Arrays;
public class TestArray13{
        public static void main(String[] args){
                //给定一个数组：
                int[] arr = {1,3,7,2,4,8};
                //toString:对数组进行遍历查看的，返回的是一个字符串，这个字符串比较好看
                System.out.println(Arrays.toString(arr));
                
                //binarySearch:二分法查找：找出指定数组中的指定元素对应的索引：
                //这个方法的使用前提：一定要查看的是一个有序的数组：
                //sort：排序 -->升序
                Arrays.sort(arr);
                System.out.println(Arrays.toString(arr));
                System.out.println(Arrays.binarySearch(arr,4));
                
                int[] arr2 = {1,3,7,2,4,8};
                //copyOf:完成数组的复制：
                int[] newArr = Arrays.copyOf(arr2,4);
                System.out.println(Arrays.toString(newArr));
                
                //copyOfRange:区间复制：
                int[] newArr2 = Arrays.copyOfRange(arr2,1,4);//[1,4)-->1,2,3位置
                System.out.println(Arrays.toString(newArr2));
                
                //equals:比较两个数组的值是否一样：
                int[] arr3 = {1,3,7,2,4,8};
                int[] arr4 = {1,3,7,2,4,8};
                System.out.println(Arrays.equals(arr3,arr4));//true
                System.out.println(arr3==arr4);//false ==比较左右两侧的地址值是否相等，返回结果一定是false
                
                //fill：数组的填充：
                int[] arr5 = {1,3,7,2,4,8};
                Arrays.fill(arr5,10);
                System.out.println(Arrays.toString(arr5));
        }
}

6.4 二维数组

本质上全部都是一维数组。

• 静态初始化
  eg:
  int[][] arr = {{1,2},{4,5,6},{4,5,6,7,8,9,9}};
  int[][] arr =new int[][] {{1,2},{4,5,6},{4,5,6,7,8,9,9}};
• 动态初始化
  eg:
  int[][] arr = new int[3][]; //本质上定义了一维数组长度为3，每个“格子”中放入的是一个数组
  arr[0] = new int[]{1,2};
  arr[1] = new int[]{3,4,5,6};
  arr[2] = new int[]{34,45,56};
• 默认初始化

7 IDEA介绍

详见《IDEA常用》

8 面向对象

8.1 面向过程和面向对象的区别

面向过程：当事情比较简单的时候，利用面向过程，注重的是事情的具体的步骤/过程，注重的是过程中的具体的行为，以函数为最小单位，考虑怎么做。
面向对象：注重找“参与者”，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位。
面向过程：编年体
面向对象：纪传体

8.2 类和对象的关系

1. 万事万物皆对象
2. 对象：具体的事物，具体的实体，具体的实例，模板下具体的产品
   类：对对象向上抽取像的部分，公共的部分，形成类，类是抽象的，是一个模板
3. 一般在写代码的时候先写类，然后再根据类创建对应的对象。

8.3 面向对象三个阶段

1. 面向对象分析OOA--Object Oriented Analysis
   对象：张三、李四、王五
   抽取出一个类 -》 人类
   类里有什么：
   动词，动态特性 -》 方法
   名称，静态特性 -》 属性
2. 面向对象设计OOD--Object Oriented Design
   先有类，再有对象
   类：人类，Person
   对象：zhangsan、lisi、wangwu
3. 面向对象编程OOP--Object Oriented Programming

8.4 类、对象

8.4.1 创建类

（1）属性（field 成员变量）
[修饰符] 属性类型 属性名 = [默认值] ;
（2）方法
[修饰符] 方法返回值类型 方法名(形参列表) {
// n条语句
}

8.4.2 创建对象

Person zhangsan = new Person();

8.4.3 局部变量和成员变量的区别

成员变量：类中方法外定义的变量
局部变量：方法中定义的变量，代码块中定义的变量

8.4.4 构造器，构造器的重载

【构造器】
构造器和方法的区别：
1.没有方法的返回值类型
2.方法体内部不能有return语句
3.构造器的名字很特殊，必须跟类名一样
【构造器重载】
1.一般保证空构造器的存在，空构造器中一般不会进行属性的赋值操作
2.一般我们会重载构造器，在重载的构造器中进行属性赋值操作
3.在重载构造器以后，假如空构造器忘写了，系统也不会给你分配默认的空构造器了，那么你要调用的话就会出错了。
4. 当形参名字和属性名字重名的时候，会出现就近原则：
在要表示对象的属性前加上this.来修饰 ，因为this代表的就是你创建的那个对象

8.4.5 内存分析

以上图片来自网络

8.4.6 this

this指代的就是当前对象。
（1）this可以修饰属性：
总结：当属性名字和形参发生重名的时候，或者 属性名字 和局部变量重名的时候，都会发生就近原则，所以如果我要是直接使用变量名字的话就指的是离的近的那个形参或者局部变量，这时候如果我想要表示属性的话，在前面要加上：this.修饰
（2）this修饰方法：
总结：在同一个类中，方法可以互相调用，this.可以省略不写。
（3）this可以修饰构造器：
总结：同一个类中的构造器可以相互用this调用，注意：this修饰构造器必须放在第一行。

8.4.7 static

static可以修饰：属性、方法、代码块、内部类。
【总结】
1.在类加载的时候，一起加载入方法区中的静态域中
2.先于对象存在
3.访问方式：对象名.属性名 类名.属性名（推荐），对象名.方法名 类名.方法名（推荐）

8.4.8 代码块

代码块分类：普通块、构造块、静态块、同步块（多线程）
【执行顺序】
静态块 -》 构造块（不常用） -》 构造器 -》 普通块

8.4.9 包，import

包的作用：为了解决重名问题，解决权限问题。
包名定义：
1.名字全部小写
2.中间用.隔开
3.公司域名倒着写 com.liweixiao
4.加上模块名字 com.liweixiao.login com.liweixiao.register

8.5 三大特性

8.5.1 封装

高内聚:类的内部数据操作细节自己完成，不允许外部干涉;
低耦合:仅对外暴露少量的方法用于使用。
通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。
提高代码的安全性。

8.5.2 继承

继承的好处：
1.提高了代码的复用性，父类定义的内容，子类可以直接拿过来用就可以了，不用代码上反复重复定义了
2.便于代码的扩展
3.为了以后多态的使用。是多态的前提。
继承具有传递性：
1.Student --》继承自 Person ---》继承自Object
2.Object类是所有类的根基父类。
3.所有的类都直接或者间接的继承自Object。

8.5.3 多态

（1）先有父类，再有子类：--》继承 先有子类，再抽取父类 ----》泛化
（2）什么是多态：
多态就是多种状态：同一个行为，不同的子类表现出来不同的形态。
多态指的就是同一个方法调用，然后由于对象不同会产生不同的行为。
（3）多态的好处：
为了提高代码的扩展性，符合面向对象的设计原则：开闭原则。
开闭原则：指的就是扩展是 开放的，修改是关闭的。
注意：多态可以提高扩展性，但是扩展性没有达到最好，以后我们会学习 反射
（4）多态的要素：
一，继承： Cat extends Animal ,Pig extends Animal, Dog extends Animal
二，重写：子类对父类的方法shout()重写
三， 父类引用指向子类对象

向下转型，向上转型

简单工厂设计模式

8.6 final等

8.6.1 final

【1】修饰变量
final修饰一个变量，变量的值不可以改变，这个变量也变成了一个字符常量，约定俗称的规定：名字大写
final修饰引用数据类型，那么地址值就不可以改变
【2】修饰方法
final修饰方法，这个方法不可以被该类的子类重写
【3】修饰类
final修饰类，代表没有子类，该类不可以被继承
一旦一个类被final修饰，那么里面的方法也没有必要用final修饰了（final可以省略不写）

8.6.2 抽象类、抽象方法

在抽象类中定义抽象方法，目的是为了为子类提供一个通用的模板，子类可以在模板的基础上进行开发，先重写父类的抽象方法，然后可以扩展子类自己的内容。抽象类设计避免了子类设计的随意性，通过抽象类，子类的设计变得更加严格，进行某些程度上的限制。使子类更加的通用。
1.在一个类中，会有一类方法，子类对这个方法非常满意，无需重写，直接使用
2.在一个类中，会有一类方法，子类对这个方法永远不满意，会对这个方法进行重写
3.一个方法的方法体去掉，然后被abstract修饰，那么这个方法就变成了一个抽象方法
4.一个类中如果有方法是抽象方法，那么这个类也要变成一个抽象类
5.子类继承抽象类，就必须重写全部的抽象方法

抽象类不能被final修饰，因为抽象类设计的初衷就是给子类继承用的。要是被final修饰了这个抽象类了，就不存在继承了，就没有子类。

8.6.3 接口

【定义】
1.类是类，接口是接口，它们是同一层次的概念
2.接口中没有构造器
3.接口如何声明：interface
4.接口中内容
在JDK1.8之前
（1）常量：固定修饰符：public static final
（2）抽象方法：固定修饰符：public abstract
在JDK1.8之后，新增非抽象方法
（1）被public default修饰的非抽象方法
5.类和接口的关系是什么？ 实现关系 类实现接口：
6.一旦实现一个接口，那么实现类要重写接口中的全部的抽象方法：
7.如果没有全部重写抽象方法，那么这个类可以变成一个抽象类。
8.java只有单继承，java还有多实现
一个类继承其他类，只能直接继承一个父类
但是实现类实现接口的话，可以实现多个接口
9.写法：先继承 再实现：extends Person implements TestInterface01,TestInterface02

8.6.4 内部类

成员内部类
局部内部类

8.7 面向对象项目

项目需求：

以上图片来自网络

package com.liweixiao.pojo;

/**
 * @author:LiWeixiao
 * @date:2022/10/28
 * @description:披萨类
 */
public class Pizza {
    //属性
    private String name;//名称
    private double price;//价格
    private int size;//大小

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    //构造器
    public Pizza() {
    }

    public Pizza(String name, double price, int size) {
        this.name = name;
        this.price = price;
        this.size = size;
    }

    //方法
    public String showPizza(){
        return "名称："+name+"\n价格："+price+"元\n大小："+size+"寸";
    }
}

package com.liweixiao.pojo;

/**
 * @author:LiWeixiao
 * @date:2022/10/28
 * @description:培根披萨类
 */
public class PizzaBacon extends Pizza{
    //属性
    private int weight;//克数

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    //构造器
    public PizzaBacon() {
    }

    public PizzaBacon(String name, double price, int size, int weight) {
        super(name, price, size);
        this.weight = weight;
    }

    //方法
    @Override
    public String showPizza() {
        return super.showPizza()+"\n培根克数："+weight+"g";
    }
}

package com.liweixiao.pojo;

/**
 * @author:LiWeixiao
 * @date:2022/10/28
 * @description:水果披萨类
 */
public class PizzaFruit extends Pizza{
    //属性
    private String burden;//配料

    public String getBurden() {
        return burden;
    }

    public void setBurden(String burden) {
        this.burden = burden;
    }

    //构造器
    public PizzaFruit() {
    }

    public PizzaFruit(String name, double price, int size, String burden) {
        super(name, price, size);
        this.burden = burden;
    }

    //方法
    @Override
    public String showPizza() {
        return super.showPizza()+"\n配料水果："+burden;
    }
}

package com.liweixiao.pojo;

import java.util.Scanner;

/**
 * @author:LiWeixiao
 * @date:2022/10/28
 * @description:简单工厂类
 */
public class PizzaStore {
    //获取披萨
    public static Pizza getPizza(int choice){
        Pizza p=null;
        Scanner sc = new Scanner(System.in);
        switch(choice){
            case 1:
                {
                    System.out.print("请输入培根的克数：");
                    int weight=sc.nextInt();
                    System.out.print("请输入披萨的大小：");
                    int size=sc.nextInt();
                    System.out.print("请输入披萨的价格：");
                    double price=sc.nextDouble();
                    PizzaBacon pb = new PizzaBacon("培根披萨", price, size, weight);
                    p=pb;
                }
                break;
            case 2:
                {
                    System.out.print("请输入要加入的水果：");
                    String burden=sc.next();
                    System.out.print("请输入披萨的大小：");
                    int size=sc.nextInt();
                    System.out.print("请输入披萨的价格：");
                    double price=sc.nextDouble();
                    PizzaFruit pf = new PizzaFruit("水果披萨", price, size, burden);
                    p=pf;
                }
                break;
        }
        return p;
    }
}

package com.liweixiao.pojo;

import java.util.Scanner;

/**
 * @author:LiWeixiao
 * @date:2022/10/28
 * @description:测试类
 */
public class Test {
    //main方法
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请选择想要制作的披萨：1.培根披萨 2.水果披萨：");
        int choice=sc.nextInt();
        Pizza p = PizzaStore.getPizza(choice);
        System.out.println(p.showPizza());
    }
}