类和对象(二)

类和对象(二)

  • 一:封装
    • 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());

    }
}

类和对象(二)_第1张图片
我们发现这三个同学的上课班级都是相同的,都是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张图片

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张图片

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);
        // 创建了两个对象实例代码块和构造方法执行了两次,
        // 而静态代码块只会执行一次

    }
}

类和对象(二)_第4张图片

你可能感兴趣的:(Java基础语法,java,开发语言)