类和对象（二）
类和对象（二）
- 一：封装
-
- 1：什么是封装？
- 2：为什么要封装？
- 3：访问限定符：
- 二：static成员：
-
- 1：static修饰成员变量
- 2：static修饰成员方法
- 3：类的成员变量
-
- 1:静态成员变量
- 2：非静态成员变量/普通成员变量
- 三：代码块
-
- 1：普通代码块
- 2:构造代码块/实例代码块
- 3：静态代码块
一：封装
面对对象程序的三大特性：封装，继承，多态。
1：什么是封装？
封装就是将类的实现细节进行了隐藏，对外只提供一些接口。
2：为什么要封装？
为了安全考虑。
3：访问限定符：
Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认识，而访问权限用来控制方法或者字段能否直接在类外使用。
public：可以理解为一个人的外貌特征，谁都可以看的到；
default：包访问权限，只有在同一个包中才可以使用。对于自己家族中（同一个包中）不是什么秘密，对于其他人来说就是隐私了。
private：只能在同一个类中使用。
protected:在同一个包中，以及不同包的子类中可以使用。
一般我们类的成员变量我们写成private修饰，成员方法用public修饰，可以根据具体的情景来确定使用什么限定符。
举个例子看一下吧！
class Student{
private String name;
private int age;
private String classroom;
//构造方法
public Student(String name, int age, String classroom) {
this.name = name;
this.age = age;
this.classroom = classroom;
}
//公开的接口，获得成员变量name
public String getName() {
return name;
}
//公开的接口，设置成员变量name
public void setName(String name) {
this.name = name;
}
//公开的接口，获得成员变量age
public int getAge() {
return age;
}
//公开的接口，设置成员变量age
public void setAge(int age) {
this.age = age;
}
//公开的接口，获得成员变量classroom
public String getClassroom() {
return classroom;
}
//公开的接口，设置成员变量classroom
public void setClassroom(String classroom) {
this.classroom = classroom;
}
}
public class Test {
public static void main(String[] args) {
Student student=new Student("张三",20,"1770");
}
}
二：static成员：
先看个例子：
class Student{
private String name;
private int age;
private String classroom;
//构造方法
public Student(String name, int age, String classroom) {
this.name = name;
this.age = age;
this.classroom = classroom;
}
//公开的接口，获得成员变量name
public String getName() {
return name;
}
//公开的接口，设置成员变量name
public void setName(String name) {
this.name = name;
}
//公开的接口，获得成员变量age
public int getAge() {
return age;
}
//公开的接口，设置成员变量age
public void setAge(int age) {
this.age = age;
}
//公开的接口，获得成员变量classroom
public String getClassroom() {
return classroom;
}
//公开的接口，设置成员变量classroom
public void setClassroom(String classroom) {
this.classroom = classroom;
}
@Override
public String toString() {
return "姓名:"+this.name+" 年龄："+age+" 班级："+classroom;
}
}
public class Test {
public static void main(String[] args) {
Student student1=new Student("张三",20,"1770");
Student student2=new Student("李四",21,"1770");
Student student3=new Student("王五",19,"1770");
System.out.println(student1.toString());
System.out.println(student2.toString());
System.out.println(student3.toString());
}
}
我们发现这三个同学的上课班级都是相同的，都是1770，而在Student类中定义的成员变量，每个对象都会包含一份，因为这些需要描述一个具体的学生，而这个教室并不需要每个学生来存储一份，而是所有的学生共享。
在Java中，被static修饰的成员，称为静态成员，也可以称为类成员，其不属于某个具体的对象，而是所有对象共享的。
1：static修饰成员变量
1：static修饰的成员变量称为静态成员变量，静态成员变量的最大特征就是不属于某个具体的对象，是所有对象所共享的。
2：既可以通过类名访问，又可以通过对象访问，但更推荐使用类名访问，因为static修饰的成员变量是不属于某个对象的，而是属于类的。
3：static修饰的成员变量存储在方法区中；
4：生命周期伴随类的一生，随着类的加载而创建，随着类的卸载而销毁。
static修饰成员变量举例：
class Student{
private String name;
private int age;
private static String classroom="1770";
//构造方法
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//公开的接口，获得成员变量name
public String getName() {
return name;
}
//公开的接口，设置成员变量name
public void setName(String name) {
this.name = name;
}
//公开的接口，获得成员变量age
public int getAge() {
return age;
}
//公开的接口，设置成员变量age
public void setAge(int age) {
this.age = age;
}
//公开的接口，获得成员变量classroom
public String getClassroom() {
return classroom;
}
//公开的接口，设置成员变量classroom
public void setClassroom(String classroom) {
this.classroom = classroom;
}
@Override
public String toString() {
return "姓名:"+this.name+" 年龄："+age+" 班级："+classroom;
}
}
public class Test {
public static void main(String[] args) {
Student student1=new Student("张三",20);
Student student2=new Student("李四",21);
Student student3=new Student("王五",19);
System.out.println(student1.toString());
System.out.println(student2.toString());
System.out.println(student3.toString());
}
}
class Student{
private String name;
private int age;
public static String classroom;
//构造方法
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//公开的接口，获得成员变量name
public String getName() {
return name;
}
//公开的接口，设置成员变量name
public void setName(String name) {
this.name = name;
}
//公开的接口，获得成员变量age
public int getAge() {
return age;
}
//公开的接口，设置成员变量age
public void setAge(int age) {
this.age = age;
}
//公开的接口，获得成员变量classroom
public String getClassroom() {
return classroom;
}
//公开的接口，设置成员变量classroom
public void setClassroom(String classroom) {
this.classroom = classroom;
}
@Override
public String toString() {
return "姓名:"+this.name+" 年龄："+age+" 班级："+classroom;
}
}
public class Test {
public static void main(String[] args) {
Student student1=new Student("张三",20);
Student student2=new Student("李四",21);
Student student3=new Student("王五",19);
Student.classroom="1770";
System.out.println(student1.toString());
System.out.println(student2.toString());
System.out.println(student3.toString());
}
}
2：static修饰成员方法
1：被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。
2：可以通过类名来调用，也可以通过对象调用，但更推荐类名调用。
3：不可以在静态方法中访问任何非静态的成员变，不可以在静态方法中调用非静态的方法；
4：可以在非静态的方法中调用静态的成员变量和静态的成员方法。
5：在静态方法中不可以使用this引用。
class Student{
private String name;
private int age;
private static String classroom;
//构造方法
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public static String getClassroom(){
return classroom;
}
public static void setClassroom(String classroom) {
Student.classroom = classroom;
}
//公开的接口，获得成员变量name
public String getName() {
return name;
}
//公开的接口，设置成员变量name
public void setName(String name) {
this.name = name;
}
//公开的接口，获得成员变量age
public int getAge() {
return age;
}
//公开的接口，设置成员变量age
public void setAge(int age) {
this.age = age;
}
//公开的接口，获得成员变量classroom
@Override
public String toString() {
return "姓名:"+this.name+" 年龄："+age+" 班级："+classroom;
}
}
public class Test {
public static void main(String[] args) {
Student student1=new Student("张三",20);
Student student2=new Student("李四",21);
Student student3=new Student("王五",19);
Student.setClassroom("1770");
System.out.println(student1.toString());
System.out.println(student2.toString());
System.out.println(student3.toString());
}
}
3：类的成员变量
类的成员变量分为两种：
1：静态成员变量
2:非静态成员变量/普通成员变量
在非静态的成员方法中可以访问静态的成员变量和静态的成员方法。
1:静态成员变量
1：静态成员变量是属于类的，不属于对象，只有一份
2：通常使用类名来访问
3：静态的成员变量随着类被加载而加载，随着类的销毁而销毁。
2：非静态成员变量/普通成员变量
1：属于对象的，每实例化一个对象，都会有一个对应的非静态成员变量，每个对象都有。
2:通过对象来访问。
三：代码块
使用{}定义的代码称为代码块。根据代码块定义的位置以及关键字又分为：
1：普通代码块
2：构造代码块/实例代码块
3：静态代码块
1：普通代码块
普通代码块是定义在方法中的代码块，一般不使用，
public class Test{
public static void main(String[] args) {
{//普通代码块
System.out.println("这是普通代码块");
System.out.println("哈哈");
}
}
}
2:构造代码块/实例代码块
定义在类中的代码块称为构造代码块，也叫做：实例代码块，一般用于初始化实例成员变量。
仍是学生类：
//构造代码块，实例代码块
{
this.name="张三";
this.age=19;
}
3：静态代码块
用static修饰的代码块称为静态代码块，一般用于初始化静态的成员变量
//静态代码块
static{
classroom="1770";
}
静态代码块不依赖与对象，随着类的加载而加载：
class Student{
private String name;
private int age;
public static String classroom;
//构造方法
public Student(String name, int age) {
System.out.println("这是构造方法");
}
//构造代码块，实例代码块
{
System.out.println("这是构造代码块");
}
static{
classroom="1770";
System.out.println("这是静态代码块");
}
}
public class Test{
public static void main(String[] args) {
//这里我们没有创建对象
System.out.println(Student.classroom);
}
}
注意：
1：不管生成多少个对象，静态代码块只会执行一次。
2：静态成员变量是类的属性，类在加载的时候完成初始化。
3：如果一个类中包含多个静态代码块，在程序执行时，程序会依次执行。
4：实例代码块只有在创建对象的时候才会执行，和构造方法一样，创建一次对象，执行一次。
5：先执行静态代码块，再执行实例代码块，再执行构造方法。但静态代码块只会执行一次。
class Student{
private String name;
private int age;
public static String classroom;
//构造方法
public Student(String name, int age) {
System.out.println("这是构造方法");
}
//构造代码块，实例代码块
{
System.out.println("这是构造代码块");
}
static{
classroom="1770";
System.out.println("这是静态代码块");
}
}
public class Test{
public static void main(String[] args) {
Student student1=new Student("张三",19);
Student student2=new Student("李四",20);
// 创建了两个对象实例代码块和构造方法执行了两次，
// 而静态代码块只会执行一次
}
}
