一、Java的对象和类
Java作为一种面向对象语言，有类、对象、实例、方法、继承、重载、抽象、多态、封装的基本概念。
1、类
(1)类是Java的核心和本质，封装、继承、多态和抽象几大特性都离不开类，可以把类看成是对象的模板。
(2)类中的变量。包括局部变量、全局变量和类变量。
局部变量：定义在方法中的变量，作用域为本方法中。
成员变量：定义在类中方法外的变量，作用域为本类。
类变量(静态变量)：类变量也声明在类中，方法体之外，但必须声明为static类型(static表示全局的、静态的)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
/**
 * @author shen
 * @desc test
 * @date 2016年7月10日
 */
public class Book {
	
	static int num = 0;//类变量
	static final String type = "children";//用final变量只能被初始化一次，之后不能再赋值
	
	String str="this is a book";//实例变量
	public void borrow(){
		int i = 0;//局部变量
	}
	
	public static void rend(){
		//静态方法，无需创建对象就能使用
		System.out.println("this is a static method.");
	}
	
	public static void main(String[] args) {
		rend();//直接调用
		System.out.println("this is a main function.");
	}
	
	static {
		//静态代码块，类加载时调用
		System.out.println("this is a static code block.");
	}
}


结果：
这里写图片描述
(3)构造方法
每个类都有构造方法，如果没有显式定义构造方法，编译器会默认为类创建一个不带参的构造方法(若子类继承有带参构造方法的父类，需要显式调用父类构造方法)。
构造方法名必须与类名相同，一个类中可以有多个构造方法(参数不同)，创建对象时至少一个构造方法。
2、对象
对象的创建：声明，声明类的类型和名称；实例化，使用new创建一个对象；初始化，创建对象时会调用构造方法初始化对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
/**
 * @author shen
 * @desc test
 * @date 2016年7月10日
 */
public class User {
	
	private String type = "student";
	private String name;//私有属性只能在本类获取到
	private int age;
	public int height;//公有属性其他类也能获取到
	
	public int getHeight() {
		return height;
	}

	public void setHeight(int height) {
		this.height = height;
	}

	//Javabean的规范，通过getter和setter对数据进行封装
	public String getType() {
		return type;
	}

	public void setType(String type) {
		this.type = type;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public User(){
		//无参构造方法
	}
	
	public User(String num){
		//带参构造
	}
	
	public User(String name,int age){
		//参数个数不同的构造
		this.name = name;
		this.age = age;
	}
	
	//普通方法
	public void borrow(String bookName){
		//bookName为方法体中的局部变量
		System.out.println(this.name + " borrow a book :" + bookName );
	}
	
	public static void main(String[] args) {
		
		User jack = new User();//默认的无参构造创建对象
		jack.age = 20;//私有属性，只能在本类使用这种方式
		jack.name = "jack";
		
		//公有属性其他类也能获取到，暴露了数据细节。将属性定义为private并使用getter和setter方法隐藏数据的细节(Java的封装特性)
		jack.height = 170;
		jack.borrow("Java code");
		System.out.println(jack.type);
		
		User jane = new User();
		jane.setAge(19);//Javabean规范，实现对数据细节的隐藏封装
		jane.setName("jane");
		jane.setType("teacher");
		jane.borrow("C prime plus");
		System.out.println(jane.type);
		
		User tom = new User("tom", 21);//使用带参构造创建对象
		tom.borrow("C++ prime plus");
	}
	
	
}

结果：
这里写图片描述

二、基本规则
1、一个源文件中只能有一个public类，可以有多个非public类，并且public类名必须与源文件名称相同
2、包与import语句
(1)Java包主要是用来给类分类，创建包使用package语句实现。包也有基本的命名规则，根据公司或个人名、项目名、模块名等命名。
(2)import语句。import语句就是用来提供一个合理的路径，使得编译器可以找到某个类，有点类似与c的头文件和c++的命名空间。