Java面向对象程序设计（基础学习）

Java入门学习

环境搭建：JDK + IDEA（社区版）

打印“Hello World”

//HelloPer.java
public class Hello {//类
    public static void main(String[] args) {//有主函数
        System.out.println("Hello World");//语句
    }
}

Java基础知识

java的语言特点

1.面向对象
2.可移植性——跨平台
3.可解释性
4.多线程
5.安全性——沙箱
···

Java的命名规则与特点

1、避免关键字
2、区分大小写
3、首字符不能是数字
4、可以是下划线（_）、美元符号（$）和字母

【经验：驼峰命名法。类名首字母大写，变量名首字母小写，且尽量避免无意义的命名】

Java常用数据类型

数据类型
    基本数据类型：
        数值型：
            整数型：int、byte、short、long
            浮点型：float、double
        字符型：char
        布尔型【真/假】：boolean
        
    引用数据类型：
        字符串（String）、
        类（class）、
        接口（interface）、
        枚举（enum）、
        注解（annotation）

Java基础语句部分

【每种较高级的编程语言，这部分的逻辑都差不多，主要区别是代码编写方式不同】

Java代码结构示例：

/** 打印 “Hello World” */
//HelloPer.java
public class Hello {//主类
    public static void main(String[] args) {//主函数
        System.out.println("Hello World");//语句
    }
}

注意：
1、一个文件中只能有一个主类，主类中只能有一个主函数
2、主类的命名与文件名相同
3、public是访问修饰符，表示公共的；private表示私有的；
···（其它待补充）···

拓展：Java中的“包”的使用：

语法格式：package [文件名].[类名]

补充：

1、包（package）可以在一个文件中调用其他文件中的类，来进行使用
2、在文件中，一般先引入包，在定义类

基础运算符的使用

【这部分就是简单的加减乘除和数据类型的使用，看看案例就能理解】

//SumPrice.java
/*计算总价*/
public class SumPrice {
    public static void main(String[] args) {
        //基础运算符的使用
        /*
         * 购书结算
         * */
        //定义价格
        int javaPrice = 32;
        int pythonPrice = 27;
        //定义数量
        int javaNo = 2;
        int pythonNo = 3;
        //计算总价【总价=单价*数量】
        int sumPrice = javaPrice * javaNo + pythonPrice * pythonNo;
        System.out.println("总价为：" + sumPrice);
    }
}

顺序结构和分支结构

【这部分就是简单顺序结构、if判断和switch分支的使用，看案例】

顺序结构示例：

/*交换first和second的值*/
public class Hello {//类
    public static void main(String[] args) {//有主函数
        int first, second;
        int temp;
        first = 20;
        second = 30;
        System.out.println("first和second交换前：");
        System.out.println("first = " + first);
        System.out.println("second = " + second);
        //将first和second进行交换
        temp=first;
        first=second;
        second=temp;
        System.out.println("first和second交换后：");
        System.out.println("first = " + first);
        System.out.println("second = " + second);

    }
}

分支结构

if-else双分支-示例

/*测体温*/
//引入java.util.Scanner，目的是实现数据输入
import java.util.Scanner;
public class Hello {
    public static void main(String[] args) {
        float temperature;
        Scanner input = new Scanner(System.in);//定义input对象，用于接收控制台输入
        System.out.println("请输入当前测量的温度值：");
        temperature = input.nextFloat();//使用变量temperature接收输入
        if (temperature >=37.5) {
            System.out.println("发烧了");
        }else{
            System.out.println("体温正常");
        }
    }
}

if-else if-else多分支-示例

public class Hello {
    public static void main(String[] args) {
        float temperature;
        Scanner input = new Scanner(System.in);//定义input对象，用于接收控制台输入
        System.out.println("请输入当前测量的温度值：");
        temperature = input.nextFloat();//使用变量temperature接收输入
        if (temperature >= 37.5) {
            System.out.println("发烧了");
        } else if (temperature <= 30) {
            System.out.println("体温异常");
        } else {
            System.out.println("体温正常");
        }
    }
}

switch分支-示例

//Week.java
/*查日期*/
import java.util.Scanner;

public class Week {
    public static void main(String[] args) {
        int day;
        Scanner input=new Scanner(System.in);
        System.out.println("请输入星期数（0-6）");//这部分有相关的方法直接使用，能理解就行
        day=input.nextInt();
        switch (day){
            case 0:
                System.out.println(day+"表示今天周日");
                break;//一般这部分不能漏写，和C语言一样，会导致代码运行到下一个break之前
            case 1:
                System.out.println(day+"表示今天周一");
                break;
            case 2:
                System.out.println(day+"表示今天周二");
                break;
            case 3:
                System.out.println(day+"表示今天周三");
                break;
            case 4:
                System.out.println(day+"表示今天周四");
                break;
            case 5:
                System.out.println(day+"表示今天周五");
                break;
            case 6:
                System.out.println(day+"表示今天周六");
                break;
            default://默认输出
                System.out.println("无效输入");
        }
        input.close();//关闭输入
    }
}

循环结构

【这部分就是while循环、for循环、do-whole循环，和C语言差不多】
【while循环和for循环可以相互转换；do-whole循环会至少进行一次运行，属于运行后判断】

//Text1.java
/*计算从1累加到100的和?*/
public class Text1 {
    public static void main(String[] args) {
        int i = 1;
        int s = 0;
        //while循环
        int s1=0;
        while (i <= 100) {//判断
            s1 = s + i;
            i++;//这个在考试中一般会考用法特点
        }
        System.out.println("s=" + s1);

        //for循环
        int s2=0;
        for (int j = 0; j <= 100; j++) {
            s2=s+j;
        }
        System.out.println("s=" + s2);
        
        //do-while循环
        /*猜数字小游戏*/
        Scanner input = new Scanner(System.in);
        int n1=(int)(Math.random()*100);//系统生成随机数1-100
        int n2;
        do {
            System.out.println("输入你猜测的数字：");
            n2 = input.nextInt();
            if (n1 < n2) {
                System.out.println("猜大了");
            } else if (n1>n2) {
                System.out.println("猜小了");
            }else {
                System.out.println("猜对了");
            }
        }while (n1!=n2);
        input.close();
    }
}

拓展：break和continue的区别

break:提前结束循环，后面循环不执行

continue:跳过、结束本次循环，后面循环继续执行

数组

【这部分和C语言编程语言也是差不多的，一维数组、二维数组、三维数组】
【数组是具有相同数据类型的数据的集合，意味着一个数组中每个数据都是同一种数据类型】

数组的定义方法：

一维数组：
int 数组名[数据数];
或：
int[数据数] 数组名
二维、三维数组的定义也差不多：
二维数组：int 数组名[数据数-y][数据数-x];
三维数组：int 数组名[数据数-z][数据数-y][数据数-x];
（这里数组有些记不清了，回头我在查一查，代码格式是这样的）

一维数组-示例：

//Array1.java
public class Array1 {
    public static void main(String[] args) {
        int a[];
        a = new int[10];//定义数组
        int i;
        for (i = 0; i < 10; i++) {//对a数组进行赋值
            a[i] = i * i;
        }
        for (i = 0; i <10 ; i++) {//输出a数组中的所有元素
            System.out.println("a["+i+"]="+i*i);
        }
    }
}

二维数组-示例：

//Array2.java
public class Array2 {
    public static void main(String[] args) {
        char[][] a;
        a=new char[4][10];//定义字符类型数组
        a[0][0]=65;
        a[1][0]=67;
        a[2][0]=69;
        a[3][0]=71;
        for (int i = 0; i < a.length; i++) {//这里的a.length是用于获取a数组的长度
            for (int j = 0; j < a[i].length-1; j++) {
                a[i][j+1]=(char) (a[i][j]+1);
            }
        }
        for (int i = 0; i < a.length; i++) {//这里的a.length是用于获取a数组的长度
            for (int j = 0; j < a[i].length; j++) {
                System.out.print(a[i][j]);
            }
            System.out.println();
        }
    }
}

三维数组-示例：

    在Java中，三维数组是数组的数组的数组。
    它可以用于存储多维数据，例如图像、视频或其他复杂数据结构。
    三维数组的每个元素都是一个二维数组，而每个二维数组的元素又是一个一维数组。
    三维数组【类别空间坐标系】：int 数组名[数据数-z][数据数-y][数据数-x];

/*办公室工位：2层楼，每层3排，每排4个工位*/
public class Test3DArray {
    public static void main(String[] args) {
        // 1. 声明并创建：2层楼，每层3排，每排4个座位
        // 坐标系映射：office[Z][Y][X]
        int[][][] office = new int[2][3][4];

        // 2. 给某个特定工位赋值（坐标定位法）
        // 第2层楼（Z=1），第3排（Y=2），第4个座位（X=3） 坐员工号 10086
        office[1][2][3] = 10086;
        
        // 再随意给几个位置赋值，让打印效果更明显
        office[0][0][0] = 11;  // 1层，1排，1座
        office[0][1][2] = 22;  // 1层，2排，3座
        office[1][0][1] = 33;  // 2层，1排，2座

        // 3. 完整遍历整个“办公大楼”（逐层、逐排、逐座扫描）
        System.out.println("=== 办公楼工位分布图 ===");
        for (int z = 0; z < 2; z++) {          // 遍历楼层（Z轴）
            System.out.println(">>> 第 " + (z + 1) + " 层：");
            
            for (int y = 0; y < 3; y++) {      // 遍历排数（Y轴）
                System.out.print("  第 " + (y + 1) + " 排: ");
                
                for (int x = 0; x < 4; x++) {  // 遍历座位（X轴）
                    // 打印每个座位的工号，\t是为了对齐表格
                    System.out.print(office[z][y][x] + "\t");
                }
                System.out.println(); // 换下一排
            }
            System.out.println("---------------------");
        }
    }
}

【到这里基本上把Java基础代码结构理解了，其他编程语言这些基础逻辑都差不多】

Java面向对象（OOP）——基础概念

【Java是一门面向对象的编程语言】

类与对象

【对象指的是类的一个具体实例，它包含了属性和行为。比如一条狗是一个对象】
【类是一群对象共同属性和行为的一个抽象。类是对象的模板，对象是类的实例】

面向对象基本特性

封装性

把对象的属性和行为封装起来，通过方法访问属性，实现细节的对外隐藏

补充：【访问修饰符可以控制属性和方法的访问级别，实现封装性】

继承性

可以使子类继承父类的属性和方法，建立类的层次结构。

多态性

让子类的对象可以作为父类的对象使用，根据实际对象调用方法
补充：【子类重写父类的方法用于实现多态，调用时会进行动态绑定】

Java面向对象（OOP）——正文部分

类的定义

//示例一
//Hello.java
public class Hello {//类
    public static void main(String[] args) {//有主函数
        System.out.println("Hello World");//语句
    }
}

//示例2
//HelloPer.java
class Person {
    //属性（成员变量）(创建引用)
    String name;
    int age;

    //方法（成员方法）(构造方法)
    public void sayHello() {
        System.out.println("你好，我叫" + name + "，今年" + age + "岁。");
    }
}

public class HelloPer {
    public static void main(String[] args) {
        //创建Person1对象，实例化Person1
        Person person1 = new Person();//分配内存空间
        person1.name = "张三";
        person1.age = 25;

        //调用对象的方法
        person1.sayHello();

        //创建Person2对象，实例化Person2
        Person person2 = new Person();//分配内存空间
        person2.name = "李四";
        person2.age = 30;

        //调用对象的方法
        person2.sayHello();
    }
}

类的成员

-成员变量（属性）
-实例变量
-类变量
-成员方法
-实例方法
-类方法
-构造方法

成员变量

在面向对象编程中，成员变量是用于存储对象状态和数据的属性。在Java中，成员变量可分为 实例变量和类变量

//成员变量示例
package demo7_3;

class Circle {
    //实例变量
    double radius;//圆的半径
    String color;//颜色
    boolean filled;//是否填充
}

public class Main {
    public static void main(String[] args) {
        //创建Circle对象
        Circle circle1 = new Circle();

        //设置实例变量的值
        circle1.radius = 5.0;
        circle1.color = "红色";
        circle1.filled = true;

        //打印实例变量的值
        System.out.println("圆的半径：" + circle1.radius);
        System.out.println("圆的颜色：" + circle1.color);
        System.out.println("圆是否填充：" + circle1.filled);
    }
}

成员方法

在面向对象编程中，类的成员方法是类中用于执行特定操作的函数或方法。成员方法定义了类的行为和功能，并可以通过创建对象来调用或使用。
在Java中，成员方法分为 实例方法和类方法（静态方法）

class Rectangle {
    //实例变量
    double length;//矩形长
    double width;//矩形宽

    //实例方法，计算矩形面积
    public double calculateArea() {
        return length * width;
    }

}

public class Main {
    public static void main(String[] args) {
        //创建两个对象
        Rectangle rectangle1=new Rectangle();
        rectangle1.length=5.0;
        rectangle1.width=3.0;
        
        Rectangle rectangle2=new Rectangle();
        rectangle2.length=4.0;
        rectangle2.width=5.0;
        
        //计算面积
        double area1=rectangle1.calculateArea();
        double area2=rectangle2.calculateArea();
        
        //打印结果
        System.out.println("矩形1面积"+area1);
        System.out.println("矩形2面积"+area2);
    }
}

方法重载

方法重载是指在同一个类中定义多个方法名相同，但是参数列表不同的方法。
重载可以使用相同的方法名做不同的事情。

方法重载最大的好处是可以让同一个方法名具有不同的功能，使代码更加简洁。
重载将统一操作的不同版本结合在一起，使程序更容易使用和维护。

class MathUtils {
    //方法重载示例1：计算两个整数的和
    public int add(int num1, int num2) {
        return num1 + num2;
    }

    //方法重载示例2：计算两个浮点数的和
    public double add(double num1, double num2) {
        return num1 + num2;
    }

    //方法重载示例3：计算三个整数的和
    public int add(int num1, int num2, int num3) {
        return num1 + num2;
    }
}

public class Main {
    public static void main(String[] args) {
        MathUtils utils = new MathUtils();//分配内存空间

        //调用方法
        int sum1 = utils.add(5, 10);//方法重载示例1
        double sum2 = utils.add(3.5, 2.0);//方法重载示例2
        int sum3 = utils.add(1, 2, 3);//方法重载示例3
    }
}

构造方法

构造方法是一种特殊的方法，用于初始化对象的状态。

构造方法的作用

(1)初始化对象状态，如成员变量赋初始值。

(2)加载配置文件，如从属性文件中读取初始化参数。

构造方法与普通方法的区别

(1)构造方法的名称必须和类名完全相同，而普通方法可以任意命名。

(2)构造方法不需要返回值类型，也不写void，普通方法都需要返回值。

(3)构造方法在创建对象时自动调用，普通方法需要手动调用。

(4)构造方法不能被继承，子类不能继承父类的构造方法。

(5)构造方法可以被重载，重载时可以通过参数列表区分。

【合理使用构造方法，可以提高代码质量，正确初始化对象】

class Person {
    //实例变量
    String name;
    int age;

    //构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person("Alice", 25);
        Person person2 = new Person("Bob", 30);
    }
}

默认构造方法

在Java类中，当没有显示定义任何构造方法，编译器会自动提供一个默认的构造方法。
这个构造方法没有参数，且不执行任何操作，仅仅保证对象实例化能够顺利进行。

public class Person{
    String name;
    int age;
    
    //默认构造方法（编译器自动添加）
    public Person(){}
}

构造方法的重载

构造方法重载指一个类中有多个参数不同的构造方法。主要用于以下场景：
1.根据不同参数创建不同状态的对象
2.可以根据需要来选择不同的构造方法，避免频繁设置属性，提高代码的灵活性。

package domo7_3_6;

class Rectangle {
    double length;
    double width;

    //无参构造方法
    public Rectangle() {
        this.length = 0.0;
        this.width = 0.0;
    }

    //构造方法重载：带两个参数
    public Rectangle(double length, double width) {//矩形
        this.length = length;
        this.width = width;
    }

    //构造方法重载：带一个参数
    public Rectangle(double side) {//正方形
        this.length = side;
        this.width = side;
    }
}

public class Main {
    public static void main(String[] args) {
        Rectangle rectangle1 = new Rectangle();
        Rectangle rectangle2 = new Rectangle(5.0, 3.0);
        Rectangle rectangle3 = new Rectangle(4.0);
    }
}