Java面向对象（十四）——Eclipse（查看继承树、源码、系统类型库、导出帮助文档、jar包导入导出）、面向对象（修饰符、类\接口\抽象类作为参数与返回值）、星级酒店案例

最新推荐文章于 2023-03-10 17:03:23 发布

kww_

最新推荐文章于 2023-03-10 17:03:23 发布

阅读量622

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/qq_40243295/article/details/112170888

版权

java 专栏收录该内容

44 篇文章 7 订阅

订阅专栏

第一章 Eclipse的应用

1.1 常用快捷操作

Ctrl+T：查看所选中类的继承树

Ctrl+点击类名：查看所选中类或方法的源代码

Alt+Shift+s：给私有成员变量添加get与set方法,或者右键source

1.Ctrl+T：查看所选中类的继承树

例如，在下面代码中，选中Dog类名，然后按Ctrl+T，就会显示出Dog类的继承关系，在继承树中点击Animal，可以查看Animal类的代码。

2.Ctrl+点击类名：查看所选中类或方法的源代码。

Ctrl+滑动鼠标点击类名，或者选中类名/方法名后，按F3键查看所选中类的源代码。

多态中调用就进入父类的抽象代码，因为编译看父类。

Eclipse中的JRE System Library是默认的Eclipse依赖JRE中的类库。在该位置可以查找到平常使用的String类、Random类、Math类等。

JDK中包含JRE,JRE中包含JVM和运行时所需的核心类库。

关系树如下：

-JDK

-JRE

-JVM

-运行时所需的核心类库

1.2文档注释导出帮助文档

在代码中添加文档注释/** */

导出文档注释：右键包名——》Export——》javadoc——》选择javadoc.exe与生成文件的地址——》完成——》查看生成的index.html文件（导出的前提是，文档中已经添加了文档注释）

在eclipse使用时，可以配合文档注释，导出对类的说明文档，从而供其他人阅读学习与使用。

通过使用文档注释，将类或者方法进行注释用@简单标注基本信息。如@author 作者、@version代码版本、@param方法参数、@return方法返回值等。

所有互联网的起始页都叫index或者default，因此以上那么多文件我们只需要打开inde.html文件即可。

inde.html内容如下图：

点击GetSum进入：

1.3项目的jar包导入与导出

jar包是一个可以包含许多.class文件的压缩文件。我们可以将一个jar包加入到项目的依赖中，从而该项目可以使用该jar下的所有类；也可以把项目中所有的类打包到指定的jar包，提供给其他项目使用。

导出jar包：即把项目中所有类，打包到指定的jar包中，步骤如下图：

环境变量的配置：

直接在PATH中加入路径；

或者建立JAVA_HOME，然后在PATH中加入%JAVA_HOME\bin；(加入分号是为了隔开每个变量)；

导入jar包：即把指定的jar包，加入到指项目中，提供给项目使用。

导入jar包的过程是将jar包加入到项目的.classpath文件中去，让项目识别，便可以使用jar包中所有的.class文件类。以下是加入步骤：

         1：项目根文件夹下创建lib文件夹，用于同一管理所有的jar文件

         2：把jar文件复制到lib文件夹中

         3：右键点击jar文件，点击Build Path，选择Add to Build Path，此时查看项目根文件夹下的.classpath文件，发现新加入的jar包路径被配置到了该文件中。说明可以使用jar包中所有类了。

导入jar包流程如下：建一个Folder文件夹，起名叫lib(库的意思)，把所需的jar包拷入lib文件夹。加入成功后点击jar包——》Build Path——》Add to Build Path——》出现一个小奶瓶的形状的jar包文件则已成功。

举例：

查看.classpath文件：

注意：

Jar包加入后，必须Add to Build Path才能使用

Jar包加入后，加入的类也必须导包，如果加入的类其包名与现有类包名相同，则视作在同一个包下。(不常见)

第二章面向对象

2.1 不同修饰符使用细节

常用来修饰类、方法、成员变量的修饰符如下：

public 权限修饰符，公共访问，可以修饰类,方法,成员变量
protected 权限修饰符，受保护访问，可以修饰方法,成员变量
默认什么也不写也是一种权限修饰符,默认访问，可以修饰类,方法,成员变量
private 权限修饰符，私有访问, 可以修饰方法,成员变量
static 静态修饰符，可以修饰方法,成员变量
final 最终修饰符，可以修饰类,方法,成员变量,局部变量
abstract 抽象修饰符可以修饰类 ,方法

protected、private、static不能修饰类。

abstract不能修饰变量。

我们编写程序时，权限修饰符一般放于所有修饰符之前，不同的权限修饰符不能同时使用；

1.同时，abstract与private不能同时使用；

（抽象方法需要子类继承重写，而private子类继承不过来，因此矛盾）

2.同时，abstract与static不能同时使用；

（抽象方法没有主体，需要重写，而静态是直接可以类名调用的，但没有主体无法调用，因此矛盾）

3.同时，abstract与final不能同时使用。

（抽象方法没有主体，需要重写而final不让重写，因此矛盾）

1.修饰类能够使用的修饰符：

修饰类只能使用public、默认的、final、abstract关键字

使用最多的是 public关键字

public class Demo {} //最常用的方式

class Demo2{}

public final class Demo3{}

public abstract class Demo4{}

2.修饰成员变量能够使用的修饰符：

                  public : 公共的

                  protected : 受保护的（子类中才可以使用）

                           : 默认的（本包可以用）

                  private ：私有的（本类可以用）

                  final : 最终的（数据不可修改）

                  static : 静态的（共享数据存在，类名可直接调用）

                  使用最多的是 private

    public int count = 100;

    protected int count2 = 100;

    int count3 = 100;

    private int count4 = 100; //最常用的方式

    public final int count5 = 100;

    public static int count6 = 100;

3.修饰构造方法能够使用的修饰符：

                  public : 公共的（都可以new）

                  protected : 受保护的（本类、本包可以new，子类只能super访问）

                           : 默认的（本包的类可以new）

                  private ：私有的（只有本类可以）

                  使用最多的是 public

    public Demo(){} //最常用的方式

    protected Demo(){}

    Demo(){}

    private Demo(){}

4.修饰成员方法能够使用的修饰符：

                  public : 公共的

                  protected : 受保护的

                           : 默认的

                  private ：私有的

                  final : 最终的

                  static : 静态的

                  abstract : 抽象的

                  使用最多的是 public

    public void method1(){}//最常用的方式

    protected void method2(){}

    void method3(){}

    private void method4(){}

    public final void method5(){}

    public static void method6(){}//最常用的方式

    public abstract void method7();//最常用的方式

第三章自定义数据类型的使用

3.1 辨析成员变量与方法参数的设计定义

如果变量是该类的一部分时，定义成成员变量。

如果变量不应该是类的一部分，而仅仅是功能当中需要参与计算的数，则定义为形参变量。

public class CFX {
	//因为长与宽，在现实事物中属于事物的一部分，所以定义成员变量
	private int chang;
	private int kuan;
	
	public CFX(int chang, int kuan) {
		this.chang = chang;
		this.kuan = kuan;
	}
	
	//求长与宽的周长
	public double zhouChang() {
		return (chang+kuan)*2;
	}
	//求长与宽的面积
	public double mianJi() {
		return chang*kuan;
	}
	public int getChang() {
		return chang;
	}
	public void setChang(int chang) {
		this.chang = chang;
	}
	public int getKuan() {
		return kuan;
	}
	public void setKuan(int kuan) {
		this.kuan = kuan;
	}
}

3.2 作为方法参数与返回值

3.2.1 类作为方法参数

在编写程序中，会经常碰到调用的方法要接收的是一个类的情况，那么这时，要向方法中传入该类的对象。如下代码演示：

package day14.demo1;

public class Person {
	private String name = "张三";
	
	public void eat(){
		System.out.println(name+ "  在吃饭");
	} 
	
	public void run(){
		System.out.println(name+" 在跑步");
	}
}

package day14.demo1;

public class TestArguments {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Person p = new Person();
	    operatorPerson(p);
	    

	}
	public static void operatorPerson(Person p) {
		p.eat();
		p.run();
		
	}
}

结果：

3.2.2 类作为方法返回值

写程序调用方法时，我们以后会经常碰到返回类型为类的返回值，那么这时，该方法要返回一个该类的对象。如下代码演示：

package day14.demo1;
/*
 *  定义类,方法返回Person的类型
 */
public class GetPerson {
	/*
	 *  方法返回值是Person类型
	 *  方法的return语句后面 一定是Person类型的对象
	 *  new 
	 */
	public Person get() {
//		Person p = new Person();
//		return p;
		
		return new Person();
	}
	
}

package day14.demo1;

public class TestReturn {
	public static void main(String[] args) {
		//调用GetPerson类的方法get
		//返回值是Person类型
		GetPerson g= new GetPerson();
		Person p = g.get();
		p.eat();
		p.run();
		//链式调用
		new GetPerson().get().eat();
		
	}
}

3.3抽象类作为方法参数与返回值

3.3.1 抽象类作为方法参数

package day14.abstractclass;

public abstract class Animal {
	public abstract void  eat();

}

package day14.abstractclass;

public class Cat extends Animal{
	
	public void eat() {
		System.out.println("猫在吃鱼");
	}

}


package day14.abstractclass;

public class Dog extends Animal{
	public void eat() {
		
		System.out.println("狗吃骨头");
	}

}

package day14.abstractclass;
/*
 *  将抽象类类型,作为方法的参数进行传递
 */
public class TestArguments {
	public static void main(String[] args) {
		Cat c = new Cat();
		operatorAnimal(c);
		
		operatorAnimal(new Dog());	
		
	}
	/*
	 *  方法operatorAnimal,参数是一个抽象类
	 *  调用方法,传递Animal类型对象,Animal抽象类没有对象
	 *  只能传递Animal的子类的对象 (多态)
	 *  可以传递Animal的任意的子类对象
	 */
	
	public static void operatorAnimal(Animal a){
		//引用变量a,调用方法eat
		a.eat();
	}
	}

方法的参数是抽象类时，只能传递抽象类的子类的对象 (多态)，可以传递此抽象类的任意子类对象。运行也是子类对象的结果。

3.3.2 抽象类作为方法返回值

抽象类作为方法返回值的情况，也是有的，这时需要返回一个实现抽象类所有抽象方法的子类对象。如下代码演示：

package day14.abstractclass;

public class GetAnimal {
	/*
	 * 定义方法,方法的返回值是Animal类型
	 * 抽象类,抽象类没有对象的,因此在方法的return后,返回Animal 的子类的对象
	 */
	public Animal getAnimal(int i){
		if (i==0)
			return new Cat();	
		
		return new Dog();
	}
}

package day14.abstractclass;

public class TestReturn {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//调用GetAnimal类的方法,getAnimal,返回值是Animal
		GetAnimal g = new GetAnimal();
		//Cat c = g.getAnimal(0);  //用Cat类型接收,报错
		Animal a = g.getAnimal(0);//返回类型是Animal类型，只能用Animal类型接收
		
		a.eat();		
	}

}

3.4 接口作为方法参数与返回值

3.4.1 接口作为方法参数

接口作为方法参数的情况是很常见的，经常会碰到。当遇到方法参数为接口类型时，那么该方法要传入一个接口实现类对象。如下代码演示：

调用方法,必须传递接口的任意的实现类的对象。

package day14.interface1;

public interface Smoking {
	public static final int A = 1;
	public abstract void smoking();
}


package day14.interface1;

public class Student implements Smoking {

	public void smoking() {
		System.out.println("请不要吸烟");
	}

}

package day14.interface1;

public class TestArguments {
	public static void main(String[] args) {
		//调用noSmoking方法,传递实现类对象
		//实现类对象是自己的对象
		/*Student s = new Student();
		noSmoking(s);
		
		noSmoking( new Student());*/
		
		//实现类对象,是采用多态创建出来
		Smoking s = new Student();
		noSmoking(s);
	}
	/*
	 * 定义方法,方法参数,接口类型
	 * 方法的参数是Smoking的接口类型
	 * 调用方法,必须传递接口的任意的实现类的对象
	 */
	public static void noSmoking(Smoking s){
		//调用接口中的常量A
		//System.out.println(Smoking.A);//A为共享数据，类可以直接调用
		//接口的引用变量s,调用方法
		s.smoking();
	}
}

3.4.2 接口作为方法返回值

接口作为方法返回值的情况，在后面的学习中会碰到。当遇到方法返回值是接口类型时，那么该方法需要返回一个接口实现类对象。如下代码演示：

接口是不能创建对象,return 语句后面返回的是他实现类的对象。

package day14.interface1;

public class GetSmoking {
	/*
	 *  定义方法,方法的返回值是接口类型
	 *  接口是不能创建对象,return 语句后面返回的是他实现类的对象
	 */
	public Smoking getSmoking(){
		return new Student();
	}
}

package day14.interface1;

public class TestReturn {
	public static void main(String[] args) {
		//调用GetSmoking类的方法getSmoking获取Smoking接口的实现类的对象
		GetSmoking g = new GetSmoking();
		Smoking s = g.getSmoking();//方法的执行结果是接口的实现类对象 new Student()
		s.smoking();
	}
}

抽象类、接口类作为返回值的情况：

对于调用者来说，不需要关注子类是谁。用本类接收，然后调用本类的方法，执行的是子类/实现类重写的方法。

public abstract class Animal {
	public abstract void eat();
	
	/*
	 * 抽象类Animal,定义方法,返回值是Animal类型
	 * 抽象类没有对象,此方法方便调用,写为静态修饰
	 */
	public static Animal getInstance(){
		return new Cat();
	}
}


public class Cat  extends Animal{
	public void eat(){
		System.out.println("猫吃鱼");
	}
}

public class Test {
	public static void main(String[] args) {
		//直接调用抽象类的静态方法getInstance获取抽象类的子类的对象
		//抽象类的静态方法,返回了自己的子类对象
		//对于调用者来讲: 不需要关注子类是谁
		Animal a = Animal.getInstance();
		a.eat();
		
		//日历类，为抽象类
		Calendar c = Calendar.getInstance();//类直接调用，调用的为静态方法
		System.out.println(c);//输出的为子类
	}

结果：

第四章星级酒店案例

4.1 案例介绍

某五星级酒店，资金雄厚，要招聘多名员工（经理、厨师、服务员）。入职的员工需要记录个人信息（姓名、工号、经理特有奖金属性）。他们都有自己的工作要做。

本案例要完成如下需求：

获取酒店幸运员工；
酒店开设VIP服务，酒店的厨师与服务员可以提供VIP服务。（厨师做菜加量、服务员给顾客倒酒）。
编写测试类

编写测试类：

向酒店中，增加多名员工（其中包含1名经理，1名厨师、2名服务员）；

调用酒店员工的工作功能

调用酒店员工的VIP服务功能

4.2 案例需求分析

员工的类型有经理、厨师、服务员，它们有共同的属性（姓名、工号、），经理额外属性（奖金）。

class 员工 {
     属性：姓名
属性：工号
方法：工作
}
class 厨师 extends 员工{}
class 服务员 extends 员工{}
class 经理 extends 员工 {
     属性：奖金
}

根据“酒店开设VIP服务，酒店的厨师与服务员可以提供VIP服务。（厨师做菜加量、服务员给顾客倒酒）”。分析出，这是要增加一个VIP的接口，接口中提供个VIP服务的方法。让厨师与服务员实现该接口。

interface VIP服务{
     抽象方法：服务
}
class 厨师 extends 员工 implements VIP服务{ 重写服务方法 }
class 服务员 extends 员工 implements VIP服务{ 重写服务方法 }

4.3代码实现

alt+shift+s：自动生成get与set方法

标准写法，提供两个构造方法：一个空参，一个满参

package day14.hotel;
/*
 *  酒店的VIP服务
 *    厨师和服务员
 */
public interface VIP {
	public abstract void service();
}

package day14.hotel;
/*
 *  酒店的员工类
 *    员工共性, 姓名,工号 工作方法
 */
public abstract class Employee {
	private String name;
	private String id;
	//构造器的标准写法，空参与满参
	public  Employee() {
		
	}
	public  Employee(String name,String id) {
		this.name = name;
		this.id= id;
		
	}
	
	public abstract void work();
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String  getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	
}

package day14.hotel;
/*
 *  定义厨师类
 *    属于员工一种,具有额外服务功能
 *    继承Employee,实现VIP接口
 */
public class cook extends Employee implements VIP{
	//构造方法不写返回值
	public  cook() {}
	public  cook(String name ,String id) {
		super(name,id);
	}
	public  void work() {
		System.out.println("厨师在炒菜");
		
	}
	public  void service() {
			
		System.out.println("厨师做菜加量");
		}

}

package day14.hotel;
/*
 *  定义厨师类
 *    属于员工一种,具有额外服务功能
 *    继承Employee,实现VIP接口
 */
public class waiter extends Employee implements VIP{
	public waiter() {}
	public waiter(String name ,String id) {
		super(name,id);
	}
	public  void work() {
		System.out.println("服务员在上菜");
			
		}
	public  void service() {
		System.out.println("服务员给顾客倒酒");
		
	}
}

package day14.hotel;
/*
 *  定义经理类
 *    属于员工一种,没有VIP功能
 *    自己有奖金属性
 */
public class manager extends Employee{
	private double money;
	
	public manager() {
		
	}
	public manager(String name ,String id,double money) {
		super(name,id);
		this.money = money;
	}
	public double getMoney() {
		return money;
	}


	public void setMoney(double money) {
		this.money = money;
	}


	public  void work() {
		System.out.println("管理");
		
	}
}

package day14.hotel;

public class Test {
	public static void main(String[] args) {
	//创建1个经理,2个服务员,2个厨师
	manager m = new manager("大王","董事会001", 123456789.32);
	m.work();
	
	waiter w1 = new waiter("小五","服务员001");
	waiter w2 = new waiter("小六","服务员002");
	w1.work();
	w2.work();
	w1.service();
	w2.service();
	
	cook c1 = new cook("辣椒", "后厨001");
	cook c2 = new cook("花椒", "后厨002");
	c1.work();
	c2.work();
	c1.service();
	c2.service();
}
}

运行结果：

kww_

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java面向对象（十四）——Eclipse（查看继承树、源码、系统类型库、导出帮助文档、jar包导入导出）、面向对象（修饰符、类\接口\抽象类作为参数与返回值）、星级酒店案例

Ctrl+T：查看所选中类的继承树例如，在下面代码中，选中Dog类名，然后按Ctrl+T，就会显示出Dog类的继承关系，在继承树中点击Animal，可以查看Animal类的代码。Ctrl+点击类名：查看所选中类或方法的源代码。Ctrl+滑动鼠标点击类名，或者选中类名/方法名后，按F3键查看所选中类的源代码。多态中调用就进入父类的抽象代码，因为编译看父类。Eclipse中的JRE System Library是默认的Eclipse依赖JRE中的类库。在该位置可以查找到平.
复制链接

扫一扫