韩顺平 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);    }}

输出结果是：

34

解释：
首先定义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.*