标签：封装 String age private public 成员 name

封装

1.封装思想

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

对象代表什么，就得封装对应的数据，并提供数据对应的行为
封装代码实现将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，提供对应的getXxx()/setXxx()方法

2.什么是封装思想:

1.我们找来了一个对象(洗衣机),只需要按一下按钮就可以了(使用洗衣机功能的过程就是在使用面向对象思想编程的过程),每一个按钮下面都包含了很多内部结构的细节(细节被封装到按钮里面了->封装),在使用的时候有必要了解洗衣机的内部构造吗?我们没有必要去了解内部结构,我们只知道调用就可以了

所以,洗衣机来说,将细节隐藏起来了,细节我们不要关注,会对外提供了一个公共的接口(按钮),供我们人类使用

2.隐藏对象内部的复杂性,只对外提供公开,公共的接口,便于外界调用,从而提高了系统的可扩展性,可维护性,安全性,通俗来说,把该隐藏的隐藏起来(细节),把该暴露的暴露出来(对外提供的供别人使用的接口),这就是封装思想

我们只需要调用这个接口(功能)即可,此接口背后封装起来的细节就开始执行了,但是我们不需要关注细节,只关注公共的接口怎么调用

3.将细节隐藏起来,不让外界随便使用,但是我们可以提供一个公共的接口让外界间接使用隐藏起来的细节->封装思想

private关键字

private是一个修饰符，可以用来修饰成员（成员变量，成员方法）

被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
- 提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
- 提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰
- 1.问题:
  定义成员变量,只要是new出来对象,就可以随便调用,随便赋值,哪怕是不合理的值我们也挡不住,怎么办?
  将属性封装起来(隐藏细节)
  a.关键字:private(私有化的) -> 被private修饰的成员只能在本类中使用,在别的类中使用不了
  b.注意:
  将代码放到一个方法中,也是封装的体现
  一个成员被private修饰也是封装的体现,只不过private最具代表性
  c.private的使用:
  修饰成员变量:private 数据类型变量名
  修饰方法:将public改成private,其他的都一样
  2.问题:属性被私有化了,外界直接调用不了了,那么此时属性就不能直接赋值取值了,所以需要提供公共的接口
  get/set方法
- set方法:为属性赋值
  get方法:获取属性值

示例代码：

/*
    学生类
 */
class Student {
    //成员变量
    String name;
    private int age;

    //提供get/set方法
    public void setAge(int a) {
        if(a&lt;0 || a&gt;120) {
            System.out.println("你给的年龄有误");
        } else {
            age = a;
        }
    }

    public int getAge() {
        return age;
    }

    //成员方法
    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        //给成员变量赋值
        s.name = "杨浩东";
        s.setAge(22);
        //调用show方法
        s.show();
    }
}

1.4 构造方法

1.4.1 构造方法的作用

在创建对象的时候，给成员变量进行初始化。

初始化即赋值的意思。

1.4.2 构造方法的格式

修饰符 类名(形参列表) {
    // 构造体代码，执行代码
}

1.4.3 构造方法的应用

首先定义一个学生类，代码如下：

public class Student {
    // 1.成员变量
    public String name;
    public int age;

    // 2.构造方法
    public Student() {
		System.out.println("无参数构造方法被调用")；
    }
}

接下来通过调用构造方法得到两个学生对象。

public class CreateStu02 {
    public static void main(String[] args) {
        // 创建一个学生对象
        // 类名 变量名称 = new 类名();
        Student s1 = new Student();
        // 使用对象访问成员变量，赋值
        s1.name = "张三";
        s1.age = 20 ;

        // 使用对象访问成员变量 输出值
        System.out.println(s1.name);
        System.out.println(s1.age); 

        Student s2 = new Student();
        // 使用对象访问成员变量 赋值
        s2.name = "李四";
        s2.age = 18 ;
        System.out.println(s2.name);
        System.out.println(s2.age);
    }
}

this的介绍

1.如果成员变量和局部变量重名时,我们遵循"就近原则",【方法内部->成员变量】先访问局部变量

使用this关键字，可以在方法中使用当前对象里其他成员[成员变量或者成员方法]

2.this概述:代表的是当前对象

3.作用:this可以区分重名的成员变量和局部变量

this点出来的一定是成员的变量

4.this代表当前对象,那么具体代表哪个对象呢?

哪个对象调用的this所在的方法,this就代表哪个对象
this表示当前调用该方法的对象

例子

用于构造方法中

this出现在构造方法中，代表构造方法正在初始化的那个对象。

public class Student {
    private String name;
    private int age;
    
    // 无参数构造方法
    public Student() {} 
    
    // 有参数构造方法
    public Student(String name,int age) {
    	this.name = name;
    	this.age = age; 
    }
}

class Book {
    private String bookName;
    private String author;

    Book(String bookName, String author) {
        this.bookName = bookName;
        this.author = author;
    }

    Book(){

    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public void show() {
        System.out.println("书名：《" + this.bookName + "》, 作者：" + this.author);
    }
}

public class BookDemo {
    public static void main(String[] args) {
        Book book = new Book();
        book.show();
//        book.setBookName("活着");
//        book.setAuthor("余华");
//        book.show();


//        Book book2 = new Book("你好");
        Book b = new Book("三国演义", "罗贯中");
        b.show();
    }
}

static关键字

概述:static是一个静态关键字

使用:
1.修饰一个成员变量:
static 数据类型变量名

2.修饰一个方法:
修饰符 static 返回值类型方法名(形参){
方法体
return 结果
}

3.调用静态成员:
类名直接调用(不用new对象)

注意事项：

被static修饰的成员称之为类成员，静态成员，不被任何一个对象私自拥有
类成员是可以直接通过类名的方式进行访问获取，优先于对象而存在的
非静态的成员方法既可以访问非静态成员，也可以访问静态成员

例子

package shujia.day05;

class Student {
    private String name = "张三";
    private int age = 18;

    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 StudentDemo1 {
    public static void main(String[] args) {
        //创建一个学生对象
        Student s1 = new Student("张成阳", 14);
        s1.setName("方直");
        s1.setAge(16);
        System.out.println("姓名：" + s1.getName() + ", 年龄：" + s1.getAge());
    }
}

static修饰成员的访问特点

1.在静态方法中能直接访问非静态成员嘛?  不能
  想要调用的话:new对象调用  
    
2.在非静态方法中能直接访问静态成员嘛? 能
  a.同类:
    直接调用
    类名调用
        
  b.不同类:
    类名调用
      
    
3.在静态方法中能直接访问静态成员嘛?能
  a.同类:
    直接调用
    类名调用
        
  b.不同类:
    类名调用
    
4.在非静态方法中能直接访问非静态成员嘛?能
  a.同类:
    直接调用
    new对象调用
        
  b.不同类:
    new对象调用

小结

1.当 static 修饰成员变量或者成员方法时，该变量称为静态变量，该方法称为静态方法。该类的每个对象都共享同一个类的静态变量和静态方法。任何对象都可以更改该静态变量的值或者访问静态方法。但是不推荐这种方式去访问。因为静态变量或者静态方法直接通过类名访问即可，完全没有必要用对象去访问。

2.无static修饰的成员变量或者成员方法，称为实例变量，实例方法，实例变量和实例方法必须创建类的对象，然后通过对象来访问。

3.static修饰的成员属于类，会存储在静态区，是随着类的加载而加载的，且只加载一次，所以只有一份，节省内存。存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。它优先于对象存在，所以，可以被所有对象共享。

4.无static修饰的成员，是属于对象，对象有多少个，他们就会出现多少份。所以必须由对象调用。

标签：封装,String,age,private,public,成员,name
From： https://www.cnblogs.com/03270925yhd/p/18673679

封装

封装