【Java基础】DAY6

最新推荐文章于 2024-05-14 12:20:13 发布
最新推荐文章于 2024-05-14 12:20:13 发布
阅读量225 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZyhMemory/article/details/88718214
版权

推荐阅读：

DAY6

DAY6

1、面向对象

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

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));
}

2、面向对象思想举例

洗衣服

面向过程：脱下衣服–>找个盆–>倒洗衣液–>洗–>晾

面向对象：脱下衣服–>放入洗衣机–>晾

吃饭

面向过程：买菜–>洗菜–>炒菜–>吃–>刷碗

面向对象：餐馆–>回家

3、类和对象的关系

类是对一类实物的描述，是抽象的，相当于设计图纸

对象是一类实物的示例，是具体的，相当于实物东西

4、类的定义

定义一个类，用来模拟“学生”实物。其中就有两个组成部分：

属性（是什么）：
姓名
年龄
行为（能做什么）：
吃饭
睡觉
学习

对应到Java的类当中：

成员变量（属性）：
String name; // 姓名
int age; // 年龄
成员方法（行为）：
public void eat() {} // 吃饭
public void sleep() {} // 睡觉
public void study() {} // 学习

注意事项：
1、成员变量是直接定义在类当中的，在方法外边。
2、成员方法不要写static关键字。

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("学习");
    }

}

5、对象的创建及使用

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

1、导包：也就是指出需要使用的类，在什么位置。
import 包名称.类名称;
import com.memory.day06.dome01.Student;
对于和当前类属于同一个包的情况，可以省略导包语句。

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

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

注意事项：
如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。

public static void main(String[] args) {
    // 1、导包。
    // 我需要使用的Studnet类，和我自己Demo02Student位于同一个包下，所以省略导包语句

    // 2、创建，格式：
    // 类名称 对象名 = new 类名称();
    // 根据Studnet类，创建了一个名为stu的对象
    Student stu = new Student();

    // 3、使用其中的成员变量，格式：
    // 对象名.成员变量名
    System.out.println(stu.name);   // null
    System.out.println(stu.age);    // 0
    System.out.println("===================");

    // 改变对象当中的成员变量数值内容
    // 将右侧的字符串，赋值交给stu对象当中的name成员变量
    stu.name = "小明";
    stu.age = 18;
    System.out.println(stu.name);
    System.out.println(stu.age);
    System.out.println("===================");

    // 4、使用对象的成员方法，格式：
    // 对象名.成员方法名()
    stu.eat();
    stu.sleep();
    stu.study();
}

6、手机类练习

定义一个类，用来模拟“手机“事物。

属性：品牌、价格、颜色
行为：打电话、发短信

对应到类当中：
成员变量（属性）：
String brand; // 品牌
double price; // 价格
String color; // 颜色
成员方法（行为）：
public void call(String who) {} // 打电话
public void sendMessage() {} // 群发短信

public class Phone {

    // 成员变量
    String brand;   // 品牌
    double price;   // 价格
    String color;   // 颜色

    // 成员方法
    public void call(String who) {
        System.out.println("给" + who + "打电话");
    }

    public void sendMessage() {
        System.out.println("群发短信");
    }
}

public class Demo01PhoneOne {

    public static void main(String[] args) {
        // 根据Phone类，创建一个名称One的对象
        // 格式：类名称 对象名 = new 类名称();
        Phone one = new Phone();
        System.out.println(one.brand);  // null
        System.out.println(one.price);  // 0.0
        System.out.println(one.color);  // null
        System.out.println("===============");

        one.brand = "苹果";
        one.price = 8388.0;
        one.color = "黑色";
        System.out.println(one.brand);  // 苹果
        System.out.println(one.price);  // 8388.0
        System.out.println(one.color);  // 黑色
        System.out.println("===============");

        one.call("乔布斯");     	  // 给乔布斯打电话
        one.sendMessage();			// 群发短信
    }
}

7、一个对象的内存图

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

public class Demo02PhoneTwo {

    public static void main(String[] args) {
        Phone one = new Phone();
        System.out.println(one.brand);  // null
        System.out.println(one.price);  // 0.0
        System.out.println(one.color);  // null
        System.out.println("===============");

        one.brand = "苹果";
        one.price = 8388.0;
        one.color = "黑色";
        System.out.println(one.brand);  // 苹果
        System.out.println(one.price);  // 8388.0
        System.out.println(one.color);  // 黑色
        System.out.println("===============");

        one.call("乔布斯");        // 给乔布斯打电话
        one.sendMessage();             // 群发短信
        System.out.println("===============");

        Phone two = new Phone();
        System.out.println(two.brand);  // null
        System.out.println(two.price);  // 0.0
        System.out.println(two.color);  // null
        System.out.println("===============");

        two.brand = "三星";
        two.price = 5999.0;
        two.color = "蓝色";
        System.out.println(two.brand);  // 三星
        System.out.println(two.price);  // 5999.0
        System.out.println(two.color);  // 蓝色
        System.out.println("===============");

        two.call("三星");         // 给三星打电话
        two.sendMessage();             // 群发短信
    }
}

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

public class Demo03PhoneSame {

    public static void main(String[] args) {
        Phone one = new Phone();
        System.out.println(one.brand);  // null
        System.out.println(one.price);  // 0.0
        System.out.println(one.color);  // null
        System.out.println("===============");

        one.brand = "苹果";
        one.price = 8388.0;
        one.color = "黑色";
        System.out.println(one.brand);  // 苹果
        System.out.println(one.price);  // 8388.0
        System.out.println(one.color);  // 黑色
        System.out.println("===============");

        one.call("乔布斯");        // 给乔布斯打电话
        one.sendMessage();             // 群发短信
        System.out.println("===============");

        // 将one当中保存的对象地址赋值给two
        Phone two = one;
        System.out.println(two.brand);  // 苹果
        System.out.println(two.price);  // 8388.0
        System.out.println(two.color);  // 黑色
        System.out.println("===============");

        two.brand = "三星";
        two.price = 5999.0;
        two.color = "蓝色";
        System.out.println(two.brand);  // 三星
        System.out.println(two.price);  // 5999.0
        System.out.println(two.color);  // 蓝色
        System.out.println("===============");

        two.call("三星");         // 给三星打电话
        two.sendMessage();             // 群发短信
    }
}

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

public class Demo04PhoneParam {

    public static void main(String[] args) {
        Phone one = new Phone();
        one.brand = "苹果";
        one.price = 8388.0;
        one.color = "土豪金";

        method(one);    // 传递进去的参数其实就是地址值
    }

    public static void method(Phone param) {
        System.out.println(param.brand);    // 苹果
        System.out.println(param.price);    // 8388.0
        System.out.println(param.color);    // 土豪金
    }
}

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

public class Demo05PhoneReturn {

    public static void main(String[] args) {
        Phone two = getPhone();
        System.out.println(two.brand);  // 苹果
        System.out.println(two.price);  // 8388.0
        System.out.println(two.color);  // 玫瑰金
    }

    public static Phone getPhone() {
        Phone one = new Phone();
        one.brand = "苹果";
        one.price = 8388.0;
        one.color = "玫瑰金";
        return one;
    }
}

12、局部变量和成员变量

1、定义的位置不一样【重点】
局部变量：在方法的内部
成员变量：在方法的外部，直接卸载类当中

2、作用范围不一样【重点】
局部变量：只有方法当中才可以使用，出了方法就不能再用
成员变量：整个类全都可以通用

3、默认值不一样【重点】
局部变量：没有默认值，如果要想使用，必须手动进行赋值
成员变量：如果没有赋值，会有默认值，规则和数组一样

4、内存的位置不一样（了解）
局部变量：位于栈内存
成员变量：位于堆内存

5、生命周期不一样（了解）
局部变量：随着方法进栈而诞生，随着方法出栈而消失
成员变量，随着对象创建而诞生，随着对象被垃圾回收而消失

public class Demo01VariableDifference {

    String name;    // 成员变量

    public void methodA() {
        int num = 20;   // 局部变量
        System.out.println(num);
        System.out.println(name);
    }

    public void methodB(int param) {    // 方法的参数就是局部变量
        // 参数在方法调用的时候，必然会比赋值
        System.out.println(param);

        int age;    // 局部变量
//        System.out.println(age);    // 没有赋值不能使用
//        System.out.println(num);    // 错误写法，调用不到局部变量
        System.out.println(name);
    }

}

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

面向对象三大特征：封装、继承、多态

封装性在Java当中的体现：
1、方法就是一种封装
2、关键字private也是一种封装

封装就是将一些细节信息隐藏起来，对于外界不可见。

public class Demo02Method {

    public static void main(String[] args) {
        int[] array = { 5, 15, 25, 20, 100 };
        
        int max =getMax(array);
        System.out.println("最大值：" + max);
    }

    // 给我一个数组，我换给你一个最大值
    public static int getMax(int[] array) {
        int max = array[0];
        for (int i = 0; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }
        return max;
    }
}

14、private关键字的作用及使用

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

一旦使用了private进行修饰，那么本类当中仍然可以随意访问。
但是！超出了本类范围之外就不能直接访问了。

间接访问private成员变量，就定义一对Getter/Setter方法

必须叫setXxx或者是getXxx命名规则。
对于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 < 120 && num >= 0) {
            age = num;
        } else {
            System.out.println();
        }
    }

    // 这个成员方法，专门用于获取age的数据
    public int getAge() {
        return age;
    }
}

public class Demo03Person {

    public static void main(String[] args) {
        Person person = new Person();
        person.show();

        person.name = "小明";
//        person.age = 18;    // 直接访问private内容，错误！
        person.setAge(20);
        person.show();
    }
}

15、练习使用private关键字定义学生类（特殊boolean）

对于基本类型当中的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 String getName() {
        return name;
    }

    public void setName(String str) {
        name = str;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int num) {
        age = num;
    }
}

public class Demo04Studnet {

    public static void main(String[] args) {
        Student stu = new Student();

        stu.setName("小明");
        stu.setAge(20);
        stu.setMale(true);

        System.out.println("姓名：" + stu.getName());
        System.out.println("年龄：" + stu.getAge());
        System.out.println("是不是男的：" + stu.isMale());
    }
}

16、this关键字的作用

当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量。
如果需要访问本类当中的成员变量，需要使用格式：
this.成员变量名

“通过谁调用的方法，谁就是this。”

public class Person {

    String name;    // 自己的名字

    // 参数name是对方的名字
    // 成员变量name是自己的名字
    public void sayHello(String name) {
        System.out.println(name + ",您好。我是" + this.name);
        System.out.println(this);
    }
}

public class Demo01Person {

    public static void main(String[] args) {
        Person person = new Person();
        // 设置我自己的名字
        person.name = "小明";
        person.sayHello("小红");
        System.out.println(person);
    }
}

17、构造方法

构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。
格式：
public 类名称(参数类型 参数名称) {
方法体
}

注意事项：
1、构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
2、构造方法不要写返回值类型，连void都不写
3、构造方法不能return一个具体的返回值
4、如果没有编写任何构造方法，那么编译器将会默认有一个构造方法，没有参数、方法体什么事情都不做。
public Studnet() {}
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 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 class Demo02Student {

    public static void main(String[] args) {
        Student stu1 = new Student();   // 无参构造
        Student stu2 = new Student("小明",20);    // 全参构造
        System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
        // 如果需要改变对象当中的成员变量数据内容，仍然还需要使用setXxx方法
        stu2.setAge(21);    // 改变年龄
        System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
    }
}

18、定义一个标准的类

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

1、所有的成员变量都要使用private关键字修饰
2、为每一个成员变量编写一对Getter/Setter方法
3、编写一个无参数构造方法
4、编写一个全参数构造方法

这样标准的类也叫做Java Bean

public class Student {

    private String name;    // 姓名
    private int age;        // 年龄

    public Student() {
    }

    public Student(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;
    }
}

public class Demo01Student {

    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.setName("小明");
        stu1.setAge(20);
        System.out.println("姓名：" + stu1.getName() + "，年龄：" + stu1.getAge());
        System.out.println("================");

        Student stu2 = new Student("小红",22);
        System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
        stu2.setAge(21);
        System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
    }
}
ZyhMemory
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java基础day01
03-25
Java基础day01
07-20
Java是一种广泛应用于各种领域的编程语言，尤其在企业级应用开发中占据着主导地位...从第一天的Java基础学习开始，随着对语言特性的理解和实践，开发者可以逐步构建起坚实的技术基础，从而在各种领域中发挥Java的优势。
Java基础Day01
Riven_x的博客
09-24 3169
作为一名JAVA开发的程序员，一直没有好好整理过自己的笔记和技术栈。很多用过的东西都忘了，从今天起，开始记录下自己的学习历程。希望还能跟上时代的步伐。谨记 不骄不躁 1_Java语言发展史（了解） Java语言诞生于1995年，由Sun公司推出。 ​ 2009年，Sun公司被甲骨文（oracle）公司收购，官网地址：https://www.oracle.com ​ Java之父：詹姆斯·高斯...
Java基础入门-Day1
weixin_45795542的博客
11-03 502
Java基础入门-Day1JAVA 开发入门特点分类Java字节执行方式JDK的使用Java垃圾回收机制Java编译 JAVA 开发入门 Java是一种高级计算机语言。他是由Sun公司(已被Oracle公司于2009年4月20日收购)于1995年5月推出的一种可以编写跨平台应用软件丶完全面向对象的程序设计语言。 特点 资源免费 跨平台 健壮，安全 高性能 简单 面向对象 动态性 多线程 分类 Ja...
Java基础Day01-Java基础语法
Puffy的博客
03-16 2005
Java基础语法Java发展史java的应用平台java特点jdk jre jvm集成开发环境 eclipse注释常量变量数据类型标识符就是用来给包 类 方法 变量定义名称的定义变量和使用变量使用变量的注意事项数据类型转换 Java发展史 诞生时间 1995年 java之父 詹姆斯 高斯林 目前最新的版本 java11 java的应用平台 javase 桌面应用开发 javaee 企业级应用开...
java基础入门day01
zpz2001的专栏
03-15 1029
java基础入门
java基础学习day01
m0_74443089的博客
12-06 398
java基础day1
hzbobhz的博客
01-04 1235
初识java 在将jdk下载成功并且配置jdk环境变量成功之后，我们可以正式开始进行java程序的编写了。 java程序执行过程分为2步： 第一步：将java源码(.java文件)通过编译器(javac.exe)编译成字节码文件(.class文件) 第二步：将JVM(java虚拟机)文件通过java.exe执行，输出结果 我们可以先用记事本进行java程序的编写。 流程：1、使用记事本编辑.java源程序 2、使用javac命令编译，生成.class文件 3、使用java命令运行.class文件 结果如图：
Java基础入门-Day10
weixin_45795542的博客
12-06 981
Java基础入门-Day10 访问控制符 在Java中，针对类、成员方法和属性提供了4种访问级别，分别是private、default、protected和public。接下来通过一个图将这4种控制级别由小到大依次列出 private==>default==>protected==>public privat（当前类访问级别） 如果类的成员被private访问控制符来修饰，则这个...
Java基础Day-One
ZIM的博客
05-09 2217
零基础Java入门第一天
Java基础Day-Two
ZIM的博客
05-10 764
Java零基础学习
Java基础Day-Six
最新发布
ZIM的博客
05-14 919
this.getStudentSex() + "\n年龄：" + this.getStudentAge() + "\n所报专业名称：" + subjectName + "\n学制年限："String str = "专业信息如下：\n专业名称：" + this.getsubjectName() + "\n专业编号：" + this.getSubjectNo() + "\n学制年限："Student stu1=new Student("S01","张三","男",18,sub1);
Java基础day03(ppt文档).pptx
11-13
Java基础day03（ppt文档） 本章节主要介绍了Java语言的基本语法，包括数据类型的转换、运算符的介绍、运算符的优先级、语句的介绍等内容。 1. 数据类型的转换 Java中可以进行不同数据类型的加减乘除运算吗？答案...
Java基础Day05.xmind
06-29
适合java初学者
Java基础Day04.xmind
06-29
适合java初学者
【Velocity】关于List中是否有某个值
Memory的博客
05-05 3303
使用contains函数即可判断false、true boolean java.util.List.contains(Object o) Returns true if this list contains the specified element. More formally, returns true if and only if this list contains at least on...
【Velocity】关于#foreach的累加
Memory的博客
05-05 1976
今天遇到了一个需求 遍历出来后累计相加 vm才接触 就想用这个给它整出来 $sun = 0 #foreach($!result in $!map.page.recordList) $sum += $result.settleNum) #end 不行…… $sun = 0 #foreach($!result in $!map.page.recordList)...
【Collectors.toMap key重复会报错】Collectors.toMap Duplicate key 1
Memory的博客
08-08 1067
Collectors.toMap key重复会报错：Collectors.toMap Duplicate key 1
Java 基础学习记录
Memory的博客
06-01 1037
Java 基础DAY11、关于进制的运算2、关于存储单元3、关于CMD的基本命令4、JRE与JDK5、Java环境变量6、程序开发步骤7、HelloWorld8、标识符9、常量10、数据类型数据类型分类基本数据类型注意事项：11、变量DAY21、数据类型转换自动类型转换（隐式）强制类型转换（显式）2、ASCII编码表3、算术运算符四则运算当中的加号“+”有常见的三种用法：4、自增自减运算符5、赋值...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值