跟着野码哥学javaDay 3_自定义圆形类特征有横纵坐标半径-CSDN博客

本文链接：https://blog.csdn.net/m0_74697366/article/details/135830062

练习1
import java.util.Random;

public class DoubleColorBall {
    public static void main(String[] args) {
        int[] arr = new int [7];
        //创建一个随机数对象
        Random random = new Random();
        //开始摇号
        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.println(arr[i] + "");
        }
    }
}

练习2
public class Point {
    int x;
    int y;
    public static void main(String[] args) {
        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);
    }
}

练习3
public class Phone {
    /*public Phone(){
        System.out.println("我是无参构造，正在被调用");
    }*/
    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 = "NIKE";
        p.price = 600.0;
        p.show();

    }
}
练习4

import java.util.Scanner;
    public class TestDemo01 {

        public static void main(String[] args) {
            // 创建一个Scanner对象
            Scanner sc = new Scanner(System.in); // 创建对象
            System.out.println("请输入圆的半径为：");
            int radius = sc.nextInt(); // 接收数据

            // 创建Circle对象
            Circle c = new Circle();
            // 对半径进行赋值
            c.setR(radius);

            // 调用方法
            c.getArea();
            c.getGirth();

        }

    }

    // 1.创建一个Circle类.
    class Circle {
        // 成员变量
        private int r; // 变量可以Scanner输入数据
        private double PI = 3.14; // double接收

        // 构造方法（无参构造方法）
        public Circle() {
            // TODO Auto-generated constructor stub
        }

        // 定义一个setR方法将来用来对半径赋值
        public void setR(int r) {
            this.r = r;
        }

        // 定义一个getArea方法将来求圆的面积
        public void getArea() {
            System.out.println("圆的面积为：" + (PI * r * r));
        }

        // 定义一个getGirth方法将来求圆的面积
        public void getGirth() {
            System.out.println("圆的周长为：" + (2 * PI * r));
        }
    }
练习5

/*
 * 定义一个交通工具(Vehicle)的类其中有: 属性速度(speed)体积(size)等等
 * 方法移动(move())设置速度(setSpeed(int speed))加速speedUp(),减速speedDown()等等.
 * 最后在测试类Vehicle中的main()中实例化一个交通工具对象并通过方法给它初始化speed,size的值并且打印出来。
 * 另外调用加速减速的方法对速度进行改变。
 */
public class Vehicle {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle(12, 1000);
        System.out.println(vehicle);
        vehicle.speedUp();
        System.out.println("加速后："+vehicle);
        vehicle.speedDown();
        System.out.println("减速后："+vehicle);
    }

    private double speed;
    private double size;

    public Vehicle() {
        super();
    }

    public Vehicle(double speed, double size) {
        super();
        this.speed = speed;
        this.size = size;
    }

    public double getSpeed() {
        return speed;
    }

    public void setSpeed(double speed) {
        this.speed = speed;
    }

    public double getSize() {
        return size;
    }

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

    public void move() {

    }

    public void speedUp() {
        speed++;
    }

    public void speedDown() {
        speed--;
    }

    @Override
    public String toString() {
        return "Vehicle [speed=" + speed + ", size=" + size + "]";
    }
}
练习6

/*定义一个矩形类Rectangle:
        21
        22
        定义三个方法:getArea()求面积、getPer()求周长，showA11()分别在控制台输出长、宽、面积、周长。
        23
        24
        25
        26
        27
        28
        有2个属性:长length、宽width通过构造方法Rectangle(int width，int length)，分别给两个属性赋值创建一个Rectangle对象，并输出相关信息
        三个
        */

class Rectangle{
    private int length;
    private int width;
    //构造方法
    Rectangle(int length,int width){
        this.length=length;
        this.width=width;
    }
    //控制台显示长,宽,面积,周长
    public void showAll(){
        System.out.println("矩形长为:"+length+"\t"+"矩形的宽为:"+width+"\t"+"矩形的面积为:"+getArea()+"\t"+"矩形的周长为:"+getPer());
    }
    //求周长
    public int getPer(){
        return 2*(length+width);
    }
    //求面积
    public int getArea(){
        return length*width;
    }
    //
}
class RectangleDemo{
    public static void main(String[] args){
        Rectangle r=new Rectangle(2,3);
        r.showAll();
    }
}
练习7

public class MethodDemo01 {
    public int add(int a,int b) {
        return a + b;

    }
    public static void main(String[] args) {
        MethodDemo01 m = new MethodDemo01();
        int sum = m.add(1,2);
        System.out.println("sum=" + sum);
    }
}

Day04 面向对象三大特征

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)

练习3：

编程实现教育类（Edu）的封装

特征有：
    int id;
    int userId;
    String start;
    String end;
    String school;
    String study;
    String description;
    Edu next;
提供公有的set和get方法，全参和无参构造方法，重写toString方法和equals方法
有参(int userId, String start, String end, String school, String study, String description)
有参(int id, int userId, String start, String end, String school, String study, String description)

练习4：

编程实现信息类（Info）的封装

特征有：
    User user;
    Edu edu;
    Skill skill;
    Work work;
    Specialty specialty;
提供公有的set和get方法，全参和无参构造方法，重写toString方法和equals方法

练习5：

编程实现结果类（Result）的封装

特征有：
    int status;
    String msg;
    Object data;
提供公有的set和get方法，全参和无参构造方法，重写toString方法和equals方法
有参(int status, String msg)
有参(int status, String msg)
并增加：
    public String toJSON(){
        return JSON.toJSONString(this);
    }

练习6：

编程实现技能类（Skill）的封装

特征有：
    int id;
    int userId;
    String keyWords;
提供公有的set和get方法，全参和无参构造方法，重写toString方法和equals方法
有参(int userId, String keyWords)

练习7：

编程实现特长类（Specialty）的封装

特征有：
    int id;
    int userId;
    String name;
    String description;
    Specialty next;
提供公有的set和get方法，全参和无参构造方法，重写toString方法和equals方法
有参(int userId, String name, String description) 
有参(int id, int userId, String name, String description)

部分课堂笔记（摘抄）：

继承

发生在父子之间父类（基类）

人类：

特征：姓名、年龄行为：吃饭、娱乐学生类特征：姓名、年龄、学号行为：吃饭、娱乐、学习教师类特征：姓名、年龄、工号行为：吃饭、娱乐、讲课工人类特征：姓名、年龄、薪水行为：吃饭、娱乐、工作

人类：

特征：姓名、年龄行为：吃饭、娱乐学生类吸收人类：特征：学号行为：学习教师类吸收人类：特征：工号行为：讲课工人类吸收人类：特征：薪水行为：工作 ...

公共类中已有特征和行为而在多个类型只需要编写自己独有特征和行为的机制，叫做继承。使用继承提高了代码的复用性，可维护性以及扩展性。在Java语言中使用extends(扩展)关键字来表示继承关系。

java 只支持单继承，可以有多重继承，一个子类只能有一个父类，而一个父类可以有多个子类（简单来说就是一个孩子一个爹，一个爹可以有多个孩子）

注意：子类 is a 父类

如： public class Worker extends Person{} - 表示Worker类继承自Person类其中Person类叫做超类、父类、基类。其中Worker类叫做派生类、子类、孩子类。

1.2 注意事项

(1)子类不能继承父类的构造方法和私有方法，但私有成员变量可以被继承只是不能直接访问。 (2)无论使用何种方式构造子类的对象时都会自动调用父类的无参构造方法，来初始化从父类中继承的成员变量，相当于在构造方法的第一行增加代码：super()的效果。 (3)使用继承必须满足逻辑关系：子类 is a 父类，也就是不能滥用继承。 (4)Java语言中只支持单继承不支持多继承，也就是说一个子类只能有一个父类，但一个父类可以有多个子类。

方法的重写(Override)

方法的重载（方法名相同,参数类型，个数，顺序不同）

(1)基本概念从父类中继承下来的方法不满足子类的需求时，就需要在子类中重新写一个和父类一样的方法来覆盖从父类中继承下来的版本，该方式就叫做方法的重写。

(2)重写的原则 a.要求方法名相同、参数列表相同以及返回值类型相同，从jdk1.5开始允许返回子类类型。 b.要求方法的访问权限不能变小，可以相同或者变大。 c.要求方法不能抛出更大的异常(异常机制)。

练习：编程实现Animal类的封装，特征有：名字和毛色，要求提供打印所有特征的方法。编程实现Dog类的封装并继承自Animal类，该类的特征有：牙齿数量，要求提供打印所有特征的方法编程实现DogTest类，在main方法中分别使用无参和有参方式构造Dog类型对象并打印特征。

2.访问权限 2.1 常用的访问权限

访问控制符访问权限本类内部本包中的类子类内部其它包中的类

public       公有的          ok           ok             ok           ok
protected    保护的          ok           ok             ok           no
啥也不写      默认的          ok           ok             no           no
private      私有的          ok           no             no           no

a.public修饰的成员可以在任意位置使用； b.private修饰的成员只能在本类内部使用； c.通常情况下，成员方法都使用public关键字修饰，成员变量都使用private关键字修饰；

包的声明

package 包名; - 表示声明单层包 package 包名1.包名2.包名3...包名n; - 表示多层包，为了便于管理以及解决命名冲突的问题；

练习：自定义矩形(Rect)类，特征有：横纵坐标、长度及宽度，提供无参，全参构造，set/get方法要求实现封装并提供打印方法；

自定义圆形(Circle)类，特征有：横纵坐标、半径，提供无参，全参构造，set/get方法，要求实现封装并提供打印方法；提取共性自定义图形(Shape)类，提供无参，全参构造，set/get方法。自定义ShapeTest类，自定义成员方法实现既能打印矩形又能打印圆形的方法并调用 (最后一个成员方法选做)

多态

基本概念 多态主要指同一种事物表现出来的多种形态。饮料：可乐、雪碧、乐虎、加多宝、红牛、脉动、... 宠物：猫、狗、鸟、小强、鱼、... 人：学生、教师、工人、保安、...

语法格式 父类类型引用变量名 = new 子类类型(); //父类型的引用指向子类型的对象【多态的核心】如： Person pw = new Worker();

Shape shape = new Rect();

pw.show();

练习：编程实现Person类的封装，特征有：姓名和年龄，要求提供打印所有特征的方法。编程实现Worker类的封装并继承自Person类，特征有：薪水编程实现PersonWorkerTest类，在main方法中分别创建Person和Worker类型对象并打印特征。

解析：由程序结果可知，编译阶段调用Person类中的show方法，运行阶段调用Worker类中的show方法

多态的效果 (1)当父类类型的引用指向子类类型的对象时，父类类型的引用可以直接调用父类独有的方法； (2)当父类类型的引用指向子类类型的对象时，父类类型的引用不可以直接调用子类独有的方法； (3)对于父子类都有的非静态方法来说，编译阶段调用父类版本，运行阶段调用子类重写的版本； (4)对于父子类都有的静态方法来说，编译和运行阶段都调用父类版本；

引用数据类型之间的转换 (1)引用数据类型之间的转换方式有两种：自动类型转换和强制类型转换。其中自动类型转换主要指小类型向大类型的转换，也就是子类转换为父类。其中强制类型转换主要指大类型向小类型的转换，也就是父类转换为子类。 (2)引用数据类型之间的转换必须发生在父子类之间，否则编译报错。 (3)若强转的目标类型并不是该引用真正指向的数据类型时则编译通过，运行阶段发生类型转换异常。 (4)为了避免上述错误的发生，应该在强转之前进行判断，格式如下： if(引用变量 instanceof 数据类型) - 判断引用变量指向的对象是否为后面的数据类型

实际意义 多态的实际意义在于屏蔽不同子类的差异性实现通用的编程带来不同的效果。

封装练习部分参考答案：
练习1

import java.util.Objects;

public class User {
    //用户编号
    private int id;
    //用户姓名
    private String name;
    //年龄
    private int age;
    //城市
    private String city;
    //详细住址
    private String address;
    //邮箱
    private String email;
    //电话
    private String phone;
    //微信
    private String weixin;
    //qq
    private String qq;
    //微博
    private String weibo;
    //性别
    private String sex;
    //简介
    private String description;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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 String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getWeixin() {
        return weixin;
    }

    public void setWeixin(String weixin) {
        this.weixin = weixin;
    }

    public String getQq() {
        return qq;
    }

    public void setQq(String qq) {
        this.qq = qq;
    }

    public String getWeibo() {
        return weibo;
    }

    public void setWeibo(String weibo) {
        this.weibo = weibo;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return id == user.id &&
                age == user.age &&
                Objects.equals(name, user.name) &&
                Objects.equals(city, user.city) &&
                Objects.equals(address, user.address) &&
                Objects.equals(email, user.email) &&
                Objects.equals(phone, user.phone) &&
                Objects.equals(weixin, user.weixin) &&
                Objects.equals(qq, user.qq) &&
                Objects.equals(weibo, user.weibo) &&
                Objects.equals(sex, user.sex) &&
                Objects.equals(description, user.description);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, age, city, address, email, phone, weixin, qq, weibo, sex, description);
    }

    public User() {
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", city='" + city + '\'' +
                ", address='" + address + '\'' +
                ", email='" + email + '\'' +
                ", phone='" + phone + '\'' +
                ", weixin='" + weixin + '\'' +
                ", qq='" + qq + '\'' +
                ", weibo='" + weibo + '\'' +
                ", sex='" + sex + '\'' +
                ", description='" + description + '\'' +
                '}';
    }
}

练习2

import java.util.Objects;

public class Work {
    private int id;
    private int userId;
    private String start;
    private String end;
    private String company;
    private String job;
    private String description;
    private Work next;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getUserId() {
        return userId;
    }

    public void setUserId(int userId) {
        this.userId = userId;
    }

    public String getStart() {
        return start;
    }

    public void setStart(String start) {
        this.start = start;
    }

    public String getEnd() {
        return end;
    }

    public void setEnd(String end) {
        this.end = end;
    }

    public String getCompany() {
        return company;
    }

    public void setCompany(String company) {
        this.company = company;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public Work getNext() {
        return next;
    }

    public void setNext(Work next) {
        this.next = next;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Work work = (Work) o;
        return id == work.id &&
                userId == work.userId &&
                Objects.equals(start, work.start) &&
                Objects.equals(end, work.end) &&
                Objects.equals(company, work.company) &&
                Objects.equals(job, work.job) &&
                Objects.equals(description, work.description) &&
                Objects.equals(next, work.next);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, userId, start, end, company, job, description, next);
    }

    public Work() {
    }

    public Work(int id, int userId, String start, String end, String company, String job, String description, Work next) {
        this.id = id;
        this.userId = userId;
        this.start = start;
        this.end = end;
        this.company = company;
        this.job = job;
        this.description = description;
        this.next = next;
    }

    @Override
    public String toString() {
        return "Work{" +
                "id=" + id +
                ", userId=" + userId +
                ", start='" + start + '\'' +
                ", end='" + end + '\'' +
                ", company='" + company + '\'' +
                ", job='" + job + '\'' +
                ", description='" + description + '\'' +
                ", next=" + next +
                '}';
    }
}
练习3

import java.util.Objects;

public class Edu {
    private int id;
    // 用户编号
    private int userId;
    // 开始时间
    private String start;
    // 结束时间
    private String end;
    // 学校名称
    private String school;
    // 学习内容或专业
    private String study;
    // 描述信息
    private String description;
    // 下一个教育记录（如果有的话）
    private Edu next;

    // 全参构造方法
    public Edu(int id, int userId, String start, String end, String school, String study, String description) {
        this.id = id;
        this.userId = userId;
        this.start = start;
        this.end = end;
        this.school = school;
        this.study = study;
        this.description = description;
        this.next = null; // 默认情况下，下一个教育记录为null
    }

    public Edu() {
    }

    @Override
    public String toString() {
        return "Edu{" +
                "id=" + id +
                ", userId=" + userId +
                ", start='" + start + '\'' +
                ", end='" + end + '\'' +
                ", school='" + school + '\'' +
                ", study='" + study + '\'' +
                ", description='" + description + '\'' +
                ", next=" + next +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getUserId() {
        return userId;
    }

    public void setUserId(int userId) {
        this.userId = userId;
    }

    public String getStart() {
        return start;
    }

    public void setStart(String start) {
        this.start = start;
    }

    public String getEnd() {
        return end;
    }

    public void setEnd(String end) {
        this.end = end;
    }

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }

    public String getStudy() {
        return study;
    }

    public void setStudy(String study) {
        this.study = study;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public Edu getNext() {
        return next;
    }

    public void setNext(Edu next) {
        this.next = next;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Edu edu = (Edu) o;
        return id == edu.id &&
                userId == edu.userId &&
                Objects.equals(start, edu.start) &&
                Objects.equals(end, edu.end) &&
                Objects.equals(school, edu.school) &&
                Objects.equals(study, edu.study) &&
                Objects.equals(description, edu.description) &&
                Objects.equals(next, edu.next);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, userId, start, end, school, study, description, next);
    }
}
篇幅有限就到这吧，小编着急干饭。