Java面向对象

目录

this关键字

static关键字

代码块

---

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方法中只输出一次。

                          构造代码块：每次调用构造方法都执行 。

 从运行结果我们可以发现实例代码块，静态代码块和构造方法的运行顺序。

静态代码块---->实例代码块---->构造方法