ghostscript java实战

一、面向对象三大特征

1. 类的继承

（1）简介

关键词：extends

public class Guy extends Person

表示Guy类继承Person类
note： Java中一个类只能继承一个父类。

（2）详细示例

class Person{
int age;
int sex;
}
public class Guy extends Person {//通过继承Person类，Guy类也有了age和sex属性，
//but private属性无法继承。
String name;
void print() {
if (sex == 1) {
System.out.println("男");
} else {
System.out.println("女");
}
System.out.println(name);
System.out.println(age);
}
void changeName(Guy temp,String teName)
{
temp.name=teName;
System.out.println("改完名字后："+name);
}
public static void main(String[] args) {
Guy guy =new Guy();
guy.age=12;
guy.name="Test Extends";
guy.sex=1;
guy.print();
guy.changeName(guy,"Test Change Name");
}
}

运行结果

2. 类的封装

（1）简介

封装，也就是对外隐藏。因此：

• 将类属性声明为private（只能在本类中访问）
• 提供公有的setter和getter方法，来访问和更新私有变量的值。

get与set
get方法返回属性值。
set方法设置属性值。

（2）详细示例

private String name;
//get
public String getName(){
return name;
}
//set
public void setName(String name)
{
this.name=name;
}

（3）封装的意义

• 更好的控制类的属性和方法。
• 类变量可以设置为只读或只写。
• 提高灵活性、安全性。

3. 类的多态

（1）简介

多态即“多种形态”，有很多通过继承关联起来的类，就会发生多态性。
继承可以让一个类继承另一个类的属性和方法，多态即可以重写这些方法。

（2）详细示例

class Animal {
public void animalSound() {
System.out.println("动物发出声音");
}
}

class Pig extends Animal {
public void animalSound() {
System.out.println("小猪说: 呜呜");
}
}

class Dog extends Animal {
public void animalSound() {
System.out.println("狗说: 旺旺");
}
}

class MyMainClass {
public static void main(String[] args) {
Animal myAnimal = new Animal(); // 创建一个动物对象
Animal myPig = new Pig(); // 创建一个Pig对象
Animal myDog = new Dog(); // 创建一个Dog对象

myAnimal.animalSound();
myPig.animalSound();
myDog.animalSound();
}
}

运行结果

二、几种特殊的类

1. 内部类

即类中类，目的是将属于同一类别的类放在一起，使代码具有更好的可读性和可维护性。

（1）常规的内部类（public or default）

想要访问常规内部类，需要先创建外部类对象，再创建内部类对象。该类型的内部类可以访问外部类的属性和方法
eg. 创建内部类，实例化并通过内部类方法访问外部类属性。

class OuterClass {
int x = 10;

class InnerClass {
public int myInnerMethod() {
return x;
}
}
}

public class Inter {
public static void main(String args[]) {
OuterClass myOuter = new OuterClass();
OuterClass.InnerClass myInner = myOuter.new InnerClass();
System.out.println(myInner.myInnerMethod());
}
}

（2）私有内部类（private）

外部无法访问私有内部类。

（3）静态内部类（static）

无需创建外部类对象，即可直接创建内部类对象来访问，但是静态内部类不可直接访问外部类的成员。
eg. 静态内部类的实例化

OuterClass.InnerClass myInner = new OuterClass.InnerClass();

2. 抽象类和抽象方法

（1）简介

数据抽象是为了隐藏某些细节，只向用户显示基本信息的过程，抽象通过抽象类和接口来实现。
abstract关键字是一个非访问修饰符，用于类和方法。
抽象类： 一个受限制的类，可包含抽象方法和常规方法。不可以创建对象，想访问它必须通过子类。
抽象方法： 只能在抽象类中使用，抽象方法没有主体（无定义），主体由子类提供。

（2）详细示例

尝试访问抽象类和抽象类中的抽象方法

// 抽象类
abstract class Animals {
// 抽象方法(没有主体)
public abstract void animalSound();
// 常规方法
public void sleep() {
System.out.println("Zzz");
}
}

// 子类(继承Animals)
class Pigs extends Animals {
public void animalSound() {
// 这里提供了animalSound()的主体
System.out.println("小猪说: 呜呜");
}
}

public class MyAbstract {
public static void main(String[] args) {
Pigs myPig = new Pigs(); // 创建一个Pigs对象
myPig.animalSound();
myPig.sleep();
}
}

运行结果

3. 接口

（1）简介

接口的关键词为interface，是一个完全抽象类，包含一组无实体的方法声明，不可直接创建对象。
要访问接口，需要由另一个类实现，关键词为implements，接口中的方法实体，也由这个类来提供。
note：

• 一个类可以同时实现多个接口。
• 实现接口必须重写所有方法。

（2）详细示例

// Interface
interface Animal1 {
public void animalSound(); // interface 方法 (没有实体)
public void sleep(); // interface 方法 (没有实体)
}

// Pig "implements" Animal 接口
class Pig1 implements Animal1 {
public void animalSound() {
// 这里提供了animalSound()方法的实体
System.out.println("小猪说: 呜呜");
}
public void sleep() {
// sleep()方法的实体
System.out.println("Zzz");
}
}

public class Interface {
public static void main(String[] args) {
Pig1 myPig = new Pig1(); // 创建Pig对象
myPig.animalSound();
myPig.sleep();
}
}

运行结果