1 this 关键字（重点）
对于this关键字来说在java中是使用比较频繁的一个关键字,this关键字在java中代表三个意义：
1 表示本类的属性
2 表示本类的方法
3 表示当前对象
1.1this表示本类的属性
在讲解之前，首先观察一下如下程序
范例：观察程序
class Person
{
private String name;
private int age;
public Person(String n,int a){
name=n;
age=a;
}
public String getInfo(){
return "姓名"+name+"年龄"+age;
}
}
public class TestDemo02
{
public static void main(String[]args){
Person per=new Person("张三",20);
System.out.println(per.getInfo());
}
}
以上的程序，通过构造方法进行赋值，并且调用getInfo()方法，返回对象的信息,对于以上程序的构造方法如下
public Person(String n,int a){
name=n;
age=a;
}
对于以上的构造方法，实际如果把参数名称改为与属性名称一致之后，发现赋值并不能成功
范例：使用this关键字代表本类的属性
class Person
{
private String name;
private int age;
public Person(String name,int age){
this.name=name;
this.age=age;
}
public String getInfo(){
return "姓名"+name+"年龄"+age;
}
}
public class TestDemo02
{
public static void main(String[]args){
Person per=new Person("张三",20);
System.out.println(per.getInfo());
}
}
通过以上的代码，使用了this关键字，则在进行构造方法赋值的时候，就不会出现就近原则的问题
1.2 调用本类方法
在一个类中就存在两种方法，分别为普通方法，构造方法,如果要调用本类的方法也就分为了两种形式：
1 调用本类的普通方法：如果调用的是本类中的普通的方法，可以使用this.方法()调用
2 调用本类的构造方法：在一个构造方法中调用其他构造方法直接使用this() 调用
假设现在一个类中存在三个构造方法(无参，有一个参数和两个参数的),要求实例化对象的时候，无论是调用哪个构造方法都会执行输出一句话
范例：实现三个构造方法
class Person
{
private String name;
private int age;
public Person(){
System.out.println("一个新的对象Person产生了");
}
public Person(String name){
System.out.println("一个新的对象Person产生了");
this.name=name;
}
public Person(String name,int age){
System.out.println("一个新的对象Person产生了");
this.name=name;
this.age=age;
}
public String getInfo(){
return "姓名"+name+"年龄"+age;
}
}
public class TestDemo02
{
public static void main(String[]args){
Person per=new Person("张三",20);
System.out.println(per.getInfo());
}
}
以上的代码虽然功能上是实现了，但是代码的重复率太高了,如果假设输出的这一行代码为50行,程序的设计的目标是代码越少越好,此时就可以使用this()方式来完成
范例：使用this调用本类的构造
class Person
{
private String name;
private int age;
public Person(){
System.out.println("一个新的对象Person产生了");
}
public Person(String name){
this(); //调用无参的构造方法
this.name=name;
}
public Person(String name,int age){
this(name); //调用一个参数的构造方法
this.name=name;
this.age=age;
}
public String getInfo(){
return "姓名"+name+"年龄"+age;
}
}
public class TestDemo02
{
public static void main(String[]args){
Person per=new Person();
System.out.println(per.getInfo());
}
}
以上的程序，使用了this关键字完成了构造方法的调用，但是需要注意的在进行构造方法调用的时候，也需要注意调用格式的
范例：错误的调用方式
public Person(){
System.out.println("一个新的对象Person产生了");
}
public Person(String name){
this(); //调用无参的构造方法
this.name=name;
}
public Person(String name,int age){
this.name=name;
this.age=age;
this(name); //错误的调用，必须放在构造方法的首行
}
如果一个类中存在多个构造方法,并且都使用了this互相调用，那么在调用的时候必须保证其中一个构造方法没有被其他方法调用，给出一个程序的出口
class Person
{
private String name;
private int age;
private String sex;
public Person(String name){
this(name);
}
public Person(String name,int age){
this(name); //调用一个参数的
}
public Person(String name,int age,String sex){
this(name,age); //调用两个参数的
}
public String getInfo(){
return "姓名"+name+"年龄"+age;
}
}
public class TestDemo02
{
public static void main(String[]args){
Person per=new Person("张三");
System.out.println(per.getInfo());
}
}
以上的代码为错误的代码，主要的原因是构造方法之间相互调用，没有给程序一个出口互相递归
1.3 this表示当前对象
当前对象指的是当前正在调用本方法的操作对象
范例：验证this为当前对象
class Demo
{
public void print(){
System.out.println("当前对象"+this);
}
}
public class TestDemo02
{
public static void main(String[]args){
Demo demo01=new Demo();
Demo demo02=new Demo();
System.out.println(demo01); //直接输出对象
demo01.print(); //调用方法 输出this
System.out.println(demo02); //直接输出对象
demo02.print(); //调用方法 输出this
}
}
以上的程序，从运行中可以发现，当某个对象进行this输出的时候，调用的对象与this的输出内存地址完全一致，所以this代表当前使用的对象
2 对象的比较（掌握）
之前学习过的比较的概念在String中的eqauals方法中提到过，当时比较是字符串的内容是否相等，现在用户自己定义一个类，然后也需要进行两个类的实例化对象比较是否相等那如何比较呢？
两个对象之间的比较就是依次取比较对象之间的属性
范例： 对象的比较形式（形式一）
class Person
{
private String name;
private int age;
public Person(String name,int age){
this.name=name;
this.age=age;
}
public void setName(String name){
this.name=name;
}
public void setAage(int age){
this.age=age;
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
}
public class TestDemo02
{
public static void main(String[]args){
Person per1=new Person("张三",22);
Person per2=new Person("张三",20);
if(per1.getName().equals(per2.getName())&&per1.getAge()==per2.getAge()){
System.out.println("是同一个对象");
}else{
System.out.println("不是同一个对象");
}
}
}
以上的代码，功能是实现了，但是出于面向对象的设计考虑，不合适，因为比较的操作应该是一个对象具备的功能，而现在比较行为是由第三方main方法来完成的,应该由类完成
范例：在类中定义比较方法
class Person
{
private String name;
private int age;
public Person(String name,int age){
this.name=name;
this.age=age;
}
public void setName(String name){
this.name=name;
}
public void setAage(int age){
this.age=age;
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
public boolean compare(Person per){
if(per==null){
return false; //传入的对象为null 直接返回false
}
if(this==per){
return true; //地址相同 是同一个对象
}
if(this.name.equals(per.name)&&this.age==per.age){
return true;
}
return false;
}
}
public class TestDemo02
{
public static void main(String[]args){
Person per1=new Person("张三",20);
Person per2=new Person("张三",20);
if(per1.compare(per2)){
System.out.println("对象相同");
}else{
System.out.println("对象不同");
}
}
}
以上的程序在类的内部定义了一个compare方法,而此方法的功能就是进行对象的比较
3 static 关键字（重点）
对于这个static关键字来说，一直被使用从未被了解,使用static关键字可以定义类中的属性与方法
3.1 使用static定义属性
在一个类中分为普通方法， 构造方法以及属性组成,而每一个对象都拥有自己各自的内容，都是不相同的(保存在不同的堆内存空间中),现在想要定义一个属性做为类的公共属性(所有的对象都可以使用的属性),对于公共的属性就可以使用static关键字来完成
范例：使用static关键字定义属性
class Person
{
private String name;
private int age;
static String city="北京";
public Person(String name,int age){
this.name=name;
this.age=age;
}
public void setName(String name){
this.name=name;
}
public void setAage(int age){
this.age=age;
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
public String getInfo(){
return "姓名"+name+"年龄"+age+"城市"+city;
}
}
public class TestDemo02
{
public static void main(String[]args){
Person per1=new Person("张三",20);
Person per2=new Person("李四",20);
per2.city="上海";
System.out.println(per2.getInfo());
System.out.println(per1.getInfo());
}
}
以上的程序，使用static关键字定义了一个属性,当在主类中某一个对象修改该属性则所有的对象使用该属性的内容全部都被修改
通过以上的画图分析，得出使用static描述的属性存放在全局数据区中，所有对象都指向同一块空间所以当该属性改变的时候，所有对象的使用的该属性全部改变
而对于内存中的区域的划分如下：
栈内存空间： 保存所有对象的名称
堆内存空间： 保存每个对象具体的属性内容
全局数据区： 保存static类型的属性
全局代码区： 保存所有的方法定义
以上的调用，之前使用使用某一个对象来进行static属性的调用，但是该属性属于一个类空间，使用某一个对象来调用是不合适的,该属性应该由类来调用，可以使用类名称.属性的方式来完成
范例：使用类名称调用static属性
public static void main(String[]args){
Person per1=new Person("张三",20);
Person per2=new Person("李四",20);
Person.city="山东"; //类名称.属性的方式 调用static属性
System.out.println(per2.getInfo());
System.out.println(per1.getInfo());
}
总结：
Static定义的属性不在堆内存中保存，而是保存在全局数据区
static定义的属性表示类属性，类属性可以由类.属性名称直接调用
Static属性虽然定义在了类中，但是它可以在没有进行实例化对象的时候进行调用(普通的方法属性是在堆内存空间中，所以必须要对象进行实例化之后才可以使用)
在开发中经常使用还是普通的对象，以及在堆内存中的属性和方法
3.2 使用static定义方法
在定义类的时候普通的方法可以使用static关键字来进行定义，但是一旦使用static关键字来进行普通方法的定义，则该方法就可以在对象没有实例化的时候使用
范例：使用static定义方法
class Person
{
private String name;
private int age;
private static String city="北京";
public Person(String name,int age){
this.name=name;
this.age=age;
}
public static void setCity(String c){
city=c;
}
public static String getCity(){
return city;
}
public String getInfo(){
return "姓名"+name+"年龄"+age+"城市"+city;
}
}
public class TestDemo02
{
public static void main(String[]args){
Person.setCity("上海");
System.out.println(Person.getCity());
}
}
通过以上的程序，可以发现static定义的方法不要对象进行实例化也可以直接调用
关于static定义方法的若干个问题：
1 static定义的方法能否调用非static定义的方法与属性？为什么？
使用static定义的方法是不能调用非static定义的方法与属性的，原因是非static定义的方法与属性需要在对象实例化开辟空间之后才可以被使用，而static定义的方法是可以在对象没有实例化的时候使用
2 非static定义的方法可以调用static定义的方法与属性
总结：1.静态变量或方法不属于对象，依赖类
2.静态变量是全局变量，生命周期从类被加载后一直到程序结束
3.静态变量只有存一份，在静态方法区中存贮
4.静态变量是本类所有对象共享一份
5.建议不要使用对象名区调用静态数据
6.static修饰一个方法，该方法属于类，不属于对象，值接用类名调用。
7.静态方法不能访问非静态属性和方法，只能访问静态的
3.3 理解主方法
对于之前的代码，对于主方法给出的格式如下
public static void main(String[]args){
}
范例：观察代码
public class TestDemo02
{
public static void main(String[]args){
print();
}
public static void print(){
System.out.println("hello world");
}
}
对于以上的代码，如果在没有使用static关键字的时候，则必须通过对象进行实例化之后才可以通过对象调用方法来使用，而在主类中直接运行程序，不需要为主类进行实例化所以主方法是使用static修饰的
对于主方法的关键字存在以下几点：
1 public 是一种访问权限 公共的
2 static 静态的，表示此方法由类名称直接调用
3 void 主方法是一切程序的开始
4 main 主方法的方法名称 执行类的时候JVM默认进行方法名称匹配
5 String args[] 表示的是运行是的参数 用字符串来接收
4 代码块（理解）
代码块在程序中是使用{} 定义起来的一段程序，根据声明的位置，与关键字的不同，代码分为了以下几种：
普通代码块
构造块
静态块
同步块（多线程的时候讲解）
4.1 普通代码块
对于普通的代码块，就是定义方法的代码块
范例：普通代码块
public static void main(String[]args){
if(true){
int i=10; //局部变量
System.out.println("i="+i);
}
int i=100; //全局变量
System.out.println("i="+i);
}
以上的程序，首先定义的 变量i属于if语句的局部变量，而第二次定义的i变量相对于if语句中的变量来说为全局变量 所以两个变量在不同的代码块中不会产生影响
范例：定义普通代码块
public static void main(String[]args){
{
int i=10; //局部变量
System.out.println("i="+i);
}
int i=100; //全局变量
System.out.println("i="+i);
}
4.2 构造块
普通块是定义在普通的方法中，而构造块是定义在构造方法中的
范例：定义构造块
class Person
{
public Person(){
System.out.println("构造方法");
}
{
System.out.println("构造块");
}
}
public class TestDemo02
{
public static void main(String[]args){
new Person();
new Person();
new Person();
}
}
可以发现，构造块的执行顺序是优先于构造方法执行的,每个对象进行实例化的时候都会重复执行构造块的代码，并且优先于构造方法执行
4.3 静态块
静态块是定义在类中，如果一个代码块使用static来进行定义则这个代码块就是为静态块
范例：观察静态块
class Person
{
public Person(){
System.out.println("构造方法");
}
{
System.out.println("构造块");
}
static{
System.out.println("静态块");
}
}
public class TestDemo02
{
public static void main(String[]args){
new Person();
new Person();
new Person();
}
}
静态块，优先于构造块来执行，并且只执行一次,不管有多少个对象实例化,j静态块只会执行一次
5 案例：编写一个登录验证系统
需要定义的类：
负责数据验证的类，不关心数据从哪来
信息采集类，接收输入的数据,调用验证的类
主方法判断结果是否登录成功
首先对于以上的程序开发验证类如下：
class LoginValidate
{
// 该类的功能就是负责数据验证
private String username; //用户名
private String password; //密码
//构造方法
public LoginValidate(String username,String password){
this.username=username;
this.password=password;
}
//验证的功能
public boolean isValidate(){
if("zhangsan".equals(this.username)&&"123".equals(this.password)){
return true;
}
return false;
}
}
定义信息采集类
class Info
{
private String data[] ; //用于接收数据
public Info(String data[]){
this.data=data; //构造方法赋值
this.exit();
}
public void exit(){
if(this.data.length!=2){
System.out.println("输入的参数错误");
System.exit(1) ; //退出程序
}
}
//调用验证的方法
public String getInfo(){
if(new LoginValidate(this.data[0],this.data[1]).isValidate()){
return "登录成功";
}else{
return "登录失败";
}
}
}
编写主程序
public static void main(String[]args){
System.out.println(new Info(args).getInfo());
}
通过以上的案例，就可以把不同的功能划分为不同的类来完成，代码结构更加清晰，可维护性更高
六、总结
1 this关键字：代表本类属性，调用本类方法，代表当前对象
2 static关键字 静态的 属于类空间保存区域可以在对象不用实例化的时候使用
3 代码块：普通代码块，构造块 静态块 执行顺序
