寒假实训 Day03

最新推荐文章于 2024-09-15 19:46:31 发布

C17200

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量804

点赞数 24

分类专栏： Java语言文章标签： java

本文链接：https://blog.csdn.net/c1720058538/article/details/135813005

版权

Java语言专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、数组和面向对象

1、一维数组

变量:

在java程序中，当需要存储单个数据内容时，需要声明一个变量，声明变量的本质就是在内存空间中申请一块存储单元

概念:

在java程序中，当需要存储多个数据类型相同的内容时，则需要声明一个数组。声明数组的本质，就是在内存中申请一段连续的存储单元。

数组中的名词:

声明变量 : 数据类型变量名 = 初始值

数组名:数组中变量的名称
数组的长度: 数组名.length;
数组中的元素:数组当中值
数组角标(下标):数组的下标从0开始，ArrayindexOutOfBoundException 数组下标越界异常

声明数组的格式:

数据类型 [ ] 数组名 = new 数据类型 [ 数组的长度 ]；
例如 : 定义一个长度为3的 int 类型的一维数组
int arr = new int[3]; // 动态的定义数组[推荐]
int arr1 = new int[ ] (1,2,3); // 静态的定义数组

package Test_01_24_1;
/**
 * @Author: CYQ
 * @Date: 2024/1/24 8:26
 */
public class ArrayDemo02 {
    public static void main(String[] args) {
        //声明数组
        int [] arr = new int[20];
        //数组遍历
        for(int i = 0; i < arr.length; i++){
            System.out.println(arr[i]);
        }
    }
}

数组的初始化:

  注意 : 在数组声明时，如果不给数组直接赋值，那么，byte/short/int/long/的默认值为0，float和double的默认值为0.0，特别需要注意的是布尔类型的默认值为false;
char 的默认值? // 0或者 \u0000[Unicode编码]
         练习: 双色球案例
         共7个号码，其中红球6个，范围1-33，蓝球1个范围是1-17

package Test_01_24_1;
import java.util.Random;
/**
 * @Author: CYQ
 * @Date: 2024/1/24 8:39
 */
public class DoubleColorBall {
    //共7个号码，其中红球6个，范围1-33，蓝球1个 范围是1-17
    public static void main(String[] args) {
        //声明一个int类型  长度为7的一维数组，动态
        int [] arr = new int[7];
        //创建一个随机数对象
        Random random = new Random();

        //开始摇号（向数组当中去添加值），需要先摇6红球  范围1-33
        for(int i = 0; i < arr.length-1; i++){
            //红球
            arr[i] = random.nextInt(33)+1;
        }

        //蓝球
        arr[arr.length-1] = random.nextInt(17)+1;

        //将数组中的双色球遍历
        System.out.println("本期中奖结果是：");
        for(int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + "  ");
        }
    }
}

上述代码，运行多次，会出现重复数字，以下是优化代码：

package Test_01_24_1;
import java.util.Random;
/**
 * @Author: CYQ
 * @Date: 2024/1/24 8:39
 */
public class DoubleColorBall {
    //共7个号码，其中红球6个，范围1-33，蓝球1个 范围是1-17
    public static void main(String[] args) {
        //声明一个int类型  长度为7的一维数组，动态
        int [] arr = new int[7];
        //创建一个随机数对象
        Random random = new Random();

        //开始摇号（向数组当中去添加值），需要先摇6红球  范围1-33
        for(int i = 0; i < arr.length-1; i++){
            //红球
            arr[i] = random.nextInt(33)+1;
            //去重
            for(int j = i-1; j >= 0; j--){
                //表示号码重复了
                if(arr[i] == arr[j]){
                    //若号码出现重复，需要重新摇号
                    i--;
                    break;
                }
            }
        }
        //蓝球
        arr[arr.length-1] = random.nextInt(17)+1;

        //将数组中的双色球遍历
        System.out.println("本期中奖结果是：");
        for(int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + "  ");
        }
    }
}

二、面向对象

什么是对象?
万事万物管对象
什么是面向对象?
面向对象的本质就是分析事物的特征《名词)和行为《动词)
什么是面向对象编程?
先用面向对象的思想进行分析，再用面向对象的语言进行翻泽的过程

类、对象、引用的基本概念

对象 : 在java中，对象是指客观存在的实体
语法格式 : new 引用数据类型();

案例：
new Person(); // 表示创建一个Person类型的对象

类 : 简单来说类就是“分类”，是指具有相同特征和行为的多个事物共性的抽象，在java中表现为一种引用教据类型，其中包含描述特征的成员变量和描述行为的成员方法。
语法格式:
[权限修饰符] class 类名{
类体；
}

案例:
class Person{
类体;

}

注意:

通常情况下，类名的首字母要大写，当类名由多个单词构成时，每个单词的首字母都要大写;

[大驼峰命名法]

成员变量(特征、属性)
语法格式
[权限修饰] 数据类型成员变量 = 成员变量值
其中等号和成员变量值可以省略，通常情况下都合格，分号不可以省略
案例:
int age = 3；
private String name；

注意:

通常情况下，成员变量的首字母要小写，当成员变量各由多个单词构成时，从第二个单词开始，首字母要大写;

[小驼峰命名法 lowerCamelCase]

引用:引用类型的成员变量名，简称“引用”
语法格式: 引用数据类型引用变量名 = new 引用数据类型()；

案例:
Person p = new Person() ; // 表示创建一个Person类型的引用 p指向Person类的对象
引用的使用方法: 引用名.成员变量名 = 成员变量值:
注意:当一个类被定义完毕后，可以使用new关键字来创建该类的对象，这个过程被称为类的实例化

类是对象的抽象，对象是类的实现。

案例 : 定义一个坐标类，特征有，横坐标x和纵坐标y
创建坐标类的对象，将对象的信息打印出来，修改特征信息，并再次打印。

package Test_01_24_1;

/**
 * @Author: CYQ
 * @Date: 2024/1/24 10:12
 */
public class Point {
    int x;
    int y;

    public static void main(String[] args) {
        //创建一个Point类型的引用 point ， 指向Point 类型的对象
        Point point = new Point();
        System.out.println("x = " + point.x);
        System.out.println("y = " + point.y);

        point.x = 3;
        point.y = 4;
        System.out.println("x = " + point.x);
        System.out.println("y = " + point.y);
    }
}

练习1:自定义Phone类，特征有: 品牌和价格，行为有: 打印品牌和价格的方法
要求在main()方法声明Phone类型的引用指向Phone类型的对象并打印特征
将品牌和价格修改为“Nokia”和598后再次打印

package Test_01_24_1;

/**
 * @Author: CYQ
 * @Date: 2024/1/24 10:46
 */

/**
 * 自定义Phone类，特征有: 品牌和价格，行为有: 打印品牌和价格的方法
 * 要求在main()方法声明Phone类型的引用指向Phone类型的对象并打印特征
 * 将品牌和价格修改为“Nokia”和598后再次打印
 */
public class Phone {
    String brand;
    double price;
    public void show(){
        System.out.println("品牌：" + brand + "，价格：" + price);
    }
    public static void main(String[] args) {
        Phone p = new Phone();
        p.show();
        p.brand = "Nokia";
        p.price = 598;
        p.show();
    }
}

练习2:编程实现Person类的定义，特征有: 姓各和年龄
要求在=main方法声明Person类型的引用指向Person类型的对象并打印特征，再将姓名和年龄修改为"zhangfei"和30后再次打印

package Test_01_24_1;

/**
 * @Author: CYQ
 * @Date: 2024/1/24 10:59
 */

/**
 * 要求在=main方法声明Person类型的引用指向Person类型的对象并打印特征
 * 再将姓名和年龄修改为"zhangfei"和30后再次打印
 */
public class Person {
    String name;
    int age;
    public void show(){
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
    public static void main(String[] args) {
        Person p = new Person();
        p.show();
        p.name = "zhangfei";
        p.age = 30;
        p.show();
    }
}

成员方法(行为):

语法格式：

[权限修饰符] 返回值类型成员方法名(形参数据类型1 形参变量名1，....，形参数据类型n 形参变量名n){
方法体;
}

构造方法:
静态方法:
普通方法:

返回值类型：

返回值 : 是指从方法体内向方法体外返回的数据内容
返回值类型 : 返回值的数据类型
案例:
要返回66，返回值类型为int
要返回3.14，返回值类型为 double
要返回“嘿嘿”，返回值类型为String
要返回true或者false，返回值类型为boolean
要返回数据内容，可以使用return 关键字，将其返回并结束方法体。
注意:通常情况下，方法名的首字母要小写，方法名由多个单词构成时，从第二个单词开始，首字母要大写

形参列表：

形式参数:是指从方法体外向方法体内，传递数据内容
形参列表:形式参数可以有多个
语法格式: 成员方法名(形参数据类型1 形参变量名1，....，形参数据类型n 形参变量名n)
注意:如果一个方法不需要返回任何内容，那么返回值就写void，如果一个方法不需要传入任何内容则形参列表啥也不写
案例:

public void show () {
    System.out.println("方法体内是描述该方法的作用”);
}
class MathDemo{

    public int add(int a, int b){
        return a + b;
    }
    public static void main(String [] args){
        MathDemo md = new MathDemo ();
        md.add(1,2);
        System.outprintln("方法执行完，该我了!");
    }
}

成员方法体

方法体本质上就是用来描述该方法的功能

方法的调用

语法格式:引用变量名.方法名(实参列表);
注意:实参就是对形参进行初始化操作，所以实参列表的类型，顺序，个数，必须和形参列表保持一致
方法调用的本质就是找到方法名，然后跳转到方法中，当方法体执行完毕后再跳转回来。

案例:
练习1:编程实现Girl类的定义，特征有:姓名、年龄、是否有男朋友bf，行为有:打印所有特征的方法，要求在main方法中声明Girl类型的引用指向Girl类型的对象并打印特征，然后修改特征为 “貂蝉”、18以及true后再次打印

package Test_01_24_1;

/**
 * @Author: CYQ
 * @Date: 2024/1/24 11:19
 */

/**
 * 编程实现Girl关的定义，特征有:姓名、年龄、是否有男朋友bf
 * 行为有:打印所有特征的方法
 * 要求在main方法中声明Girl类型的引用指向Girl类型的对象并打印特征
 * 然后修改特征为 ”、18以及true后再次打印
 */
public class MethodDemo02 {
    String name;
    int age;
   boolean bf;
   public void print(){
       System.out.println("姓名：" + name + "  年龄：" + age + "  有没有男朋友：" + bf);
   }

    public static void main(String[] args) {
        MethodDemo02 m = new MethodDemo02();
        m.print();
        m.name = "貂蝉";
        m.age = 18;
        m.bf = true;
        m.print();
    }
}

练习2:自定义成员方法实现将姓名修改为参数指定的数值
自定义成员方法实现将年龄修改为参数指定的数值
自定义成员方法实现将是否有男朋友修改为参数指定的数值
自定义成员方法实现姓名的获取并返回
自定义成员方法实现年龄的获取并返回
自定义成员方法实现是否有男朋友的获取并返回

练习3:自定义Girl类，特征有姓名、年龄、是否有男朋友bf,行为有打印特征的方法
自定义修改特征的方法
自定义获取特征的方法
要求在main方法中创建Girl类的对象，打印特征
通过自定义方法进行设置姓名、年龄、是否有男朋友，再次打印

构造方法和方法重载

语法格式:

[权限修饰符] 构造方法名[类名](形参列表){
构造方法体
}

案例:
public class Person{
   String name.
   int age;
   public Person0{} //无参构造方法
   public Person(String name, int age){}//全参构造方法
}

注意事项:

a.构造方法名与类名完全相同并且没有返回值类型，连void都不许有;
b.当使用new关键字创建对象时会自动调用构造方法来实现成员变量的初始化工作;

默认构造方法:

a.当一个类中没有定义任何构造方法时，编译器会自动添加一个无参空构造方法，叫做默认/缺省构造方法，如:
Person(){}
b.若类中出现了构造方法，则编译器不再提供任何形式的构造方法

方法重载(会用即可):

(1)基本概念: 在java语言中若方法的名称相同，但参数列表不同，这样的方法之间构成重载关系(Overload)
(2)体现形式：方法重载的主要形式体现在:参数的个数不同、参数的类型不同、参数的顺序不同，与返回值类型和形参变量名无关，但建议返回值类型最好相同。
判断方法能否构成重载的核心: 调用方法时能否加以区分
(3)实际意义：方法重载的实际意义在于调用者只需要记住一个方法名就可以调用各种不同的版本，来实现各种不同的功能

如:

boolean b1 = true;
System.out.println(b1);
int i1 = 66;
System.out.println(i1);
double d1 = 3.14;
System.out.println(d1);
int add(int x; int y){}
int add (double x,double y){}
int add(String str){}
int add(String str1,String str2,int x)

练习:编程实现Point类，特征有:横坐标和纵坐标(整数);
行为有:无参构造方法，有参构造方法、打印所有特征的方法
要求:在main方法中分别使用无参方式和有参方式构造对象并打印特征自定义成员方法实现横坐标增加1的行为 ;自定义成员方法实现纵坐标增长参数指定数值的行为

综合练习:
1.创建一个圆Circle类，为该类提供一个变量r表示半径，一个常量Pi表示圆周率，同时为该类提供两个方法:方法一用于求圆的面积，方法二用于求圆的周长，为该类提供一个构造方法，用于初始化r的值为4。

在main方法中测试。

2.请定义一个交通工具(Vehicle)的类，其中有:
属性: 速度(speed)，车的类型(type)等等
方法: 移动(move0)，设置速度(setSpeed(double s))，加速speedUp(double s),减速speedDown(double s等等
最后在测试类Vehicle中的main()中实例化一个交通工具对象，并通过构造方法给它初始化speed,type的值，并且打印出来，另外，调用加速，减速的方法对速度进行改变。

3.定义一个矩形类Rectangle:
定义三个方法: getArea0求面积、getPer0求周长，showA0分别在控制台输出长、宽、面积、周长。
有2个属性: 长length、宽width 通过构造方法Rectangle(int width, int length)，分别给两个属性赋值创建一个Rectangle对象，并输出相关信息。

4.自定义Car类，特征有:品牌(brand)、颜色(color)、价格(price)，
行为有: 无参构造、三个参数的构造、打印所有特征的行为、获取品牌并返回的行为、获取颜色并返回的行为、获取价格并返回的行为、设置品牌为参数指定的数值、设置颜色为参数指定的数值、设置价格为参数指定的数值、实现价格增长1000元的行为、实现价格增长参数指定数值的行为。
要求在main()方法中使用无参形式构造对象打印特征，再使用有参形式构造对象打印特征，并使用有参形式构造的对象调用其他方法测试

面向对象三大特征

this关键字(原理、理解)

基本概念:

在构造方法中和成员方法中访问成员变量时，编译器会加上this.的前缀，而this.相当于汉语中 "我的"，当不同的对象调用同一个方法时，由于调用方法的对象不同导致this关键字不同，从而this. 方式访问的结果也就随之不同。

使用:

(1)当形参变量名与成员变量名相同时，在方法体中会优先使用形参变量(就近原则)，若希望使用成员变量，则需要在成员变量的前面加上this.的前缀，明确要求该变量是成员变量。 (2)在构造方法的第一行可以使用this()的方式来调用本类中的其它构造方法(了解)。

封装

基本概念

通常情况下可以在测试类给成员变量赋值一些合法但不合理的数值，无论是编译阶段还是运行阶段都不会报错或者给出提示，此时与现实生活不符。为了避免上述错误的发生，就需要对成员变量进行密封包装处理，来隐藏成员变量的细节以及保证成员变量数值的合理性，该机制就叫做封装。

实现流程

(1)私有化成员变量，使用private关键字修饰;

(2)提供公有的get和set方法，并在方法体中进行合理值的判断;

(3)在构造方法中调用set方法进行合理值的判断;

实体类的封装：

在项目开发中，通常com.XXXX.bean; com.XXXX.domain; com.XXXX.entity; com.XXXX.pojo 这些包当中通常情况下存放的都是实体类。

实体类封装的步骤：

1.私有化成员变量；

2.提供公有的get/set方法

3.提供无参/有参/全参的构造方法

4.重写toString()、equals和hashCode()

案例：编程实现Person类的封装，特征有：姓名、年龄、国籍，要求提供打印所有特征的方法。

编程实现PersonTest类，在main方法中使用有参方式创建两个Person类型的对象并打印特征。

练习：编程实现Car类的封装，特征有：品牌和价格，要求提供打印所有特征的行为。

所有类统一放到com.jzxy.bean

练习1：

编程实现用户类（User）的封装

特征有：

//用户编号

int id;

//用户姓名

String name;

//年龄

int age;

//城市

String city;

//详细住址

String address;

//邮箱

String email;

//电话

String phone;

//微信

String weixin;

//qq

String qq;

//微博

String weibo;

//性别

String sex;

//简介

String description;

提供公有的set和get方法，无参构造方法，重写toString方法和equals方法

有参(String name, int age, String city, String address, String email, String phone, String weixin, String qq, String weibo, String sex, String description)

有参(int id, String name, int age, String city, String address, String email, String phone, String weixin, String qq, String weibo, String sex, String description)

练习2：

编程实现工作类（Work）的封装

特征有：

int id;

int userId;

String start;

String end;

String company;

String job;

String description;

Work next;

提供公有的set和get方法，全参和无参构造方法，重写toString方法和equals方法

有参(int id, String name, int age, String city, String address, String email, String phone, String weixin, String qq, String weibo, String sex, String description)

有参(int userId, String start, String end, String company, String job, String description)