从头开始学Java--类和对象

一.啥也不说了，先来个helloworld

public class Hello {
	public static void main(String[] args)
	{
		System.out.println("hello world");
	}
}

Java不像C++那样“用C++的语法，写C语言的代码”，连Helloworld都要封装到一个类里面，彻底的面向对象。个人感觉十分有助于培养面向对象的思维方式。最开始学C到用C++，感觉总是不彻底的面向对象，写着写着就变成了结构化编程。这下好了，想不写一个类都不成！

要点： 1.main方法是程序的入口点，由java虚拟机调用，必须按照格式书写。

2.main方法属于static方法，即不创建对象也可调用的方法。

3.System.out.print与System.out.println为输出函数，类似与cout，都可以接受输出的内容，包括一些特殊字符（如\n），前者是输出，后者是输出一行（自带换行功能）。System是类名，out是一个字段，System.out是java提供的标准输出对象，print与println为两个方法。

语法部分看过了一些，跟C/C++大概差不多，所以就不记录了。还是记下来一些Java的特性。

二.来一个类

class Myclass1 {
	private int value;
	private String name;

	public void setValue(int v)
	{
		value = v;
	}
	public int getValue()
	{
		return value;
	}
	public void setName(String s)
	{
		name = s;
	}
	public String getName()
	{
		return name;
	}
}

public class TestMyClass1
{
	public static void main(String[] args)
	{
		Myclass1 myclass1 = new Myclass1();
		myclass1.setName("hello");
		myclass1.setValue(1);
		System.out.println("value is " + myclass1.getValue() + " name is " + myclass1.getName());
	}
}

跟C++的差不太多，只是main函数也是需要封装在一个类里面。而且main函数也是需要有固定的格式。

要点： 1.java类命名规范：每个单词首字母大写，eg：TestMyClass

2.java文件命名规范：  java文件名 = 公有类名 + .java。一个.java文件中可以有多个类，但是只能有一个公有类。

3.java变量&函数命名规范：常量全大写eg： MAX_VALUE，函数名第一个单词小写，后面单词第一个字母大写eg：getValue()。

三.引用类型变量

java中除了少数的几个原始数据类型，如int,char, float等，其他的变量都为引用数据类型。

所谓引用数据类型，就是在内存中建立一个对象，用一个变量引用这个对象。

例如：Myclass1 myclass1 = new Myclass1();

前半句 Myclass1 myclass1 就是创建了个Myclass1类型的引用变量，但是这个变量并没有实际的对象。此时myclass1 = null.

后半句new  Myclass1()，调用了类的构造函数，产生了一个对象。并且用前面的myclass1引用这个对象。

这里面 = 赋值的仅为内存地址值，并不是将对象赋给引用类型的变量。只是让引用变量可以找到内存中的对象。

一个例子：

class Myclass {
	private int value;
	private String name;

	public Myclass(int v, String n)
	{
		value = v;
		name = n;
	}
}

public class TestMyClass
{
	public static void main(String[] args)
	{
		Myclass myclass1 = new Myclass(1, "zhang");
		Myclass myclass2 = new Myclass(1, "zhang");
		Myclass myclass3 = myclass1;
		System.out.println(myclass1 == myclass2);
		System.out.println(myclass1 == myclass3);
	}
}

结果如下：

两个内容都一样的对象，却不相等。可见，对于两个引用类型的变量，判断 == 是判断两个引用类型的变量是否指向一个相同的对象。

上面程序可以用下图表示：

要点： 1.引用类型的变量，存储的并不是实际的对象。而是对象的地址。 = 赋值也只是将地址赋值给另一个引用类型的变量。内存中对象仍然只有一份。

2.即使创建的两个对象内容完全相同，用 == 判断的也是对象的地址是否相同，所以只要不是两个引用类型变量指向同一个对象，都是不相等的。

3.如果要判断两个对象内容是否相等，可以重写equals方法，或者重载equals方法。

四.构造函数&类的初始化块

看一个例子：

class InitClass
{
	//flag默认值
	public int flag = 100;
	//类的初始化块
	{
			flag = 200;
			filed = 200;
	}
	//filed默认值
	public int filed = 100;
	
	//无参数构造函数
	public InitClass()
	{
		
	}
	//重载：带参数构造函数
	public InitClass(int falg, int filed)
	{
		this.flag = falg;
		this.filed = filed;
	}
	
}

public class InitTest {
	public static void main(String[] args)
	{
		InitClass initclass1 = new InitClass();
		System.out.println("flag: " + initclass1.flag + " filed:" + initclass1.filed);
		
		InitClass initclass2 = new InitClass(300, 300);
		System.out.println("flag: " + initclass2.flag + " filed:" + initclass2.filed);
	}
}

输出如下：

要点： 1.如果不写构造函数，系统提供无参数的默认构造函数。只建立对象，不赋值。如果定义了构造函数，那么系统将不提供默认构造函数。如果需要无参数构造函数则需要自己写。可以重载构造函数，提供不同参数的构造函数。

2.初始化时执行的顺序：  第一步执行成员定义，有定义时默认赋值和初始化块，同时有这两个的时候，两者按照顺序执行。第二步执行构造函数。

五.类的静态字段&静态方法

举个栗子：

class StaticDemo
{
	//静态成员属性
	static int value = 100;
	//静态初始化块
	static 
	{
		value = 200;
	}
	//静态方法访问静态成员属性
	public static void staticPrint()
	{
		System.out.println(value);
	}
}

public class StaticTest {
	public static void main(String[] args)
	{
		//直接访问静态属性
		System.out.println(StaticDemo.value);
		
		//建立对象，通过对象访问静态成员属性
		StaticDemo staticdemo = new StaticDemo();
		System.out.println(staticdemo.value);
		
		//直接访问静态方法
		StaticDemo.staticPrint();
	}
}

要点： 1.静态成员变量或方法可以通过两种方式访问。一种是直接用类名.属性（或方法），一种是建立对象，通过对象.属性（或方法）。但是推荐直接使用类名调用。

2.静态成员函数只能访问静态成员变量，不能访问非静态的成员变量。

3.静态初始化块的调用与初始化块调用一样。但是静态初始化块只执行一次。一个类只有一份静态成员，不管建立了几个对象。