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
Person.java
// 引入包attributes的Attributes接口
import attributes.Attributes;
// 引入包functions的Functions接口
import functions.Functions;
// 公共类Person,继承接口Attributes和Functions
public class Person implements Attributes, Functions {
// 定义实例变量
String name_p,sex_p;
// 重定义方法getName()
public String getName(String names) {
name_p = names;
return name_p;
}
// 重定义方法geSex()
public String getSex(String sexs) {
sex_p = sexs;
return sex_p;
}
// 重定义方法crawl()
public void crawl() {
System.out.println(this.getName("xinerqi")+" can crawl!");
}
// 重定义方法walk()
public void walk() {
System.out.println(this.getName("xinerqi")+" can walk!");
}
// 重定义方法run()
public void run() {
System.out.println(this.getName("xinerqi")+" can run!");
}
// 程序主入口
public static void main(String []args) {
// 局部变量
String output_name, output_sex;
// 新建对象,体现多态,此时Person好比插座
//插座有两相接口和三项接口,实现不同功能
// 使用Attributes接口定义Person类功能
Attributes xin = new Person();
// 使用Functions接口定义Person类功能
Functions xin_2 = new Person();
// Attributes功能
output_name = xin.getName("xindaqi");
output_sex = xin.getSex("Male");
System.out.println("Author name is:"+xin.name);
System.out.println("Author sex is:"+xin.sex);
System.out.println("Author's name:"+output_name);
System.out.println("Author's sex:"+output_sex);
// Functions功能
xin_2.crawl();
xin_2.walk();
xin_2.run();
}
}
4.2.6 编译&运行
# 编译
javac -d . *.java
# 运行
java Person
4.2.7 结果
Author name is:xindaqi
Author sex is:male
Author's name:xindaqi
Author's sex:Male
xinerqi can crawl!
xinerqi can walk!
xinerqi can run!
4.2.8 最终文件
|-- lesson3
|-- Attributes.java
|-- Functions.java
|-- Person.class
|-- Person.java
|-- attributes
| `-- Attributes.class
`-- functions
`-- Functions.class
5 总结
- 类和对象是Java基础,着重理解;
- 继承实现代码复用,包实现模块化;
- Java本是单继承,但可以使用接口实现"多继承";
- 接口继承,体现Java多态,同一个类可用不同接口建立对应的功能;
[参考文献]
[1]https://www.linuxidc.com/Linux/2018-10/155020.htm
[2]http://www.runoob.com/java/java-object-classes.html
[3]https://www.jb51.net/article/129462.htm