java——面向对象之初始封装

二、面向对象——封装

1.类和对象

1.定义

在我们的生活中存在许多的类和对象。举个栗子，小到一个杯子、一本书，大到一个人、一栋楼…这些具有一定属性（特征）和功能（行为）的就是对象，俗话说物以类聚，因此具有相同属性的对象就构成一个类。而在编程语言Java中，类是最基本的单位。我们可以在 Java 的类中像日常生活一样抽象地定义属性与方法，将类实例化成一个对象之后，我们就可以使用它的属性与方法了

2.类的特点

• 类是对象的数据类型
• 类是具有相同属性和行为的一组对象的集合

3.对象的属性：

• 属性：对象具有的各种特征，每个对象的的属性有特点的值
• 行为：对象能够执行的操作

4.类和对象的关系

• 类是对现实生活中一类具有共同属性和行为的事物的抽象
• 抽象是能够看得到摸得着的真实存在的实体

5.类的组成：属性和行为

• 属性：在类中通过成员变量来体现（类中方法外的变量）
• 行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）

面向对象的写法之一

// 学生信息 
public class DemoOne{
    // 定义对象属性：姓名，年龄
    String name;
    int year;
    
    // 定义方法
    public void daka_shang(){
        System.out.println("打卡上学");
    }
    public void daka_xia(){
        System.out.println("打卡放学");
    }
    
}

2.操作使用

1.对象的使用

创建对象：

格式：类名 对象名 = new 类名();

使用对象的成员变量

格式：对象名.变量名

使用对象的成员方法

格式：对象名.方法名()

（1）学生类

可理解为一个模板，可以由主函数输入值，在利用这个模板打印

package com.itheima;

// 学生信息
public class Student_One {
    // 定义对象属性：姓名，年龄
    String name;
    int year;

    // 定义方法
    public void daka_shang(){
        System.out.println("打卡上学");
    }
    public void daka_xia(){
        System.out.println("打卡放学");
    }
    public void show(){
        System.out.println(name+","+year);
    }
}

（2）调用类

public class DemoOne{
    public static void main(String[] args) {
        // 新建 studeng_one 类变量
        Student_One so = new Student_One();

        // 调用类的属性
        so.name = "李宁";
        System.out.println(so.name);
        // 调用类的方法
        so.daka_shang();
    }

3.对象内存图

1.单个对象

2.多个对象

3.局部变量和成员变量

1. 局部变量定义：在方法里面的变量
2. 成员变量定义：在类里面的变量
3. 区别

• 所在的位置不同
• 内存中的位置不同（成员是在堆内存中，局部是在栈内存中）
• 生命周期不同（成员随着对象的变化而变化，局部是随着方法的变化而变化）
• 初始化值（成员有默认的初始值，而局部必须要定义变量）

4.封装

1.private关键字

定义

• 是一个权限修饰符
• 可以修饰成员（成员变量和成员方法）
• 作用是保护成员不被别的类使用，被private修饰的成员只在本类中才能访问

针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作

• 提供“get变量名()” 方法，用于获取成员变量的值，方法用 public修饰
• 提供"set变量名（参数）"方法，用于设置成员变量的值，方法用public修饰
• （1）学生类

// 学生信息
public class Student_One {
    // 定义对象属性：姓名，年龄
    String name;
//    int year;
    // 对年龄做一个关键字判断
    private int year;
    public void SetAge(int a){
        // 做出判断如果 这个输入的年龄乱来则报错
        if (a<0 ||a>120){
            System.out.println("输出的年龄有错误");
        }else {
            year = a;
        }
    }
    public int GetAge(){
        return year;
    }

    // 定义方法
    public void daka_shang(){
        System.out.println("打卡上学");
    }
    public void daka_xia(){
        System.out.println("打卡放学");
    }
    public void show(){
        System.out.println(name+","+year);
    }
}

（2）调用类

public class DemoOne{
    public static void main(String[] args) {
        // 新建 studeng_one 类变量
        Student_One so = new Student_One();

        // 调用类的属性
        so.name = "李宁";
        // 如果有private的关键字，则不能直接输入
        so.SetAge(35);
//        so.SetAge(190);
//        System.out.println(so.name);
        // 调用类的方法
        so.daka_shang();
        so.show();
        // 也可以直接用  get的方式进行调用
        System.out.println(so.GetAge());
    }
}

2.this关键字

1.this修饰的变量用于指代成员变量

• 方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
• 方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

2.什么时候使用 this ？对于成员变量和局部变量同名时

3.this：代表所在类的对象引用【方法被哪个对象调用，this就代表哪个对象】

    private int year;
    // 对于private的关键字 如下 int a 的命名不是很规范
    public void SetAge(int year){
//    public void SetAge(int a){
        // 做出判断如果 这个输入的年龄乱来则报错
        if (year<0 ||year>120){
            System.out.println("输出的年龄有错误");
        }else {
            //  !!!!会出现名字相同的变量，因此需要this
//            year = year;
            this.year = year;  // 这里 的this.year指代成员的 year 与局部的year进行区分
            // 而原先的不存在变量名相同，
//            year = n  // 这里的year则指代的是成员的year
        }
    }

3.封装定义和原则

1.概述

是面向对象三大特征之一（封装，继承，多态）

是面向对象编程语言对客观世界的模拟，客观世界成员变量都是隐藏在对象内部的，外界是无法进行操作

2.原则

将类的某些信息隐藏在类内部，外部不允许直接访问，而是通过 Get, Set 方法拉进行访问 成员private关键字的变量

3.好处

提高了代码的安全性

提高了代码的复用性

4.构造方法

作用：创建对象

格式

public class Class{
	修饰符 Class(参数){
	
	}
}
// 功能：完成对象数据的初始化
// 修饰符一半为 public

注意：

Student_One so = new Student_One();

在调用类中的构建函数，在定义类中默认有了

public Student_One(){}

因此，在对于构建函数中的参数，是可以在定义类中进行参数的增删
需求：

实现

（1）student类

package com.itheima1;

public class Student {
    // 属性：成员姓名，成员年龄 并且采用 private关键字
    private String name;
    private int year;

    // 构建函数
    public Student(){};

    // 对于私有关键字编写 set/get方法
    // 年龄的 get/set
    public void Set_Year(int year){
        if (year<0 || year>120){
            System.out.println("输入的年龄格式错误！");
        }else {
            // 采用 this 关键字进行区分局部变量和成员变量
            this.year = year;
        }
    }

    public int Get_Year(){
        return year;
    }
    // 姓名的 get/set
    public void Set_Name(String name){
        if (name.length() > 4){
            System.out.println("名字过长，请输入四位格式的姓名！");
        }else {
            this.name = name;
        }
    }
    public String Get_Name(){
        return name;
    }

    // show 展示，也可在调用类中使用 get方法
    public void Show(){
        System.out.print("姓名："+name+" | "+"年龄："+year);
        System.out.println();
    }

    // 传姓名传年龄
    public Student(String name,int year){
        this.name = name;
        this.year = year;
    };
}

（2）调用类

package com.itheima1;

public class DemoTest {
    public static void main(String[] args) {
        // 构建函数，初始化
        Student student1 = new Student();
        student1.Show(); // 无参数的展示

        //!!!!!!!无构造方法创建对象写入值

        // 传入一个姓名
        student1.Set_Name("李宁");
        student1.Show(); // 只有姓名的展示

        // 传入一个年龄
        student1.Set_Year(32);
        student1.Show(); // 只有年龄的展示,但是如果前面已经 set了一个姓名，这里会传进去

        // 既传入姓名，又传入 年龄
        student1.Set_Name("哈哈哈哈哈");
        student1.Set_Year(28);
        student1.Show(); // 姓名和年龄一起展示

        // ________________________
        //!!!!!!!带参数的写入值
        Student student2 = new Student("王刚王刚王",24);
        student2.Show();
    }
}

————————
后续将继续更新！
内有不足请指教！