Java SE 学习记录06

@学习记录

开始学习Java

遵从同学的指导，从Java se开始学习

黑马的JavaSE零基础入门

day06-01 面向对象

package day06;

import java.util.Arrays;

/*
面向过程，当需要实现一个功能的时候，详细处理每一个细节，强调过程
面向对象，当需要实现一个功能的时候，借助已有功能实现，强调对象

面向对象的三大基本特征：封装，继承和多态


*/
public class Demo01 {
    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));

    }
}

day06-04 类的定义

package day06;

/*
面向过程，当需要实现一个功能的时候，详细处理每一个细节，强调过程
面向对象，当需要实现一个功能的时候，借助已有功能实现，强调对象

面向对象的三大基本特征：封装，继承和多态

定义一个类，模拟“学生”事务，其中有两个组成部分：
属性（是什么）：
    姓名
    年龄
行为（能做什么）：
    吃饭
    睡觉
    学习

对应到Java的类中：
成员变量（属性）：
    String name;
    int age;
成员方法（行为）： // 没有static关键字
    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("学习！");
    }
}

day06-05 对象的创建及其使用

package day06;

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

2.创建
类名称 对象名 = new 类名称（）；
Student stu = new Student();

3.使用
使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名(参数)

注意事项：
如果成员变量没有进行赋值，那么将会有一个默认值

 */
public class Demo02 {
    public static void main(String[] args) {
        // 1. 导包
        // 位于同一类，可以省略不写

        // 2. 创建
        Student stu = new Student();

        // 3.使用
        System.out.println(stu.name); // 默认值null
        System.out.println(stu.age); // 默认值0
        System.out.println("==================================");

        // 改变对象当中成员变量的数值内容
        stu.name = "胡歌";
        stu.age = 18;
        System.out.println(stu.name);
        System.out.println(stu.age);
        System.out.println("==================================");

        // 使用成员对象的方法
        stu.eat();
        stu.sleep();
        stu.study();
        System.out.println("==================================");

    }
}

day06-06 手机类练习，使用对象类型作为方法的参数和返回值

package day06;

/*
新建手机的类
成员变量：品牌，价格，颜色
成员方法：打电话，发短信
 */


public class Phone {
    // 成员变量
    String brand;
    int price;
    String color;

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

    public void text() {
        System.out.println("发短信！");
    }


}

package day06;

public class Demo02Phone {
    public static void main(String[] args) {
        // 1. 导包

        // 2. 创建
        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.price = 8888;
        one.color = "黑色";
        System.out.println(one.brand);
        System.out.println(one.price);
        System.out.println(one.color);
        System.out.println("======================");

        one.call("家里人");
        one.text();
        System.out.println("======================");

        Phone phone2 = new Phone();
        System.out.println(phone2.brand);
        System.out.println(phone2.price);
        System.out.println(phone2.color);
        System.out.println("======================");

        phone2.brand = "三星";
        phone2.price = 6666;
        phone2.color = "蓝色";
        System.out.println(phone2.brand);
        System.out.println(phone2.price);
        System.out.println(phone2.color);
        System.out.println("======================");

        phone2.call("欧尼");
        phone2.text();
        System.out.println("======================");

        // 调用方法method()
        Phone two = new Phone();
        two.brand = "苹果";
        two.price = 8888;
        two.color = "黑色";
        method(two);
        System.out.println("======================");

        // 调用方法getPhone()
        Phone three = getPhone();
        System.out.println(three.brand);
        System.out.println(three.price);
        System.out.println(three.color);

    }

    // 使用对象类型作为方法的参数
    public static void method(Phone one){
        System.out.println(one.brand);
        System.out.println(one.price);
        System.out.println(one.color);
    }

    // 使用对象类型作为方法的返回值
    public static Phone getPhone(){
        Phone one = new Phone();
        one.brand = "苹果";
        one.price = 8888;
        one.color = "红色";
        return one;
    }
}

day06-12 成员变量和局部变量的区别

成员变量和局部变量的区别
1.定义的位置不一样【重点】
局部变量：在方法的内部
成员变量：在方法的外部，直接写在类当中

2.作用范围不一样【重点】
局部变量：只有方法中才可以使用
成员变量：整个类全部可以通用

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

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

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

day06-14 面向对象之封装性

package day06;

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

封装在java中的体现：
1.方法是一种封装
2.关键字private是一种封装

封装就是将一些细节信息隐藏，外界不可见

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

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

间接访问private成员变量，就是定义一对Getter（有参数无返回，参数类型与private的类型一致）/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 >= 0){
            age = num;
        }else {
            System.out.println("数据不合理");
        }

    }

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

package day06;

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

        person.name = "胡歌";
//        person.age = -20; // 直接访问private内容，错误写法！
        person.setAge(-20);
        person.show();

    }
}

day06-15 private关键字练习

package day06;

/*
对于基本类型当中的boolean值，Getter一定要写成isXxxx的形式，而Setter规则不变
 */

public class Student02 {
    private String name;
    private int age;
    private boolean 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;
    }
    public void setMale(boolean b){
        male = b;
    }
    public boolean isMale(){
        return male;
    }

}

package day06;

public class Demo04 {
    public static void main(String[] args) {
        Student02 stu = new Student02();
        stu.setName("胡歌");
        stu.setAge(30);
        stu.setMale(true);

        System.out.println(stu.getName());
        System.out.println(stu.getAge());
        System.out.println(stu.isMale());


    }
}

day06-16 this关键字的作用

package day06;

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

"通过谁调用的方法，谁就是this "
 */
public class Person02 {
    String name;

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

package day06;

public class Demo04 {
    public static void main(String[] args) {
        Person02 person = new Person02();
        person.name = "王健林";
        person.sayHello("王思聪");

    }
}

day06-17 构造方法

package day06;

/*
构造方法是专门用来创建对象的方法，通过关键字new创建对象时，其实就是在调用构造方法。

格式：
public 类名称(参数类型 参数名称){
    方法体
}

注意事项：
1.构造方法的名称必须和所在的类名称完全一样，包括大小写
2.构造方法不要写返回值类型，连void都不写
3.构造方法不能return一个具体的返回值
4.如果没有编写任何构造方法，那么编译器会默认赠送一个构造方法，没有参数，方法体什么事情都不做
5.一旦编写了至少一个构造方法，那么编译器就不再赠送
6.构造方法也是可以进行重载的

 */

public class Student03 {
    // 成员变量
    String name;
    int age;

    // 无参数的构造方法
    public Student03(){
        System.out.println("构造方法成功！");
    }

    // 全参数的构造方法
    public Student03(String name, int age){
        this.name = name;
        this.age = age;
    }

    // Setter,Getter
    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 day06;

public class Demo04 {
    public static void main(String[] args) {
        Student03 stu01 = new Student03(); // 无参数构造
        Student03 stu02 = new Student03("胡歌", 30); // 全参数构造
        System.out.println("姓名：" + stu02.getName() + "，年龄：" + stu02.getAge());
        // 如果需要改变对象当中成员变量数据内容，仍需要使用setXxxx方法
        stu02.setAge(31);
        System.out.println("姓名：" + stu02.getName() + "，年龄：" + stu02.getAge());
    }
}

day06-18 定义标准的类

package day06;

/*
一个标准的类通常需要满足下面四个组成部分：
1.所有的成员变量都要使用private关键字修饰
2.为每一个成员变量编写一对Setter/Getter方法
3.编写一个无参数的构造方法
4.编写一个全参数的构造方法

这样标准的类也叫做Java Bean
 */
public class Student04 {
    private String name;
    private int age;

    // code generate（或alt+insert）自动生成代码
    public Student04() {
    }

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

package day06;

public class Demo04 {
    public static void main(String[] args) {
        Student04 stu03 = new Student04();
        stu03.setName("胡歌");
        stu03.setAge(32);
        System.out.println("姓名：" + stu03.getName() + "，年龄：" + stu03.getAge());
        System.out.println("=========================");

        Student04 stu04 = new Student04("胡歌",34);
        System.out.println("姓名：" + stu04.getName() + "，年龄：" + stu04.getAge());
        stu04.setAge(33);
        System.out.println("姓名：" + stu04.getName() + "，年龄：" + stu04.getAge());
        System.out.println("=========================");



    }
}