韩顺平 java 第八讲第九讲 this、类变量、类方法、封装

this

public class Demo{
    public static void main(String []args){

    }
}

class Person{
    int age;
    String name;

    public Person(int age, String name){
        this.age = age; //用了this，可读性更好了！
        this.name = name;
    }
    public void showInfo(){
        System.out.println("name is:" + name);
    }
}

• this 是属于一个对象的，不是属于类的
• this 只能在类定义的时候用，不能在外部用。

---

类变量

一群小孩在玩雪人，不时有人加入，问一段时间之后，有多少个小孩？

public class Child{
    int age;
    int name;
    static int total = 0;
    //total 是静态变量，它可以被任何一个对象访问。

    public Child(int age, String name){
        this.name = name;
        this.age = age;
    }
    public void joinGame(){
        total++;
        System.out.println("有一个小孩加入了~");
    }
}

之后用的时候，每次创建新的小孩，然后调用joinGama()函数，最后输出total就可以了！可以用“对象名.total”或者“类名.total”进行访问。

类变量定义

类变量是该类所有的对象共享的一个变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量。

定义语法

访问修饰符  static  数据类型  变量名；
//其实static 也是一种访问修饰符，以后再说

访问方法

类名.类变量名
对象名.类变量名

public class Demo{
    static int i = 1;
    static{
        i++;
    }
    public Demo(){
     i++;
    }

    public static void main(String []args){
        Demo t1 = new Demo();
        System.out.println(t1.i);

        Demo t2 = new Demo();
        System.out.println(t2.i);
    }
}

输出结果是：

3
4

解释：
首先定义Demo类的时候，静态区域块自动被执行一次。
构造函数在产生新的对象的时候执行。

类方法

class Stu{
    int age;
    int name;

    int fee;
    static int totalFee;
    public Stu(int age,String name, int fee){
        this.age = age;
        this.name = name;
        this.fee = fee;
        totalFee += fee;
    }
    public int getTotalFee(){                   //**
        return totalFee;
    }

    public static void main(String []args){
        Stu stu1 = new Stu(22,"Jone",340);
        Stu stu2 = new Stu(21,"Jack",240);
        System.out.println(stu2.getTotalFee());  //##
    }
}

这个写法固然可以，但是产生一个问题就是，所有的类都会创建getTotalFee()这个方法，这样浪费内存。所以，类似于静态变量，就产生了类方法，可以把**处改为

public static int getTotalFee(){

把## 处改为：

System.out.println(Stu.getTotalFee());

这就是静态方法。

java中规则
类变量原则上用类方法去访问。普通方法也可以访问。
类方法不能访问非静态变量。（这点很好想，因为“类名.类方法”这种方式，根本不能指明访问了哪个对象。）

类方法定义

//定义
访问修饰符  static 数据返回类型  方法名（）{}
//使用
类名.类方法名
对象名.类方法名

总结

• 类变量是与类相关的，公共的属性；实例变量属于每个对象个体的属性。
• 类方法是与类相关的，公共的方法；实例方法属于每个对象个体的方法。

java面向对象的四大特征

1. 抽象
2. 封装
3. 继承
4. 多态

抽象

定义一个类的时候，实际上就是把一类事物的共有的属性和行为提取出来，形成一个模板，这种研究问题的方法称之为抽象。

封装

就是把抽象出来的数据和对数据的操作封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的操作（成员方法）才能对数据进行操作。
其实以后编程，我们要尽量的把成员变量做成私有的。
比如对电视机的操作就是典型的封装。
这里怎么封装呢？？
就是通过访问控制修饰符。
比如：一个不能访问别人工资、年龄的类

class Clerk{
    public String name;
    private int age;
    private float salary;

    public Clerk(String name, int age, float salary){
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
    public float getSal(){
        return this.salary;
    }

    public static void main(String []args){
        Clerk clerk1 = new Clerk("小花"，24,222.33f);
        System.out.println("name:" + clerk1.name);
        // System.out.println("salary:" + clerk1.salary);//ERROR! 此时要是想访问薪水，就要通过成员方法来控制和访问私有类型
        System.out.println("salary:" + clerk1.getSal);
        //此处类似于，我们控制电视关闭，不用直接去打开电视机把里面的电源线切断，我们可以通过遥控器来控制电源切断。这就是封装
    }
}

4种控制修饰符

1. public 对外公开
2. protected 对子类和同一个包中的类公开
3. 不写，也就是默认情况下，对同一个包的类公开
4. private 只有类本身可以访问，不对外公开

包

引入：假如两个程序员共同开发一个java项目，但是两个人定义某个类的类名都叫Dog，怎么办？
这时候可以将其放在不同的包里面。

---

包的3大作用
1. 区分相同名字的类
2. 当类很多时，可以很好地管理类
3. 控制访问范围

---

打包命令

package com.xiaoming;

一般来讲，这个命令放在最开始的地方。
一般名字都是小写，然后用点分隔开

常用的包
java.lang.* 包自动引入
java.awt.* 窗口工具包
java.net.* 网络开发包
java.util.* 工具包
用的时候引入即可：

import java.util.*