1 小序

类:类是一个模板,描述一类对象的行为和状态;用程序语言描述,即行为用方法(函数)表征,状态即属性用变量(类变量,实例变量)表征.比如人类,行为可以有爬,走,跑,状态可以有姓名,年龄,性别等.
对象:对象是类的一个实例,有状态和行为.通过人类建立一个object,即建立一个实在的个体,如xindaqi,他可以爬,走,跑,名字是xindaqi等.
类本身是无"生命",只有放在一个个object上才会大放光彩,我们看到的也是一个个object,如人类,提到人类,会想到人类的各种行为和成功案例,但是这些都是在个体上实现的,如Jack是成功的,她是继承了人类的基本特性后,实现梦想,创造价值的.
所以需要实例化去实现梦想.个体就是实例化出来实现梦想的"生命",他在类赋予的能力上,进行创造.
Ubuntu编译与运行:
编译

javac Test.java
运行
java Test

2 构造方法

每个类都有一个构造方法,创建对象时,至少要调用一个构造方法;
构造方法名称必须和类同名,一个类可以有多个构造方法;
功能:初始化类;

public class Test{
	public Test(String name){
		//构造方法:用于初始化类
		System.out.println("Author:"+ name);
	}
	public static void main(String []args){
		// 实例化test_a,并进行初始化
		Test test_a = new Test("xin daqi");
	}
}

3 访问实例变量和方法

3.0 源文件

源文件即后缀为java的文件,*.java;
规则:

一个源文件只能有一个public类;
一个源文件可以有多个非public类;
源文件名称和public类名一致;
如果类定义在某个包中,package语句在首行;
源文件含有import语句,放在package与类定义之间;

3.1 Demo

源文件:Test.java

public class Test{
	// 实例变量
	String job_show;
	// 构造方法
	public Test(String name){
		System.out.println("Author:"+name);
	}
	//方法
	public void setJob(String job){
		job_show = job;
	} 
	public String getJob(){
		// System.out.println("Author job:"+job_show);
		return job_show;
	}
	public static void main(String []args){
		//创建对象:实例化+初始化
		Test test_new = new Test("xin daqi");
		//访问方法
		test_new.setJob("Coder");
		// 新建局部变量
		String output_1, output_2;
		// 访问方法
		output_1 = test_new.getJob();
		// 访问实例变量job_show
		output_2 = test_new.job_show;
		System.out.println("Job from function:"+output_1);
		System.out.println("Job from variable:"+output_2);
	}
}

3.2 Result

Author:xin daqi
Author job:Coder
Job from function:Coder
Job from variable:Coder

4 继承

继承是类间变量和方法的复用,避免代码冗余,增强可读性.
现有两个类,C1和C2.
C1继承C2,则约定:C2是父类,C1是子类,好比父子,父亲的财产(C2)由儿子(C1)继承.

4.1 单继承

单继承即一个子类只能继承一个父类,使用关键字extends.

4.1.0 公共父类

Human.java

// 创建包human
package human;
// 建立公共父类Human
public class Human{
	String name;
	String sex;
	public void crawl() {
		System.out.println("Human can crawl!");
	}
	public void walk() {
		System.out.println("Human can walk!");
	}
	public void run() {
		System.out.println("Human can run!");
	}

	public void setName(String names) {
		name = names;
	}
	public String getName() {
		return name;
	}

	public void setSex(String sexs) {
		sex = sexs;
	}
	public String getSex() {
		return sex;
	}
}

4.1.2 子类

Person.java

// 导入父类package.class_name
import human.Human;
// 子类Person继承父类Human,extends关键字继承
public class Person  extends Human {
	public static void main(String []args) {
		String name, sex;
		Person xin = new Person();
		xin.setName("xindaqi");
		xin.setSex("Male");
		name = xin.getName();
		sex = xin.getSex();
		System.out.println("Author name is :"+name);
		System.out.println("Author sex is :"+sex);
	}
}

4.1.3 文件结构

xinPrj
   |-- java
      |-- lesson2
         |-- Human.java
         |-- Person.java

4.1.4 Compile

# 编译Human.java,在根目录下生成human包
javac -d . Human.java
# 编译Person.java
javac Person.java
# 执行
java Person

4.1.6 Result

Author name is :xindaqi
Author sex is :Male

4.1.7 最终目录结构

xinPrj
   |-- java
      |-- lesson2
         |-- Human.java
         |-- Person.class
         |-- Person.java
         `-- human
         	`--Human.class

4.1.8 解析

子类继承父类,需分别建立公共父类和子类;
父类是独立的文件,需要建立包package;
package的编译使用命令javac -d . Human.java,该命令生成的包路径为:/home/xdq/xinPrj/java/lesson2/human/Human.class,这样才能引用成功;
子类引入包使用import,实现继承;
javac Human.java编译生成的class会在根目录下生成,/home/xdq/xinPrj/java/lesson2/Human.class,这不能导入成功;

4.2 "多"继承

不是真正意义上的多继承,而是继承接口interface,一个类可以同时继承多个接口,接口间使用逗号分隔,使用关键字implements实现.

4.2.1 接口的说明

接口不是类,因此接口中的方法(即函数)只需给出函数名称,无需写功能,即没有函数体;
接口中的方法必须在继承的类中全部重新定义功能,否则写成抽象类;
接口不能被实例化,即不能new,但是可以被实现;

4.2.2 接口文件目录

|-- lesson3
    |-- Attributes.java
    |-- Functions.java
    |-- Person.java

4.2.3 接口Attributes

Attributes.java

// 建立包attributes
package attributes;
// 定义接口Attributes
public interface Attributes {
	// 接口变量,默认为static 常量
	String name = "xindaqi";
	String sex = "male";
	// 接口方法,只有函数名,无函数体
	public String getName(String names);
	public String getSex(String sexs);
}

4.2.4 接口Functions

Functions.java

// 建立包functions
package functions;
// 定义接口Functions
public interface Functions {
	// 接口方法,只有函数头,无函数体
	public void crawl();
	public void walk();
	public void run();
}

4.2.5 子类Person