3_java面向对象

Posted 2020-11-26 未来已来，你来不来

目录

• java 的面向对象
  • 1. 定义一个类
  • 2. 使用类
  • 3. Scanner类
  • 4. Random 类
  • 5 ArrayList类

java 的面向对象

• 面向过程： 当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节
• 面向对象： 当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的为，来帮我做事儿

如：

public class Demo01Class {
    public static void main(String[] args) {
        int[] array = {10, 20, 30, 40, 50};

        // 要求打印数组，打印格式为： [10, 20, 30, 40, 50]
        // 使用面向过程，每一个步骤细节都要亲力亲为
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            if (i == array.length-1) {
                System.out.println(array[i] + "]");
            } else {
                System.out.print(array[i] + ",");
            }
        }

        System.out.println("============================");

        // 使用面向对象
        // 找一个 JDK 给我们提供的 Arrays类
        // 其中有一个toString方法，直接就能把数组变成想要的格式的字符串
        System.out.println(Arrays.toString(array));
    }
}

1. 定义一个类

// Student.java
public class Student {

    // 成员变量
    String name;    // 姓名
    int age;        // 年龄

    // 成员方法  不要写static关键字
    public void eat() {
        System.out.println("吃饭");
    }

    public void sleep() {
        System.out.println("睡觉");
    }

    public void study() {
        System.out.println("学习");
    }

}

2. 使用类

通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用

1. 导包： 导入类，需要使用的类，在什么位置

import 包名称.类名称;
对于和当前类属于同一个包的情况下，可以省略导包语句不写 (同一目录下)
java.lang包下的内容不需要导包

2. 创建对象

类名称 对象名 = new 类名称();
Student stu = new = Student();

3. 使用

使用成员变量： 对象名.成员变量名;
使用成员方法： 对象史.成员方法([参数]);

4. private 私有化成员

package day06_class;
/*
问题描述： 定义Person的年龄时，无法阻止不合理的数值被设置进来
解决方案： 用private关键字将需要保护的成员变量进行修饰

一旦使用了 private 进行修饰，那么本类当中仍然可以随意访问
但是！ 超出了本类范围之外就不能再访问了
 */
public class Person {
    String name;
    private int age;

    public void show() {
        System.out.println("我叫: " + name + ", " + "年龄" + age);
    }

    // 这个成员方法，专门用于向age设置数据
    public void setAge(int num) {
        if (num > 0 && num <= 120) {
            age = num;
        } else {
            System.out.println("数据不合法");
        }
    }

    // 专门用于获取私有变量 age 的值
    public int getAge() {
        return age;
    }
}

5. this关键字： 通过谁调用的方法， 谁就是 this

6. 构造方法

• 构造方法是专门用来创建对象的方法，当我们通过关键字new 来创建对象时，其实就是在调用构造方法

• 格式：

  public 类名称 ([参数类型 参数名称) {   // 因为构造方法的名称，与类名称必须一样，所以这里我叫其为类名称
      // 方法体
  }

• 注意事项：

  • 构造方法的名称必须和所在的类名称完全一样

  • 构造方法不能有返回值类型，包括void也不能有

public class Con {

    private String name;
    private int age;

    // 无参数构造方法
    public Con() {
        System.out.println("构造方法执行");
    }

    // 全参数构造方法
    public ConstructionDemo(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void show() {
        System.out.println("name: " + this.name + "age: " + this.age);
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return this.age;
    }
}

7. 一个标准的类

一个标准的类通常要拥有下面四个组成部分：

• 所有的成员变量都要使用pprivate 关键字修饰
• 为每一个成员变量编写一对儿getxxx/setxxx方法
• 编写一个无参数的构造方法
• 编写一个全参数的构造方法

这样标准的类也叫做Java Bean

package day06_class;

public class Students {
    private String name;
    private int age;

    public Students() {
    }

    public Students(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

3. Scanner类

Scanner类的作用： 可以实现键盘输入数据到程序中

导包： import java.util.Scanner;

创建： Scanner sc = new Scanner(System.in);

使用：

• 获取键盘输入的一个int数字： int num = sc.nextInt(); // 键盘输入的都是字符串，nextInt方法只是把字符串转换为int类型
• 获取键盘输入的一个字符串： String str = sc.next();

package day07;

import java.util.Scanner;

/*
题目： 从键盘中输入两个int数字，并且求出和值
 */
public class DemoSum02 {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        System.out.print("请输入第一个数字: ");
        int a = sc.nextInt();
        System.out.print("请输入第二个数字: ");
        int b = sc.nextInt();

        System.out.println(a + " + " + b + " = " + (a + b));
    }
}

4. Random 类

用于生成随机数

package day07;

import java.util.Random;

public class RandomDemo03 {
    public static void main(String[] args) {
        // 创建一个新的随机数生成器
        Random rdom = new Random();

        // 生成一个随机数
        // int num = rdom.nextInt();
        // System.out.println("随机数：" + num);

        // 生成 [0-10) 范围内的随机数
        for (int i=0; i<100; i++) {
            int num2 = rdom.nextInt(10);
            // int num2 = rdom.nextInt(10) + 1;  // 生成[1, 10] 之间的一个随机int数字
            System.out.println(num2);
        }
    }

    public static void show() {
        // 显示方法
    }
}

Random与Scanner类的练习：

package day07.demo02;

import java.util.Scanner;
import java.util.Random;

/*
猜数字游戏

思路：
1. 首先需要产生一个随机数字， 并且一旦产生不再变化. 用 Random的 nextInt() 方法
2. 需要键盘输入， 所以用到了Scanner
3. 获取键盘输入的数字， 用Scanner当中的 nextInt方法
4. 已经得到两个数字， 判断(if) 一下：
    如果太大了， 提示太大了， 并且重试
    如果太小了， 提示太小，并且重试
    如果猜中了， 游戏结束
 */
public class DemoTest {
    public static void main(String[] args) {
        Random r = new Random();
        // 1. 获取一个随机数字, [1-500]
        int rNum = r.nextInt(500) + 1;

        // 2. 键盘输入
        Scanner sc = new Scanner(System.in);

        // 3. 判断这两个数字
        int flag_num = 0;
        while (true) {
            System.out.print("请输入你猜的数字：");
            int inputNum = sc.nextInt();
            if (inputNum == rNum) {
                System.out.println("恭喜你，猜对了, 结果为: " + rNum + ", " + "你猜的数字为: " + inputNum);
                 break;
            } else if (inputNum > rNum) {
                System.out.println("大了");
                continue;
            } else {
                System.out.println("小了");
                continue;
            }
        }

    }
}

5 ArrayList类

java.uril.ArrayList 是大小可变的数组的实现，存储在内的数据称为元素。此类提供一些方法来操作内部存储的元素。ArrayList中可不断添加元素，其大小也自动增长

ArrayList<String> list = new ArrayList<>(); // 创建了一个ArrayList集合， 集合的名称是list, 里面装的全是String类型的字符串

list.add("only"); // 使用 add 方法添加元素

常用方法：

• public boolean add(E e) ： 向集合中添加元素，参数的类型必须与泛型一致
• public E get(int index) : 从集合当中获取元素，参数是索引编号， 返回值就是对应位置的元素
• public E remove(int index) : 从集合当中删除元素，参数是索引编号，返回值是被删除的元素
• public int size() : 获取集合的尺寸长度，返回值是集合中包含的元素个数

package day07.demo02;

import java.util.ArrayList;

/*
数组的长度不可以改变
但是ArrayList的长度是可以是可以随意变化的

对于ArrayList来说， 有一个尖括号 <E> 代表泛型.
泛型：也就是装在集合当中的所有元素，全都是统一的什么类型
注意： 泛型只能是引用类型，不能是基本类型
 */
public class Demo02ArrayList {

    public static void main(String[] args) {
        // 创建了一个ArrayList集合， 集合的名称是list, 里面装的全是String类型的字符串
        // 备注： 从JDK 1.7+开始，右侧的尖括号内部可以不写内容，但是 <> 本身还是要写的
        ArrayList<String> list = new ArrayList<>();

        // System.out.println(list);   // []

        // 向集合中添加数据， 要用到 add 方法
        list.add("Yanyan");
        list.add("Cheng");
        System.out.println(list);
    }

}

package day07.demo02;

/*
ArrayList中的常用方法有：

public boolean add(E e)   向集合中添加元素，参数的类型和泛型一致
备注： 对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用
但是对于其他集合(今后学习) 来说， add 添加动作不一定成功

public E get(int index) : 从集合当中删除元素， 参数是过些编号， 返回值是被删除的元素
public int size() : 获取集合的尺寸大小， 返回值是集合中包含的元素个数
 */

import java.util.ArrayList;

public class ArrayListMethods {
    public static void main(String[] args) {
        //
        ArrayList<String> list = new ArrayList<String>();

        boolean success = list.add("yanyan");
        list.add("cheng");
        list.add("zhu");
        list.add("long");
        System.out.println("集合添加成功: " + success);

        // 从集合中获取元素 get
        String love_person = list.get(0);
        System.out.println(love_person);   // yanyan

        list.add("remove_test");
        System.out.println(list);
        //  remove 删除指定索引的元素
        String remove_name = list.remove(list.size() - 1);   // 删除最后一个 , list.size() 集合的大小  - 1 就是集合的最后一个元素的索引值了
        System.out.println("被删除的人为： " + remove_name);
        System.out.println(list);

        // 集合的长度
        System.out.println("list的长度为：" + list.size());

    }
}

package day07.demo02;

import java.util.ArrayList;

/*
遍历 ArrayList
 */
public class ArrayListDemoEach {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        for(int i=1; i<=20; i++) {
            list.add("list_" + i);
        }
        // System.out.println(list);

        // 遍历(Each)ArrayList集合
        for(int i=0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

ArrayList集合存储基本数据类型

问问 JDK1.5+开始，支持自动装箱、自动拆箱

• 自动装箱： 基本类型 ---- > 包装类型
• 自动拆箱： 包装类型 ----->基本类型

如果希望向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的 "包装类"

基本类型            包装类(引用类型， 包装类都位于java.lang包下, 即不需要导包就可以使用)
byte                Byte
int                 Integer    # 特殊
short               Short
float               Float
double              Double
char                Character   # 特殊
boolean             Boolean