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面向对象的四大特征
- 抽象
- 封装
- 继承
- 多态
抽象
定义一个类的时候,实际上就是把一类事物的共有的属性和行为提取出来,形成一个模板,这种研究问题的方法称之为抽象。
封装
就是把抽象出来的数据和对数据的操作封装在一起,数据被保护在内部,程序的其他部分只有通过被授权的操作(成员方法)才能对数据进行操作。
其实以后编程,我们要尽量的把成员变量做成私有的。
比如对电视机的操作就是典型的封装。
这里怎么封装呢??
就是通过访问控制修饰符。
比如:一个不能访问别人工资、年龄的类
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种控制修饰符
- public 对外公开
- protected 对子类和同一个包中的类公开
- 不写,也就是默认情况下,对同一个包的类公开
- private 只有类本身可以访问,不对外公开
包
引入:假如两个程序员共同开发一个java项目,但是两个人定义某个类的类名都叫Dog,怎么办?
这时候可以将其放在不同的包里面。
包的3大作用
1. 区分相同名字的类
2. 当类很多时,可以很好地管理类
3. 控制访问范围
打包命令
package com.xiaoming;
一般来讲,这个命令放在最开始的地方。
一般名字都是小写,然后用点分隔开
常用的包
java.lang.* 包自动引入
java.awt.* 窗口工具包
java.net.* 网络开发包
java.util.* 工具包
用的时候引入即可:
import java.util.*