目录
this关键字
java当中this关键字的四个用法:
1.this关键字可以调用当前类的属性。
2.this关键字可以调用当前类的方法。
3.this关键字可以调用当前类的构造方法。
4.this关键字能够表示当前对象本身。
假设有一个学生类定义如下:
public class Student {
String name; //学生的姓名
int age; //学生的年龄
String sex; //学生的性别
创建构造方法,为上面三个成员变量赋值:
public Student(String name,int age,String sex){
this.name=name;
this.age=age;
this.sex=sex;
}
在 Teacher 类的构造方法中使用了 this 关键字对属性 name、salary 和 age 赋值,this 表示当前对象。this.name=name语句表示一个赋值语句,等号左边的 this.name 是指当前对象具有的变量 name,等号右边的 name 表示参数传递过来的数值。
创建一个main()方法对Student进行测试:
public static void main(String[] args){
Student student=new Student();
System.out.println("学生信息如下:");
System.out.println(student.name);
System.out.println(student.age);
System.out.println(student.sex);
}
当一个类的属性(成员变量)名与访问该属性的方法参数名相同时,则需要使用 this 关键字来访问类中的属性,以区分类的属性和方法中的参数。
如果方法里有局部变量和成员变量同名,但程序有需要在该方法里访问这个被覆盖的成员变量,则需要使用this前缀。
public class Account {
static double roi=0.035;
String account;
double balance;
public Account(String account,double balance){
this.account=account;
this.balance=balance;
}
public double annualInterest(){
double interest=0.0;
interest=this.balance*roi;
return interest;
}
}
这是一个计算利息的小问题。
定义public Account(String account,double balance){}来为成员变量赋值,但是成员变量名与方法参数名相同 ,且annualInterest()方法需要访问被覆盖的成员变量,这时候就要使用this关键字。
以下为测试函数:
public class TextAccount {
public static void main(String[] args){
Account account1=new Account("11111",1000);
double a = account1.annualInterest();
System.out.println("账户:"+account1.account+"年利息为: "+a);
Account account2=new Account("22222",2000);
double b = account2.annualInterest();
System.out.println("账户:"+account2.account+"年利息为: "+b);
}
}
由于不是静态成员方法,所以仍需使用对象来进行访问。
以下为输出结果:
static关键字
static被称为静态,可以修饰成员变量,成员方法,代码块,内部类。
被static关键字修饰的成员的特点:
1.随着类的加载而加载。
2.优先于对象存在。
3.可以直接用类名调用,不必创建对象。
使用static关键字的注意事项:
1.静态方法只能访问静态变量,不能访问非静态变量;非静态成员方法可以使用静态成员变量。
2.静态方法中不能使用this,super关键字。
提出一个问题什么时候使用静态的成员变量或静态的成员方法?
1.静态变量:
首先我们要清楚,静态---指的是在内存中只有一份。所以我们就要分析,对象中成员变量的只都是相同的时候,这个成员变量就可以被静态修饰。只要数据在对象是不同的,是特有的数据,就不能被静态修饰。举个例子吧:
public class Chinese{
String name; //每个中国人的名字都是不一样的
static String country; //每个中国人的国籍都是一样的,所以可以被静态修饰。
}
2.静态方法:
当方法中不需要非静态的成员变量时,我们可以将方法设计为静态方法。
public class MyMath {
public static int max(int x,int y){
int z= (x>y)?x:y;
return z;
}
public static double max(double x,double y){
double z=(x>y)?x:y;
return z;
}
public static int max(int x,int y,int z){
int a=(x>y)?x:y;
int b=(a>z)?a:z;
return b;
}
public static double max(double x,double y,double z){
double a=(x>y)?x:y;
double b=(a>z)?a:z;
return b;
}
}
比如上述代码 没有成员变量也可以用静态修饰。
statice关键字的特点:
1、static 是修饰符,可以修饰成员和方法。
2、static修饰的成员被所有的对象所共享。
3、static优先于对象存在,因为static的成员随着类的加载就已经存在了。
4、static修饰的成员多了一种调用的方式,用类名直接调用。类名.静态成员。
5、static修饰的是共享数据,对象中存储的是特有的数据。
静态成员变量与非静态成员变量的区别?
二者的调用方式不同:
非静态成员变量只能通过创建对象,通过对象名来调用。
静态成员变量可以通过对象调用,也可以通过类名直接调用。
数据储存位置不同:
非静态成员变量数据存储在堆中。 堆是用来储存java程序创建的对象的
静态成员变量数据存储与方法区中。方法区是用来储存类信息的。
代码块
代码块在类中声明,类似一个没有名称的方法体(代码块),
代码块分为实例块和静态块。
因为代码块没有名字,只能在满足条件时,自动由系统调用。
//实例代码块
{
//任何java语句
}
//静态代码块
static {
//任何java语句
}
}
实例代码块:在创建对象时,被自动调用执行。
静态代码块:在类被加载是,被自动调用执行。
类什么时候被加载:
在一个类中使用main方法,类会被加载。
通过类名访问类的静态成员,类会被加载。
创建对象,也会加载类。
举个例子吧:
public class Demo {
{
System.out.println("实例代码块1");
}
{
System.out.println("实例代码块2");
}
static {
System.out.println("静态代码块1");
}
static {
System.out.println("静态代码块2");
}
public static void text(){
}
public Demo(){
System.out.println("构造方法1");
}
}
测试函数:
public class TextDemo {
public static void main(String[] args){
Demo.text();
new Demo();
}
}
运行结果为:
静态代码块:只执行一次------------------整个main方法中只输出一次。
构造代码块:每次调用构造方法都执行 。
从运行结果我们可以发现实例代码块,静态代码块和构造方法的运行顺序。
静态代码块---->实例代码块---->构造方法