JAVA笔记_（Day12）包&面向对象_练习

最新推荐文章于 2021-09-13 16:13:40 发布

ChunyeLi

最新推荐文章于 2021-09-13 16:13:40 发布

阅读量665

点赞数

分类专栏： JAVA 文章标签： java

本文链接：https://blog.csdn.net/sinat_32512123/article/details/85273287

版权

JAVA 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

文章目录

概述
包之间的访问
包之间继承&protected
- **总结（权限）**
import关键字
jar包
面向对象_练习

概述

包
对类文件进行分类管理
给类提供多层命名（名称）空间
写在程序文件的第一行。
类名的全称的是包名.类名。
包也是一种封装形式。

package  mypack//包名都小写

在cmd中,
javac会出现一堆指令
输入

javac -d. 路径可加可不加 类名 //这样会生成一个包
set classpath-路径  //指定在新的目录下运行class文件

包之间的访问

被访问的包中的类权限必须是public的。
类中的成员权限：public或者protected
protected是为其他包中的子类提供的一种权限

package packa
public class DemoA
{
  public void main(){
        System.out.println("demoA show run");
  }
}

package mypack;

class packageDemo
{
       public static void main(String[] args)
       {
            packa.DemoA d1=new packa.DemoA();
            d1.show();
       }
}

如何编译？
此处用cmd

javac -d c:\javaapp DemoA.java
javac -d c:\javaapp PackageDemo.java

问题1：找不到符号
原因：类名写错。有了包以后，类的名称应该是：包名.类名。

改成包名.类名后
问题2：程序包packa不存在
原因：packa包没有存放在当前目录下。需要告诉jvm它的位置。
解决：设置classpath。

set classpath=c:\javaapp

设置完classpath后
问题3:DemoA在packa中不是公共的；无法从外部程序包中对其进行访问。
问题4:show()在packa中不是公共的；无法从外部程序包中对其进行访问。
原因：被访问中的包中的类，权限不够。被访问的方法也必须是public。
解决：被访问的包中的类，用public修饰。

加完所有public后

java PackageDemo

问题5：找不到或无法加载主类PackageDemo
解决：应该

java mypack.PackageDemo

包之间继承&protected

protected 保护
专门给子类提供的权限

package packfu;
public class DemoFu 
 {
	 //public void method()//把public改成protected
	 protected void method()
	 {
		 System.out.println("Demofu method run"); 
	 }
 }

package packa;
public class DemoA extends packfu.DemoFu
 {
	 public void show()
	 {
	     method();
		 System.out.println("DemoA show run"); 
	 }
 }

package mypack

class PackageDemo
{
  public static void main(String[] args)
  {
  /*
    packfu.DemoFu d=new packfu.DemoFu();
    d.method();//建立父类对象能直接访问method，那么子类的method就有点没有必要。
    //所以用protected来之让其子类才能调用父类中的方法
    */
    packa.DemoA d1=new packa.DemoA();
    di.show();
    System.out.println("Hello package");
  }
}

运行
javac不用加包名，java需要加包名

javac -d c:\javaapp DemoFu.java
javac -d c:\javaapp DemoA.java
javac -d c:\javaapp PackageDemo.java
java mypack.PackageDemo

总结（权限）

权限

	public	protected	default	private
同一个类中	ok	ok	ok	ok
同一个包中	ok	ok	ok
子类	ok	ok
不同包中	ok	不同包中的子类也可以使用，除此之外不能

包与包之间只有两种权限可以用，public,protected(只给子类使用)

import关键字

导入的是类

一个类

import packa.demoA;//导入了packa包中的DemoA类。简化类名的书写。

那么

 packa.DemoA d1=new packa.DemoA();

可以改为

DemoA d1=new DemoA();

一个包中的多个类,类中类

packa\ TestA.class
     \Demo.class
     \A.class
     \haha\zz.class//haha是包

那么可以写成：

imprort packa.TestA;
import packa.A;
import packa.*；//全用到。*为通配符，但用这个会降低效率，因此宁愿一个一个加载。
import packa.haha.zz;//导入packa包中haha子包中的类。

用到哪个类，就导入哪个类。
但高级编辑器会比较方便：ctrl+shift+o

当不同包中的类重名

这时即使导入了，也必须在使用时明确该类的包名。

java中常用的包

java在线文档
java.io:输入输出
java.lang:java的语言核心包
java.awt:抽象的窗口工具集，做图形化界面时会用到
java.net:网络传输方面的问题
java.util:java最常用的一些工具

jar包

jar:java的压缩包

用到第十二天中的code
运行

javac -d .JarDemo.java
java pack.JarDemo

报错：找不到或无法加载朱磊pack.JarDemo

首先看classpath

set classpath

取消之前设置的

set classpath-

使之内容为当前文件夹

在cmd中敲入

jar

会出现很多说明,了解即可。
jar的具体命令

jar cfv my.jar pack//创建新的归档文件+指定文件名+在标准输出中生成详细输出 ， 并把pack放进其中
jar -tvf my.jar pack//显示jar中的内容列表
jar -xfv my.jar//解压缩，结果文件夹里面多出的是配置文件

这时

day11\mypack
day11\my.jar\mypack    //运行包所在的父目录

运行

set classpath-.\my.jar
java pack.JarDemo

把

ArrayTool.class --help//数组工具
Trans.class//进制转换

封进jar包，然后把classpath设置为jar，那么里面的就都能用。

开发中把自己测试完毕的都封装进jar包，直接导入classpath,就全能用。
还要配说明书。

Ps:lib文件夹中的rt.jar有很多常用类，比如String[],Object.class

生成的jar包，不用解压，双击即能执行

面向对象_练习

练习1

建立一个图形接口，声明一个面积函数。圆形和矩形都实现这个接口，并提出两个图形的面积。
注：体现面向对象的特征，对数值进行判断。用异常处理。不合法的数值要出现“这个数值是非法的”提示，不再进行运算。

interface Areable 
 {
	 double getAera();
 }

class NotValueException extends RuntimeException//不需要声明
{
	NotValueException()
	{
		super();//格式
	}
	NotValueException(String message)
	{
		super(message);
	}
}

class Rec implements Areable
{
	private int length,width;
	public Rec(int length,int width) 
	{
		if(length<=0||width<=0)
			throw new NotValueException("这个数值是非法的");
		this.length=length;
		this.width=width;
	}
	public double getAera() {
		return length*width;
	}
}

class Circle implements Areable
{
	private double radius;//半径
	private static final double PI=3.14;//静态可以直接被类名调用
	public Circle(double radius) 
	{
		if(radius<=0)
			throw new NotValueException("这个数值是非法的");
		this.radius=radius;		
	}
	public double getAera() 
	{
		return PI*radius*radius;
	}
}

练习2

在一个类中编写一个方法。这个方法搜索一个字符数组中是否存在某个字符，如果存在，则返回这个字符在字符数组中第一次出现的位置（序号从0开始计算），否则，返回-1。
要搜索的字符数组和字符都以参数形式传递给该方法。
如果传入的数组为null，应抛出IllegalArgumentException异常。
在类的main方法中以各种可能出现的情况测试验证该方法编写得是否正确，
例如，字符不存在，字符存在，传入的数组为null等。

public int searchChar(char[] chs,char key)
		{
			if(chs==null)
				throw new IllegalArgumentExcepton("数组为空");
			for(int x=0;x<chs.length;x++) 
			{
				if(key==chs[x])
					return x;
			}
			return -1;
		}

练习3

补足compare函数内的代码，不许添加其他函数。

class Circle
{
	private double radius;
	public Circle(double r)
	{
		radius=r;
	}
	public static double compare(Circle[] cir) 
	{
		//程序代码
		//获取数组中的最大值
		//下面两个选其中一个即可
		int max1=0;//初始化为数组中的任意一个角标。
		double max=cir[0].radius;//初始化为数组中的任意一个元素
		//============int max1=0======
		for(int x=1;x<cir.length;x++)
		{
			if(cir[x].radius>cir[max1].radius) 
			{
				max1=x;
			}			
		}
		return cir[max1].radius;
	}
}

class TC
{
	public static void main(String[] args) 
	{
		Circle cir[]=new Circle[3];
		System.out.println(cir[0]);//输出为null
		cir[0]=new Circle(1.0);
		cir[1]=new Circle(2.0);
		cir[2]=new Circle(4.0);
		System.out.println("最大的半径值是："+Circle.compare(cir));
	}
}

练习4

描述Person
属性：姓名和年龄
行为：1.说出姓名和年龄。2.判断是否是同一个人（同姓名，同年龄视为同一个人）。
提示：判断姓名相同的方法到API文档String类中查找。
java在线文档
java.lang–>String–>equals(Object anObject) 将此字符串与指定的对象比较

class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public void speak()
	{
		System.out.println(this.name+"..."+this.age);		
	}
	
	/**
	 * 既然要判断对象是否相同，直接使用Object类中的方法。
	 * 但是还要依据子类的特征来判断，直接覆盖Object类中的方法equals。
	 */
	 
	public boolean equals(Object obj) //这里的equals是Person类中的方法
	{
		//判断姓名和年龄是否相同。这些都是Person的属性，所以必须向下转型。
		if(!(obj instanceof Person))
			throw new ClassCastException("类型错误");
		Person p=(Person) obj;
		//return this.age== p.age && this.name==p.name;//this.name是字符串，不能用==
		return this.age== p.age && this.name.equals(p.name);//这里的equals是String类中的方法
	}
}

练习5

补足代码

class Circle
{
	private double radius;
	public Circle(double r) 
	{
		radius=r;
	}
	//请定义功能：比较两个圆是否一样大。
	//覆盖equals方法
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Circle))
			throw new ClassCastException(obj.getClass().getName()+"类型错误");//可以指出什么类名的类型错误
		Circle c=(Circle) obj;
		return c.radius==this.radius;
	}
}

class TC
{
	public static void main(String[] args) 
	{
		Circle cir1=new Circle(2.0);
		Circle cir2=new Circle(2.0);
		
		boolean b=cir1.equals(cir2);
		System.out.println("两个圆是否一样大："+b);
	}
}

练习6

public class OuterClass{
	private double d1=1.0;
	//insert code here
}

把下列答案存放在指定code位置上，哪个答案是正确的。阐述原因。

A.class InnerOne{
	public static double methoda() {return d1;}
  }
  不行，因为非静态内部类中，不可以定义静态方法

B. public class InnerOne{
	static double methoda() {return d1;}
  }
   不行，因为非静态内部类中，不可以定义静态方法

C.private class InnerOne{
	double methoda() {return d1;}
  }
对，内部类可以私有，也可以直接访问外部类成员。

D.static class InnerOne{
	protected double methoda() {return d1;}
  }
  不行，静态内部类只能访问外部类中的静态成员。

E.abstract class InnerOne{
	public abstract double methoda();
  }
  可以，内部类可以抽象。

练习7

写出下面代码的执行结果（需写出分析过程）。

class A
{
	void fun1(){
		System.out.println(this.fun2());//this=0X0099new B();// A a=new B();a.func2();（多态）
	}
	int fun2() {
		return 123;
	}
}

class B extends A{
	int fun2() {
		return 456;
	}
	public static void main(String augs[]) {
		A a;
		B b=new B();//0X0099
		b.fun1();//456
		a=b;
		a.fun1();//456
	}
}

结果：