Java面向对象之类的定义和this引用

首先，需要明确一点，Java不支持多继承，只支持单继承，也就是说一个类只能继承自一个父类。而C++是只是多继承的，多继承会导致很多问题。
Java是一门面向对象的语言，所以具有：单继承，封装性，多态性。封装是指只提供接口，不提供内部数据和具体实现，有效的保证了数据安全性。多态性是指一个接口多种性态，允许一个接口被多个类使用。

类的定义

格式如下

[public][abstract|final]class<class_name>[extends<class_name>][implements<interface_name>] {
    // 定义属性部分
    <property_type><property1>;
    <property_type><property2>;
    <property_type><property3>;
    …
    // 定义方法部分
    function1();
    function2();
    function3();
    …
}

public:表示可以被其他类和程序访问，一个程序的主类必须是public修饰的，否则就完全封闭了。
abstract表示抽象类，抽象类不能被实例化。抽象类中有抽象方法（abstract)修饰，和具体方法。继承抽象类的类必须实现抽象类中的抽象方法。
final表示不能被继承，也就是不能派生新的类。
另外注意到这里abstract和final不能共存。

//classA 不允许被继承
public final class classA{
};
//classB不允许实例化
public abstract class classB{
}

同C++一样，java也有构造函数，如果没有显式定义构造函数，那么系统将会自动生成一个空的构造函数。构造函数没有返回值，函数名和类命相同。构造函数用于初始化例如：

public class student{
	int age; //成员变量
	//构造函数/构造器
	public student(int t_age)
	{
		age = t_age;
	}
}

用new关键字创建一个新的对象

student stu = new student(10);

成员变量和成员函数

成员变量分为：普通成员变量，静态成员变量，常成员变量。
C++中常成员变量是用const修饰的，Java中常成员变量用final修饰，表示该变量初始化之后就不能再修改。
静态成员变量用static关键字修饰，表示不属于某一个对象，而是属于整个类。
另外成员变量的前面可以用public,private,protect修饰

[public|protected|private][static][final]<type><variable_name>

例如创建一个Student类

public class Student{
	public String name; //公开成员变量，初始化为null
	final int sex = 0; //常成员变量,初始化为0，不能修改
	private int age; //私有成员变量，必须创建get和set方法，否则报错，eclipse可以自动创建
	static int num ; //静态成员变量，自动初始化为0
	
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

注意：方法的名称第一个单词首字母小写，第二个单词首字母大写，例如getAge,setAge

this 关键字

Java中的this是引用，不是指针，因此调用类中的成员变量或称成员函数的时候用点，不是箭头。例如

this.age = 0;

同C++一样，当形参和属性名一样时，必须用this区分开。

public class Student{
	private String name;
	private int age;
	//构造函数中的形参和属性重名
	Student(String name, int age)
	{
		this.age = age;
		this.name = name;
	}
	//如果形参不重名，可以不用this关键字区分
	Student(String t_name, int t_age)
	{
		name = t_name;
		age = t_age;
	}
}

注意到一个现象，那就是可以在Java的成员函数中定义当前类的对象。

public class HelloWorld{
	public void jump()
	{
		System.out.println("Jumping...");
	}
	public void run()
	{
		HelloWorld d = new HelloWorld(); //在类的定义中实例化当前类的对象
		d.jump();
		System.out.println("Running...");
	}
	public static void main(String[] args)
	{
		HelloWorld h = new HelloWorld();
		h.run();
	}
}
//输出结果
//Jumping...
//Running...

另外，在C++ 中也是可以的

#include<iostream>
using namespace std;

class student{
	public:
		int age;
	public:
		student(){};
		student(int t_age):age(t_age){};
		student func(int x)
		{
			student stu; //在类的定义中实例化当前类的对象
			stu.age = x;
			return stu; //注意不能返回指针或者引用，因为这是局部变量/临时变量
		}
}; 

int main()
{
	student stu(10);
	student stu2; 
	stu2 = stu.func(0);
	cout<<"stu2.age = "<<stu2.age<<endl; //stu2.age = 0
	return 0;
}

原因应该是在于在一个类中，每个对象的属性不同，但是方法是相同的，只要属性已经完全定义了，那么就可以确定一个类了。于是可以在类的定义中实例化当前类的对象。如果尝试在实例化对象之后再添加属性，那么必然报错。
另外区分一点，当C++中new一个对象的时候，如果没有初始化参数，是不带小括号的：student* stu = new student;
而Java中需要带括号，就算没有传入初始化参数，调用默认构造函数/构造器。

student stu = new student(); 

在构造函数中使用this()方法

public class HelloWorld{
	private String name;
	public HelloWorld()
	{
		this("zhangsan");
	}
	public HelloWorld(String string) {
		// TODO Auto-generated constructor stub
		name = string;
	}
	public void print()
	{
		System.out.println("name = "+name);
	}
	public static void main(String[] args)
	{
		HelloWorld h = new HelloWorld();
		h.print(); //name = zhangsan
		HelloWorld h2 = new HelloWorld("Jack");
		h2.print(); // name = Jack
	}
	
}

注意 ：this( ) 不能在普通方法中使用，只能写在构造方法中。在构造方法中使用时，必须是第一条语句。
这里无参构造函数中调用this（）方法实际上相当于调用了带一个参数的构造函数。

总结

this关键字的三个作用：this.属性，this.方法，this()用在构造函数中进行初始化，此时的this完全等于当前对象名。传入参数相当于调用带参数的构造函数。
另外注意，static修饰的成员变量和成员函数不能用this,因为是属于类的，不属于某个对象，没有this引用。同C++中没有this指针一个道理。