天耀18期 – 07.面向对象-继承、访问权限【作业】
2017-11-15 13:14
387 查看
1. 写一个类Param，声明四个成员变量a、b、c、d，分别赋予四种访问权限。
（1）试验在同一个包中的另一个类里能访问哪几个变量？
（2）试验在不同包中的另一个类里能访问哪几个变量？
（3）试验在不同包中、用Param派生一个子类，看子类能访问哪几个变量？
package FirstBag;
public class Param {
public int a=1;
protected int b=2;
int c=3;
private int d=4;
void test () {
System.out.println("输出a的值"+a);
System.out.println("输出b的值"+b);
System.out.println("输出c的值"+c);
System.out.println("输出d的值"+d);
}
}
package FirstBag; //在同一个 包中的一个类
public class Main {
public static void main(String[] args) {
Param pr=new Param();
System.out.println("输出a的值"+pr.a);
System.out.println("输出b的值"+pr.b);
System.out.println("输出c的值"+pr.c);
System.out.println("输出d的值"+pr.d);
//private 不能在同一个包中不同文件中使用
}
}
package FirstBag1;
/** * 不同包中的一个子类 * @author LENOVO * */
import FirstBag.Param;
public class ParamSon extends Param {
void test () {System.out.println("输出a的值"+a);
//在不同包中的子类中，public 可以使用 System.out.println("输出b的值"+b);
//在不同包中的子类中，protected 可以使用 System.out.println("输出c的值"+c);
//在不同包中的子类中，友好型不 可以使用 System.out.println("输出d的值"+d);
//在不同包中的子类中，private不 可以使用
}
}
ackage FirstBag1; import FirstBag.Param;
//在不同包中的一个类
public class Main {
public static void main(String[] args) {
Param pr1=new Param();
System.out.println("输出a的值"+pr1.a);
//在不同包中一个普通类，public 可以使用
System.out.println("输出b的值"+pr1.b); //在不同包中一个普通类，protected 不可以使用 System.out.println("输出c的值"+pr1.c);// 在不同包中一个普通类，友好型 不可以使用 System.out.println("输出d的值"+pr1.d);//在不同包中一个普通类，private不 可以使用
}
}
2. 题目：有一分数序列：2/1，3/2，5/3，8/5，13/8 ... 求出这个数列的前20项之和。
package FirstBag; //类方法 求有一分数序列：2/1，3/2，5/3，8/5，13/8 ... 求出这个数列的前20项之和。 public class Add {
int i;
float sum=0;
void add () {
int mem=2,dmin=1;
for (i=1;i<=20;i++) {
sum+=mem/dmin*1.0;
mem+=dmin; dmin=mem;
}
System.out.println("前二十项的结果是："+sum);
}
}
package FirstBag; //调用类方法 使用主方法得出结果
public class Main1 {
public static void main(String[] args) {
Add ad=new Add(); ad.add();
}
}
3. 写一个工具类，提示用户，1为普通话，2 for English ，判断用户输入的数据，根据输入的数据做出对应的响应。用户输入1，则提示，您好，欢迎使用本系统；如果输入2，则提示，Hello, welcome to use this system。 package FirstBag2;
//类方法 进入系统时提示选则语言
public class Remind {
//提示1和2所代表的语言
void remind() {
System.out.println("如果您输入1，则为普通话，if you enter 2, for English ");
}
// 1和2 所选择的语言
void remind1(int a) {if (a==1) {System.out.println("您好，欢迎使用本系统");
}
else if (a==2) {
System.out.println("Hello, welcome to use this system ");
}
else {System.out.println("您输入的数据有错误");
}
}
}
//主方法
package FirstBag2;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Remind rm=new Remind(); rm.remind();
// 让用户输入数字 Scanner scanner=new Scanner(System.in);
System.out.println("请输入1或者2");
int s=scanner.nextInt(); rm.remind1(s);
}
}
4. 写一个工具类，打包到tools里，计算如下题目，两列火车相向而行，问：多长时间后两车相遇。用户输入已知信息：第一列车速度（千米/小时），第二列车速度（千米/小时），两车距离（千米）。在另一个类里调用该类，测试是否正确。
package tools;
/** * 类方法 */
import java.util.Scanner;
public class TrainMeetUseTime1 {
void enterNum() {
Scanner scanner=new Scanner(System.in );
System.out.println("请输入第一列车速度（千米/小时）");
float v1=scanner.nextFloat();
System.out.println("请输入第二列车速度（千米/小时）");
float v2=scanner.nextFloat();
System.out.println("请输入两车之间的距离(千米)");
float s=scanner.nextFloat();
float time=s/(v1+v2);
System.out.println("两辆火车相遇所用的时间是："+time);
}
}
package tools;
//主方法
public class Main {
public static void main(String[] args ) {
TrainMeetUseTime1 tmut=new TrainMeetUseTime1();
tmut.enterNum();
}
}
5. 写一工具类，判断输入的字符（char）是否为数字（使用ASCII码判断）类型，在另一个类里引入该类，然后调用工具类判断。要求打包到tools里。
package tools;
import java.util.Scanner;
public class JudgeNumber {
void judgeNumber() {
Scanner scanner=new Scanner(System.in);
System.out.println("请输入一个数据");
char s=scanner.next().charAt(0);
if (s>=47&&s<=58) {
System.out.println("您输入的是一个数字");
} else {System.out.println("您输入的不是一个数字");
}
}
}
package tools;
public class Main1 {
public static void main(String[] args) {
JudgeNumber jn=new JudgeNumber();
jn.judgeNumber();
}
}
6. 题目：打印杨辉三角
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
6.
package tools;
import java.util.Scanner;
public class Main2 {
public static void main(String[] args) {
printYFTriangle();
}
public static void printYFTriangle(){
System.out.println("how many lines you want:");
Scanner in = new Scanner(System.in);
int lines = in.nextInt();
int[] a = new int[lines + 1];
int previous = 1;
for (int i = 1; i <= lines; i ++){
for (int j = 1; j <= i; j++)
{
int current = a[j];
a[j] = previous + current;
previous = current;
System.out.print(a[j] + " ");
}
System.out.println();
}
}
}
7. 题目
吸血鬼数字是指位数为偶数的数字，可以由一对数字相乘得到，而这对数字的位数是原数字的一半位数，并且由组成原数字的各个位数组成，以两个0结尾的数字不是吸血鬼数字。
例如：1260 = 21 * 60 1827 = 21 * 87 2187= 27 * 81 求所有四位吸血鬼数字
import java.util.Arrays;
/**
* 吸血鬼数字,高效率版本. 一个4位数字，可以拆分2个2位数数字的乘积,顺序不限。 比如 1395 =15 * 93
*
*/
public class VampireNumber {
public static void main(String[] arg) {
String[] str1, str2;
int sum = 0;
int from;
int to;
int val;
int count = 0;
// 双重循环穷举
for (int i = 10; i < 100; i++) {
// j=i+1避免重复
from = Math.max(1000 / i, i + 1);
to = Math.min(10000 / i, 100);
for (int j = from; j < to; j++) {
val = i * j;
/*
* 假设val = 1000a + 100b + 10c + d, 因为满足val = x * y, 则有x = 10a + b, y = 10c + d
* 则val - x - y = 990a + 99b + 9c = 9 * (110a + 11b + c),
*所以val - x - y能被9整除。 所以满足该条件的数字必定能被9整除，所以可以直接过滤其他数字。
*/
if (val % 100 == 0 || (val - i - j) % 9 != 0) {
continue;
}
count++;
str1 = String.valueOf(val).split("");
str2 = (String.valueOf(i) + String.valueOf(j)).split("");
Arrays.sort(str1);
Arrays.sort(str2);
if (Arrays.equals(str1, str2)) {// 排序后比较,为真则找到一组
sum++;
System.out.println("第" + sum + "组: " + i + "*" + j + "=" + val);
}
}
}
System.out.println("共找到" + sum + "组吸血鬼数");
System.out.println(count);
}
}
结果：
第1组: 15*93=1395
第2组: 21*60=1260
第3组: 21*87=1827
第4组: 27*81=2187
第5组: 30*51=1530
第6组: 35*41=1435
第7组: 80*86=6880
共找到7组吸血鬼数
232
//未运行
public class XiXueGuiJudge {
public XiXueGuiJudge()
{
}
void main(){
//输入数据
Scanner scanner=new Scanner(System.in);
System.out.println("请输入一个数据");
int s=scanner.nextInt();
int i,a,b,c,d,num=s;
a=num%10;
num/=10;
b=num%10;
num/=10;
c=num%10;
num/=10;
d=num%10;
for (i=1000;i<10000;i++)
{
if ( (a*10+b)*(b*10+c)==s||
(a*10+b)*(c*10+d)==s||
(b*10+a)*(b*10+c)==s||
(b*10+a)*(c*10+d)==s||
(a*10+c)*(b*10+d)==s||
(c*10+a)*(d*10+b)==s||
(c*10+a)*(b*10+d)==s||
(a*10+d)*(b*10+c)==s||
(a*10+d)*(c*10+b)==s||
(d*10+a)*(b*10+c)==s||
(d*10+a)*(c*10+b)==s
)
{System.out.println(i+"是一个吸血鬼数字");}
}
}
package xiXueGui;
public class Main {
public static void main(String[] args)
{XiXueGuiJudge xx=new XiXueGuiJudge();
xx.main();
}
}
（1）试验在同一个包中的另一个类里能访问哪几个变量？
（2）试验在不同包中的另一个类里能访问哪几个变量？
（3）试验在不同包中、用Param派生一个子类，看子类能访问哪几个变量？
package FirstBag;
public class Param {
public int a=1;
protected int b=2;
int c=3;
private int d=4;
void test () {
System.out.println("输出a的值"+a);
System.out.println("输出b的值"+b);
System.out.println("输出c的值"+c);
System.out.println("输出d的值"+d);
}
}
package FirstBag; //在同一个 包中的一个类
public class Main {
public static void main(String[] args) {
Param pr=new Param();
System.out.println("输出a的值"+pr.a);
System.out.println("输出b的值"+pr.b);
System.out.println("输出c的值"+pr.c);
System.out.println("输出d的值"+pr.d);
//private 不能在同一个包中不同文件中使用
}
}
package FirstBag1;
/** * 不同包中的一个子类 * @author LENOVO * */
import FirstBag.Param;
public class ParamSon extends Param {
void test () {System.out.println("输出a的值"+a);
//在不同包中的子类中，public 可以使用 System.out.println("输出b的值"+b);
//在不同包中的子类中，protected 可以使用 System.out.println("输出c的值"+c);
//在不同包中的子类中，友好型不 可以使用 System.out.println("输出d的值"+d);
//在不同包中的子类中，private不 可以使用
}
}
ackage FirstBag1; import FirstBag.Param;
//在不同包中的一个类
public class Main {
public static void main(String[] args) {
Param pr1=new Param();
System.out.println("输出a的值"+pr1.a);
//在不同包中一个普通类，public 可以使用
System.out.println("输出b的值"+pr1.b); //在不同包中一个普通类，protected 不可以使用 System.out.println("输出c的值"+pr1.c);// 在不同包中一个普通类，友好型 不可以使用 System.out.println("输出d的值"+pr1.d);//在不同包中一个普通类，private不 可以使用
}
}
2. 题目：有一分数序列：2/1，3/2，5/3，8/5，13/8 ... 求出这个数列的前20项之和。
package FirstBag; //类方法 求有一分数序列：2/1，3/2，5/3，8/5，13/8 ... 求出这个数列的前20项之和。 public class Add {
int i;
float sum=0;
void add () {
int mem=2,dmin=1;
for (i=1;i<=20;i++) {
sum+=mem/dmin*1.0;
mem+=dmin; dmin=mem;
}
System.out.println("前二十项的结果是："+sum);
}
}
package FirstBag; //调用类方法 使用主方法得出结果
public class Main1 {
public static void main(String[] args) {
Add ad=new Add(); ad.add();
}
}
3. 写一个工具类，提示用户，1为普通话，2 for English ，判断用户输入的数据，根据输入的数据做出对应的响应。用户输入1，则提示，您好，欢迎使用本系统；如果输入2，则提示，Hello, welcome to use this system。 package FirstBag2;
//类方法 进入系统时提示选则语言
public class Remind {
//提示1和2所代表的语言
void remind() {
System.out.println("如果您输入1，则为普通话，if you enter 2, for English ");
}
// 1和2 所选择的语言
void remind1(int a) {if (a==1) {System.out.println("您好，欢迎使用本系统");
}
else if (a==2) {
System.out.println("Hello, welcome to use this system ");
}
else {System.out.println("您输入的数据有错误");
}
}
}
//主方法
package FirstBag2;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Remind rm=new Remind(); rm.remind();
// 让用户输入数字 Scanner scanner=new Scanner(System.in);
System.out.println("请输入1或者2");
int s=scanner.nextInt(); rm.remind1(s);
}
}
4. 写一个工具类，打包到tools里，计算如下题目，两列火车相向而行，问：多长时间后两车相遇。用户输入已知信息：第一列车速度（千米/小时），第二列车速度（千米/小时），两车距离（千米）。在另一个类里调用该类，测试是否正确。
package tools;
/** * 类方法 */
import java.util.Scanner;
public class TrainMeetUseTime1 {
void enterNum() {
Scanner scanner=new Scanner(System.in );
System.out.println("请输入第一列车速度（千米/小时）");
float v1=scanner.nextFloat();
System.out.println("请输入第二列车速度（千米/小时）");
float v2=scanner.nextFloat();
System.out.println("请输入两车之间的距离(千米)");
float s=scanner.nextFloat();
float time=s/(v1+v2);
System.out.println("两辆火车相遇所用的时间是："+time);
}
}
package tools;
//主方法
public class Main {
public static void main(String[] args ) {
TrainMeetUseTime1 tmut=new TrainMeetUseTime1();
tmut.enterNum();
}
}
5. 写一工具类，判断输入的字符（char）是否为数字（使用ASCII码判断）类型，在另一个类里引入该类，然后调用工具类判断。要求打包到tools里。
package tools;
import java.util.Scanner;
public class JudgeNumber {
void judgeNumber() {
Scanner scanner=new Scanner(System.in);
System.out.println("请输入一个数据");
char s=scanner.next().charAt(0);
if (s>=47&&s<=58) {
System.out.println("您输入的是一个数字");
} else {System.out.println("您输入的不是一个数字");
}
}
}
package tools;
public class Main1 {
public static void main(String[] args) {
JudgeNumber jn=new JudgeNumber();
jn.judgeNumber();
}
}
6. 题目：打印杨辉三角
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
6.
package tools;
import java.util.Scanner;
public class Main2 {
public static void main(String[] args) {
printYFTriangle();
}
public static void printYFTriangle(){
System.out.println("how many lines you want:");
Scanner in = new Scanner(System.in);
int lines = in.nextInt();
int[] a = new int[lines + 1];
int previous = 1;
for (int i = 1; i <= lines; i ++){
for (int j = 1; j <= i; j++)
{
int current = a[j];
a[j] = previous + current;
previous = current;
System.out.print(a[j] + " ");
}
System.out.println();
}
}
}
7. 题目
吸血鬼数字是指位数为偶数的数字，可以由一对数字相乘得到，而这对数字的位数是原数字的一半位数，并且由组成原数字的各个位数组成，以两个0结尾的数字不是吸血鬼数字。
例如：1260 = 21 * 60 1827 = 21 * 87 2187= 27 * 81 求所有四位吸血鬼数字
import java.util.Arrays;
/**
* 吸血鬼数字,高效率版本. 一个4位数字，可以拆分2个2位数数字的乘积,顺序不限。 比如 1395 =15 * 93
*
*/
public class VampireNumber {
public static void main(String[] arg) {
String[] str1, str2;
int sum = 0;
int from;
int to;
int val;
int count = 0;
// 双重循环穷举
for (int i = 10; i < 100; i++) {
// j=i+1避免重复
from = Math.max(1000 / i, i + 1);
to = Math.min(10000 / i, 100);
for (int j = from; j < to; j++) {
val = i * j;
/*
* 假设val = 1000a + 100b + 10c + d, 因为满足val = x * y, 则有x = 10a + b, y = 10c + d
* 则val - x - y = 990a + 99b + 9c = 9 * (110a + 11b + c),
*所以val - x - y能被9整除。 所以满足该条件的数字必定能被9整除，所以可以直接过滤其他数字。
*/
if (val % 100 == 0 || (val - i - j) % 9 != 0) {
continue;
}
count++;
str1 = String.valueOf(val).split("");
str2 = (String.valueOf(i) + String.valueOf(j)).split("");
Arrays.sort(str1);
Arrays.sort(str2);
if (Arrays.equals(str1, str2)) {// 排序后比较,为真则找到一组
sum++;
System.out.println("第" + sum + "组: " + i + "*" + j + "=" + val);
}
}
}
System.out.println("共找到" + sum + "组吸血鬼数");
System.out.println(count);
}
}
结果：
第1组: 15*93=1395
第2组: 21*60=1260
第3组: 21*87=1827
第4组: 27*81=2187
第5组: 30*51=1530
第6组: 35*41=1435
第7组: 80*86=6880
共找到7组吸血鬼数
232
//未运行
public class XiXueGuiJudge {
public XiXueGuiJudge()
{
}
void main(){
//输入数据
Scanner scanner=new Scanner(System.in);
System.out.println("请输入一个数据");
int s=scanner.nextInt();
int i,a,b,c,d,num=s;
a=num%10;
num/=10;
b=num%10;
num/=10;
c=num%10;
num/=10;
d=num%10;
for (i=1000;i<10000;i++)
{
if ( (a*10+b)*(b*10+c)==s||
(a*10+b)*(c*10+d)==s||
(b*10+a)*(b*10+c)==s||
(b*10+a)*(c*10+d)==s||
(a*10+c)*(b*10+d)==s||
(c*10+a)*(d*10+b)==s||
(c*10+a)*(b*10+d)==s||
(a*10+d)*(b*10+c)==s||
(a*10+d)*(c*10+b)==s||
(d*10+a)*(b*10+c)==s||
(d*10+a)*(c*10+b)==s
)
{System.out.println(i+"是一个吸血鬼数字");}
}
}
package xiXueGui;
public class Main {
public static void main(String[] args)
{XiXueGuiJudge xx=new XiXueGuiJudge();
xx.main();
}
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 天耀18期 – 05.面向对象-封装【作业】.
- 天耀18期 – 6.面向对象-类和对象【作业】.
- 天耀18期 -08.面向对象-上转型【作业】
- Java基础笔记整理---【08】面向对象程序设计-包、继承、访问权限
- C++面向对象开发：继承、多态、重载及访问修饰符
- java知识点 (继承、对象、复用类、初始化、访问权限控制等)
- 面向对象 【访问修饰符 】【封装】【继承】【多态】
- java知识点 (继承、对象、复用类、初始化、访问权限控制等)
- 面向对象，类的组合关系，继承，实现，方法重写，方法重载，this的使用，抽象方法和抽象类的比较，父类构造方法存在的意义，多态的是用和解析，各种访问修饰符
- JAVA进阶 面向对象程序设计——第4章 继承与多态【不同访问属性使子类在使用这些成员时不同】
- 面向对象程序设计：继承成员访问控制机制
- 面向对象技术继承访问控制
- [零基础学JAVA]Java SE面向对象部分-21.包及访问权限 推荐
- Java第四次作业--面向对象高级特性（继承和多态）
- 继承原则与子父类初始化过程，类成员访问权限，普通类与抽象类，throwble类，重写与重载，string对象修改，i=i++;
- php面向对象笔记3 封装和权限修饰符以及继承
- 面向对象程序设计之访问控制、继承与拷贝控制
- 【学习笔记07】java面向对象-继承
- C++ 类的继承,子类以及之类的对象 对父类成员函数的访问权限
- java面向对象-super、继承、覆盖、多态、类加载、访问控制