Java学习5-数组+面向对象+关键字+构造方法

最新推荐文章于 2022-08-11 01:47:48 发布

努力学习的代码小白

最新推荐文章于 2022-08-11 01:47:48 发布

阅读量804

点赞数 1

分类专栏：学习笔记文章标签： java

本文链接：https://blog.csdn.net/weixin_42656213/article/details/123586108

版权

学习笔记专栏收录该内容

63 篇文章 10 订阅

订阅专栏

1. 数组

1.1 数组概念

1.2 数组的定义格式 - 创建动态初、静态数组

package njust.c518.day0318.demo02;

/*
两种常见的初始化方式：
1、动态初始化（指定长度）：在创建数组时，直接指定数组当中的数据元素个数
2、静态初始化（指定内容）：在创建数组时，不直接指定数据个数多少，而是直接将具体的数据内容进行指定

动态初始化的格式：
数据类型[] 数组名称 = new 数据类型[数组长度];
* 解析含义：
左侧数据类型：也就是数组当中保存的数据，全都是统一的什么类型
左侧的中括号：代表是一个数组
左侧数组名称：给数组一个名字
右侧的new：代表创建数组的动作
右侧数据类型：必须和左边的数据类型保持一致
右侧中括号的长度：也就是数组当中，到底可以保存多少个数据，是一个int数字

静态数组初始化基本格式：
数据类型[] 数组名称 = new 数据类型[] {元素1, 元素2, 元素3, ...};

静态数组初始化的省略格式：
数据类型[] 数组名称 = {元素1, 元素2, 元素3, ...};

注意事项：
1、静态初始化虽然没有直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出来长度
2、静态初始化标准格式可以拆分成两个步骤
3、动态初始化也可以拆分成两个步骤
4、静态初始化一旦使用省略格式，就不能拆分成两个步骤了
使用建议：
如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化
 */
public class ArrayExp1 {
    public static void main(String[] args) {
        // 创建动态数组
        int[] array1 = new int[100];
        double[] array2 = new double[50];
        String[] array3 = new String[10];

        //创建静态数组
        int[] array4 = new int[] {10, 20, 30}; //长度为3
        String[] array5 = new String[] {"hello", "java", "world"}; // 长度为3

        // 创建省略的静态数组
        int[] array6 = {10, 20};

        // 动态初始化也可以拆分成两个步骤
        int[] array7;
        array7 = new int[10];
        // 静态初始化也可以拆分成两个步骤
        int[] array8;
        array8 = new int[] {10, 20};
        /*
         静态初始化的省略格式，不能拆分成两个步骤
         int[] array9;
         array9 ={10, 20};
        */
    }

}

1.3 访问数组元素

package njust.c518.day0318.demo02;

public class ArrayUse1 {
    public static void main(String[] args) {
        // 访问数组元素，进行获取，静态
        int[] array1 = {10, 20, 30};
        //打印数组内存地址
        System.out.println(array1);
        // 直接打印数组当中的元素
        System.out.println(array1[0]);
        System.out.println(array1[1]);
        System.out.println(array1[2]);
        System.out.println("========");
        // 也可以将数组当中的某一个单个元素，赋值交给变量
        int num = array1[1];
        System.out.println(num);

        // 访问数组元素，进行赋值，动态
        int[] array2 = new int[3];
        System.out.println(array2); //内存地址
        System.out.println(array2[0]); // 0 ，默认值
        System.out.println(array2[1]); // 0 ，默认值
        System.out.println(array2[2]); // 0 ，默认值
        // 将数据123赋值给数组array当中的1号元素
        array2[1] = 123;
        System.out.println(array2[0]); // 0
        System.out.println(array2[1]); // 123
        System.out.println(array2[2]); // 0
    }
}

1.4 Java中内存划分

1.5 数组内存图

1.5.1 一个数组的内存图

1.5.2 两个数组的内存图

1.5.3 两个引用指向同一个数组的内存图

1.6 常见问题1 - 数组索引越界异常

1.7 常见问题2 - 空指针异常

1.8 数组长度

package njust.c518.day0318.demo02;

public class ArrayLen {
    public static void main(String[] args) {
        int[] arrayA = new int[3];
        int[] arrayB = {10,20,30,50,40,60,1,2,3,4,5,6};
        int len = arrayB.length;
        System.out.println("arrayB数组的长度是：" + len);
        System.out.println("=========");

        int[] arrayC = new int[3];
        System.out.println(arrayC.length);
        arrayC = new int[5];
        System.out.println(arrayC.length);
    }
}

1.9 遍历数组

package njust.c518.day0318.demo02;

public class PrintArray {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

1.10 求数组中的最值

package njust.c518.day0318.demo02;

public class ArrayMaxAndMin {
    public static void main(String[] args) {
        int[] array = {10, 20, 2, 1000, 50, 45, 70};
        int max = array[0];
        int min = array[0];
        for (int i = 1; i < array.length; i++) {
            if(max < array[i]){
                max = array[i];
            }
            if(min > array[i]){
                min = array[i];
            }
        }
        System.out.println("最大值是：" + max);
        System.out.println("最小值是：" + min);
    }
}

1.11 数组元素反转

package njust.c518.day0318.demo02;

public class ArrayReverse {
    public static void main(String[] args) {
        int[] array = {10, 20, 5, 60, 25, 30, 7};
        System.out.println("转置前：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
       /* int min = 0; // 方法1，while循环
        int max = array.length - 1;
        while(min < max){
            int temp;
            temp = array[min];
            array[min] = array[max];
            array[max] = temp;
            min++;
            max--;
        }*/

        // 方法2，for循环
        for(int min = 0, max = array.length - 1; min < max; min++, max--){

            int temp = array[min];
            array[min] = array[max];
            array[max] = temp;
        }
        System.out.println("转置后：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
}

1.12 数组作为方法参数 - 传地址

package njust.c518.day0318.demo02;

public class ArrayParam {
    public static void main(String[] args) {
        int[] array = {10, 20, 30, 40, 50};
        System.out.println(array); //地址值
        System.out.println("======方法输出======");
        printArray(array);
    }
    public static void printArray(int[] array){
        System.out.println("printArray方法收到的参数是" + array); //地址值
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

1.13 数组作为方法返回值 - 返回地址

package njust.c518.day0318.demo02;

public class ArrayReturn {
    public static void main(String[] args) {
        int[] ret = caculateRet(10, 20,30);
        System.out.println("main方法的数组是：" + ret); //地址
        System.out.println("总和：" + ret[0]);
        System.out.println("平均值：" + ret[1]);
    }
    public static int[] caculateRet(int a, int b, int c){
        int sum = a + b + c;
        int avg = sum / 3;
        int[] ret = {sum, avg};
        System.out.println("方法内部的数组是：" + ret); //地址
        return ret;
    }
}

2. 面向对象

2.1 面向对象思想概述

package njust.c518.day0318.demo02;

import java.util.Arrays;

/*
面向过程：当需要实现一个功能的时候，每一个具体步骤都要亲力亲为，详细处理每一个细节。
面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事
 */
public class PrintArrayObj {
    public static void main(String[] args) {
        int[] array = {10, 20, 30, 40, 50, 60};
        // 打印格式为：[10, 20, 30, 40, 50, 60]
        // 面向过程，每一个步骤细节都要自己写
        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类，
        // 其中有一个toStrings方法，直接就能把数组变成想要的格式的字符串
        System.out.println(Arrays.toString(array));
    }
}

2.2 类和对象的关系

2.3 类的定义

（1）成员方法不带static

（2）成员变量是直接定义在类当中的，在方法外边。

package Demo01;

public class Student {
    // 成员变量
    String name; //名字
    int age; // 年龄

    // 成员方法
    public void eat(){
        System.out.println("吃饭饭！");
    }
    public void sleep(){
        System.out.println("睡觉觉！");
    }
    public void study(){
        System.out.println("学习习！");
    }
}

2.4 对象的创建及其使用

package Demo01;

/*
通常情况下，一个类并不能直接使用，想要根据类创建一个对象，才能使用。
1. 导包：也就是指出需要使用的类，在什么位置。
import 包名称.类名称;
import Demo01.Student;
对于和当前属于一个包的情况，可以省略导包语句不写。

2. 创建，格式：
类名称 对象名 = new 类名称();
Student stu = new Student();

3. 使用，分为两种情况：
使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名(参数)
（也就是，想用谁，就用对象名点儿谁）

注意事项：
如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样
 */
public class Demo01Student {
    public static void main(String[] args) {
        // 1. 导包。
        // 我需要的 Student类，和我自己的Demo01Student位于同一个包下，所以省略导包语句不写
        // 2. 创建，格式：
        // 类名称 对象名 = new 类名称();
        // 根据Student类，创建了一个名为stu的对象
        Student stu = new Student();
        // 3. 使用
        //使用成员变量：对象名.成员变量名
        System.out.println(stu.name); // null
        System.out.println(stu.age); // 0
        // 改变对象中的成员变量数值内容
        // 将右侧的字符串，赋值交给stu对象当中的name成员变量
        stu.name = "哈哈哈";
        stu.age = 18;
        System.out.println(stu.name);
        System.out.println(stu.age);
        System.out.println("============");
        stu.study();
        stu.eat();
        stu.sleep();
    }
}

2.5 手机类练习

package Demo02;

public class PhoneOne {
    public static void main(String[] args) {
        Phone one = new Phone();
        System.out.println(one.brand);
        System.out.println(one.price);
        System.out.println(one.color);
        System.out.println("===========");
        one.brand = "苹果";
        one.color = "红色";
        one.price = 8868;
        System.out.println(one.brand);
        System.out.println(one.price);
        System.out.println(one.color);
        one.call("乔布斯");
        one.sendMessage();
    }
}

2.6 一个对象的内存图

2.7 两个对象使用同一个方法的内存图

2.8 两个引用指向同一个对象的内存图

2.9 使用对象类型作为方法的参数

package Demo02;

public class PhoneParam {
    public static void main(String[] args) {
        Phone one = new Phone();
        one.brand = "苹果";
        one.price = 8868;
        one.color = "炫酷黑";
        method(one);
    }
    public static void method(Phone phone){
        System.out.println(phone.brand);
        System.out.println(phone.color);
        System.out.println(phone.price);
    }
}

2.10 使用对象类型作为方法的返回值

package Demo02;

public class Phone {
    // 成员变量
    String brand;
    double price;
    String color;
    // 成员方法
    public void call(String who){
        System.out.println("给" + who + "打电话");
    }
    public void sendMessage(){
        System.out.println("群发短信");
    }
}

package Demo02;

public class PhoneReturn {
    public static void main(String[] args) {
        Phone two = getPhone();
        System.out.println(two.price);
        System.out.println(two.brand);
        System.out.println(two.color);
    }
    public static Phone getPhone(){
        Phone one = new Phone();
        one.price = 8868;
        one.brand = "苹果";
        one.color = "玫瑰金";
        return one;
    }
}

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

2.12 面向对象三大特征之封装性

3. 关键字

3.1 private 关键字

3.1.1 private 关键字的作用及使用

package Demo02;

// 类
public class Person {
    String name;
    int age;
    public void show(){
        System.out.println("我叫：" + name + "，年龄：" + age);
    }
}

package Demo02;

// 对象
public class PersonOne {
    public static void main(String[] args) {
        Person per = new Person();
        per.name = "哈哈哈";
        per.age = 20;
        per.show();
    }
}

package Demo02;

/*
间接使用private成员变量，就是定义一对儿Getter/Setter方法
 */
// 类
public class Person {
    String name;
    private int age;
    public void show(){
        System.out.println("我叫：" + name + "，年龄：" + age);
    }
    // 这个成员方法，专门用于向age设置数据
    public void setAge(int num){
        if(num < 100 && num >= 9){
            age = num;
        } else {
            System.out.println("数据不合理！");
        }
    }
    // 整个成员方法，专门用于获取age的数据
    public int getAge(){
        return age;
    }
}

package Demo02;

public class PersonOne {
    public static void main(String[] args) {
        Person per = new Person();
        per.show();
        per.name = "哈哈哈";
        //  per.age = -20; // 直接访问private内容，错误写法
        per.setAge(20);
        per.show();
    }
}

3.1.2 练习使用 private 关键字定义学生类

package Demo02;

/*
对于基本类型中的boolean值，Getter方法一定要写成isXxx形式，而setXxx规则不变
 */
// 类
public class Student {
    private String name;
    private int age;
    private boolean male;
    public void setMale(boolean b){
        male = b;
    }
    public boolean isMale(){
        return male;
    }
    public void setName(String str){
        name = str;
    }
    public String getName(){
        return name;
    }
    public void setAge(int num){
        age = num;
    }
    public int getAge(){
        return age;
    }
}

package Demo02;

// 对象
public class StudentDemo {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setName("哈哈哈");
        stu.setAge(18);
        stu.setMale(false);
        System.out.println("姓名：" + stu.getName() + "年龄：" + stu.getAge() + "性别：" + stu.isMale());
    }
}

3.2 this 关键字

package Demo03;

// 类
public class Person {
    String name; // 我自己的名字
    // 参数name是自己的名字
    // 成员变量name是自己的名字
    public void sayHello(String name){
        System.out.println(name + "，你好。我是：" + name);
    }
}

package Demo03;

// 对象
public class PersonDemo {
    public static void main(String[] args) {
        Person per = new Person();
        // 设置自己的名字
        per.name = "哈哈哈";
        per.sayHello("呵呵呵");
    }
}

package Demo03;

// 类
public class Person {
    String name; // 我自己的名字
    // 参数name是自己的名字
    // 成员变量name是自己的名字
    public void sayHello(String name){
        System.out.println(name + "，你好。我是：" + this.name);
        System.out.println(this); // 和对象内的代码的地址值值一样
    }
}

package Demo03;

public class PersonDemo {
    public static void main(String[] args) {
        Person per = new Person();
        // 设置自己的名字
        per.name = "哈哈哈";
        per.sayHello("呵呵呵"); // 通过per调用的sayHello方法，所以per是this
        System.out.println(per); // 地址值
    }
}

4. 构造方法

package Demo03;

// 类
/*
构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法
格式：
public 类名称（参数类型 参数名称）{
    方法体
}
注意事项：
1、构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
2、构造方法不要写返回值类型，连void都不写
 */
public class Student {
    public Student(){
        System.out.println("构造方法执行啦！！！");
    }
}

package Demo03;

// 对象
public class StudentDemo {
    public static void main(String[] args) {
        Student stu = new Student(); // 其中的Student()调用的就是构造方法
    }
}

package Demo03;

// 类
/*
构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法
格式：
public 类名称（参数类型 参数名称）{
    方法体
}
注意事项：
1、构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
2、构造方法不要写返回值类型，连void都不写
3、构造方法不能return一个具体的返回值
4、如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做。
public Student() {}
5、一旦编写了至少一个构造方法，那么编译器将不再赠送。
6、构造方法也是可以重载的
 */
public class Student {
    // 成员变量
    private String name;
    private int age;

    // 无参构造
    public Student(){
        System.out.println("构造方法执行啦！！！");
    }
    // 全参构造
    public Student(String name,int age){
        System.out.println("全参构造方法执行啦！！！");
        this.name = name;
        this.age = age;
    }
    // Getter Setter
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
}

package Demo03;

// 对象
public class StudentDemo {
    public static void main(String[] args) {
        Student stu = new Student(); // 其中的Student()调用的就是构造方法
        Student stu2 = new Student("哈哈哈",18);
        // 直接使用全参构造中的姓名、年龄
        System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
        // 如果需要修改对象中的成员变量的数据内容，仍然还需要使用setXxx方法
        stu2.setAge(20);
        System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
    }
}

5. 定义一个标准的类

5.1 自动生成Getter、Setter 方法：

5.2 自动生成无参构造

5.3 自动生成全参构造

package Demo04;

// 类
public class Student {
    private String name;
    private int 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;
    }

    public Student() {
    }

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

package Demo04;

// 对象
public class StudentDemo {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.setName("哈哈哈");
        stu1.setAge(18);
        System.out.println("姓名：" + stu1.getName() + "，年龄：" + stu1.getAge());
        System.out.println("===========");

        Student stu2 = new Student("呵呵呵",20);
        System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
        stu2.setAge(21);
        System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
    }
}