黑马程序员 java基础测试(2013年4月)_创建一个包含有private属性和private方法的类然后创建一个内部类-CSDN博客

本文链接：https://blog.csdn.net/SSSSword/article/details/8806411

-------android培训、java培训、java学习型技术博客、期待与您交流！ ----------

1、环境变量path和classpath的作用是什么？

2、已知一个int数组, 编程从数组中获取最大数.

3、编写程序计算1+2+3+....+100的和.

4、 UDP协议与TCP协议有什么不同？

5、创建一个包含有private的属性和private方法的类。然后创建一个内部类，它有一个方法可用来修改外部类的属性，并调用外部类的方法。在外部类的另一个方法中，创建此内部类的对象，并且调用它的方法。

6、输入一个数字组成的数组，输出该数组的最大值和最小值

7、编写程序获取已知文件的扩展名. 注意: abc.txt的扩展名是txt, abc.java.txt的扩展名也是txt.

8、定义一个学生类, 需要有姓名, 年龄, 考试成绩三个成员属性. 属性(成员变量)需要私有并提供get, set方法, 可以通过构造函数进行初始化.

9、有这样三个类，Person,Student.GoodStudent。其中Student继承了Person,GoodStudent继承了Student,三个类中只有默认的构造函数，用什么样的方法证明在创建Student类的对象的时候是否调用了Person的构造函数，在创建GoodStudent类的对象的时候是否调用了Student构造函数？如果在创建Student对象的时候没有调用Person的构造函数，那么采用什么样的手段可以调用父类的构造函数？

10、定义一个学生类, 需要有姓名, 年龄, 考试成绩三个成员属性，创建5个对象, 属性可为任意值. 编程对这5个对象按成绩排序，并将结果输出。（提示，用TreeSet和Comparator实现）

package com.itheima;

/**
 * 第一题： 环境变量path和classpath的作用是什么？
 *@author Sword
 *
 *答：1. path环境变量:作用是指定命令搜索路径，在dos系统行下面执行命令如javac编译java程序时，
 *它会到path变量所指定的路径中查找看是否能找到相应的命令程序。
 *我们需要把jdk安装目录下的bin目录增加到现有的path变量中，
 *bin目录中包含经常要用到的可执行文件如javac/java/javadoc等待，设置好path变量后，就可以在任何目录下执行javac/java等工具了。
 *2. classpath环境变量:作用是指定类搜索路径，要使用已经编写好的类，
 *前提当然是能够找到它们了，JVM就是通过classpath来寻找类的。
 *我们需要把jdk安装目录下的lib子目录中的dt.jar和tools.jar设置到CLASSPATH中，
 *当然，当前目录“.”也必须加入到该变量中。
 */
public class Test1 {

	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
        System.out.println("1. path环境变量:作用是指定命令搜索路径，在dos系统行下面执行命令如javac编译java程序时，它会到path变量所指定的路径中查找看是否能找到相应的命令程序。我们需要把jdk安装目录下的bin目录增加到现有的path变量中，bin目录中包含经常要用到的可执行文件如javac/java/javadoc等待，设置好path变量后，就可以在任何目录下执行javac/java等工具了。");
        System.out.println("2. classpath环境变量:作用是指定类搜索路径，要使用已经编写好的类，前提当然是能够找到它们了，JVM就是通过classpath来寻找类的。我们需要把jdk安装目录下的lib子目录中的dt.jar和tools.jar设置到CLASSPATH中，当然，当前目录“.”也必须加入到该变量中。");
	}
}

package com.itheima;

/**
 * 第二题： 已知一个int数组, 编程从数组中获取最大数
 *@author Sword
 */

public class Test2 {
	
	public static void main(String[] args)
	{
		//自己定义一个数组
		int values[] = {1,7,9,3,4,8,6,5,2};
		
		int max = getMax(values);
		//打印输出结果
		System.out.printf("数组中的最大值为（The MAX values）: %d\n", max);
	}
    //定义getMax方法
	public static int getMax(int[] values)
	{
		//定义一个临时变量
		int tmp=Integer.MIN_VALUE;
		
		if(values!=null)
		{
			//变量赋值为数组的第一个数
			tmp=values[0];
			//for循环进行遍历
			for(int i=0; i<values.length; i++)
			{
				//进行比较
				if(tmp<values[i])
				{
					tmp = values[i];
				}
			}
		}
		
		return tmp;		
	}
}

package com.itheima;


/**
 * 第三题： 编写程序计算1+2+3+....+100的和
 *@author Sword
 */


public class Test3 {
	
	public static void main(String[] args){
		
		定义一个变量接收它们的和，初始值为0
		 int sum=0;
		 //for循环遍历1-100之间的所以整数.
		 for (int i = 1; i <=100; i++) {
			  //在for遍历期间从1到100之间每个数都加起来给sum.
			  sum+=i;
		 }
		 //打印输出
	      System.out.println(sum);
   }
}

package com.itheima;


/**
 * 第四题：  UDP协议与TCP协议有什么不同？
 *@author Sword
 *
 *答：
 *UDP（User Data Protocol，用户数据报协议）是与TCP相对应的协议。它是面向非连接的协议，它不与对方建立连接，而是直接就把数据包发送过去,
 *不需要验证，服务端直接发包，包的到达客户端的顺序也不一定是按照发包时候的顺序一样，相对容易丢包 .
 *TCP（Transmission Control Protocol，传输控制协议）是基于连接的协议，
 *也就是说，在正式收发数据前，必须和对方建立可靠的连接。一个TCP连接必须要经过三次“对话”才能建立起来
 *也就是说需要验证，有三次握手，服务端发包的时候有优化，小包会等到一起发，相对较安全不容易丢包 ，UDP适用于一次只传送少量数据、对可靠性要求不高的应用环境
 */
public class Test4 {
	public static void main(String[] args) {
		System.out.println("UDP（User Data Protocol，用户数据报协议）是与TCP相对应的协议。" +
				"它是面向非连接的协议，它不与对方建立连接，而是直接就把数据包发送过去," +
				"不需要验证，服务端直接发包，包的到达客户端的顺序也不一定是按照发包时候的顺序一样，" +
				"相对容易丢包 .TCP（Transmission Control Protocol，传输控制协议）是基于连接的协议，" +
				"也就是说，在正式收发数据前，必须和对方建立可靠的连接。" +
				"一个TCP连接必须要经过三次“对话”才能建立起来.也就是说需要验证，" +
				"有三次握手，服务端发包的时候有优化，小包会等到一起发，相对较安全不容易丢包 ，" +
				"UDP适用于一次只传送少量数据、对可靠性要求不高的应用环境");
	}

}

package com.itheima;

/**
 * 第五题：创建一个包含有private的属性和private方法的类。
 * 然后创建一个内部类，它有一个方法可用来修改外部类的属性，并调用外部类的方法。
 * 在外部类的另一个方法中，创建此内部类的对象，并且调用它的方法。
 *@author Sword
 */
//定义外部类
class Outer                                                                        
{
	   //外部类私有属性
	    private int x = 0;    
	    //外部类私有方法
        private void method()                                      
        {
                System.out.println("method run");
        }
        //定义内部类
        class Inner                                                              
        {
        	   //内部类修改外部类属性x，并调用外部类method()的方法
        	    void xiugai(int a)                                        
                {
        	    	   //修改外部类私有属性
                        x = a;                                                      
                        System.out.println("x="+x);
                        //内部类调用外部类的mehtod()方法
                        method();                                              
                }
        }
        public void function(int b)                                      
        {
        	//创建内部类对象并调用内部类方法的外部类的方法   
        	new Inner().xiugai(b);
        }
}

class Test5
{
        public static void main(String[] args)
        {
        	  //创建外部类对象并调用它的function()方法
              new Outer().function(10);                      
        }
}

package com.itheima;

/**
 * 第六题：输入一个数字组成的数组，输出该数组的最大值和最小值
 *@author Sword
 */
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test6 {

	public static void main(String[] args) throws IOException {
		System.out.println("请输入一组数字(数字之间用空格隔开)：");
		// 创建输入流对象
		BufferedReader reader = new BufferedReader(new InputStreamReader(
				System.in));
		// 读取一行信息
		String input = reader.readLine();
		
		// 以空格为分隔符，转换成数组
		String[] numbers = input.split(" ");
		int[] values = new int[numbers.length];
		for (int j = 0; j < numbers.length; j++) {
			values[j] = Integer.parseInt(numbers[j]);
		}
		// 回收numbers数组的资源
		numbers = null; 

		// 获取接收到的数组里面的最大、最小数值
		// 获取最大值和获取最小值分别写成了两个函数的话，就等于是多遍历了一遍这个数组，效率降低了，可扩展性增强了
		System.out.printf("最大值(MAX):%d, 最大值(MIN):%d\n", getMax(values), getMin(values));
	}

	public static int getMax(int[] values) {
		int tmp = Integer.MIN_VALUE;

		if (values!=null) {
			tmp = values[0];
			for (int i = 0; i < values.length; i++) {
				if (tmp < values[i]) {
					tmp = values[i];
				}
			}
		}

		return tmp;
	}

	public static int getMin(int[] values) {
		int tmp = Integer.MIN_VALUE;

		if (values!=null) {
			tmp = values[0];
			for (int i = 0; i < values.length; i++) {
				if (tmp > values[i]) {
					tmp = values[i];
				}
			}
		}

		return tmp;
	}
}

package com.itheima;

/**
 * 第七题： 编写程序获取已知文件的扩展名. 
 * 注意: abc.txt的扩展名是txt, abc.java.txt的扩展名也是txt.
 *@author Sword
 */

import java.io.File;
import java.io.IOException;

public class Test7 {
	public static void main(String args[]) {
		//创建file对象，读入abc.txt
		File file = new File("abc.txt");
		File file1 = new File("abc.java.txt");
		
		if (!file.exists()) {
			//try-catch抛出异常
			try {
				file.createNewFile();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		//获取file的文件名，赋值给fname
		String fname = file.getName();
		String fname1 = file1.getName();
		//用substring截取文件名，lastIndexOf(".")是从最后一个.开始，长度为length的字符作为后缀名
		System.out.println(fname + ":扩展名是："
				+ fname.substring(fname.lastIndexOf(".") + 1, fname.length()));
		System.out.println(fname1 + ":扩展名是："
				+ fname.substring(fname.lastIndexOf(".") + 1, fname.length()));
	}
}

package com.itheima;

/**
 * 第八题：定义一个学生类, 需要有姓名, 年龄, 考试成绩三个成员属性. 
 *        属性(成员变量)需要私有并提供get, set方法, 可以通过构造函数进行初始化.
 *@author Sword
 */

public class Test8 {
	
	 private String name;
	 private int age;
	 private double grade;
	 
	 //通过构造函数进行初始化成员属性
	 public Test8(String name, int age, double grade) {
		super();
		this.name = name;
		this.age = age;
		this.grade = grade;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public double getGrade() {
		return grade;
	}
	public void setGrade(double grade) {
		this.grade = grade;
	}

}

package com.itheima;


/**
 * 第九题：有这样三个类，Person,Student.GoodStudent。
 * 其中Student继承了Person,GoodStudent继承了Student,
 * 三个类中只有默认的构造函数，
 * 用什么样的方法证明在创建Student类的对象的时候是否调用了Person的构造函数，
 * 在创建GoodStudent类的对象的时候是否调用了Student构造函数？
 * 如果在创建Student对象的时候没有调用Person的构造函数，
 * 那么采用什么样的手段可以调用父类的构造函数？
 *@author Sword
 */

public class Test9 {

	public static void main(String[] args) {
		
		Person p1=new Person();
		System.out.println("-------------------------------");
		Student s1 = new Student();
		System.out.println("-------------------------------");
		Student s2 = new Student();
		System.out.println("-------------------------------");
		GoodStudent g1 = new GoodStudent();
		System.out.println("-------------------------------");
	}

}

class Person {

	Person() {
		System.out.println("I'm Person!");
	}

	Person(String arg) {
		System.out.println(arg);
	}

	Person(String arg1, String arg2) {
		System.out.println(arg1 + arg2);
	}
}

class Student extends Person {

	Student() {
		super("have arg!"); 
		System.out.println("I'm Student!");
	}

	Student(String arg) {
		super("have arg!", "in Person");
		System.out.println(arg);
	}
}

class GoodStudent extends Student {

	GoodStudent() {
		super("from GoodStudent!");
		System.out.println("I'm GoodStudent!");
	}

}

package com.itheima;

/**
 * 第十题：定义一个学生类, 需要有姓名, 年龄, 考试成绩三个成员属性，
 * 创建5个对象, 属性可为任意值. 编程对这5个对象按成绩排序，并将结果输出。
 * （提示，用TreeSet和Comparator实现）
 * *******************按成绩小->大排序****************
 * @author Sword
 *
 */

import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class Test10 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student_ stu1=new Student_("James", 21, 99);
		Student_ stu2=new Student_("Paul", 25, 95);
		Student_ stu3=new Student_("Wade", 29, 96);
		Student_ stu4=new Student_("Kobe", 25, 98);
		Student_ stu5=new Student_("Sword", 18, 86);
		// 创建TreeSet
		Set<Student_> st=new TreeSet<Student_>(new Student_.TestScoresCompare<Student_>());
		st.add(stu5);	st.add(stu4);	st.add(stu3);	st.add(stu2);	st.add(stu1);
		//遍历
		Iterator<Student_> it=st.iterator();
		while(it.hasNext()){
			Student_ student=it.next();
			System.out.println(student.getName()+"  年龄: "+student.getAge()+"  成绩: "+student.getTest_scores());
		}
	}

}

class Student_{
	// 三个属性
	private String name;
	private int age;
	private int test_scores;
	public String getName(){
		return this.name;
	}
	public int getAge(){
		return this.age;
	}
	public int getTest_scores(){
		return this.test_scores;
	}
	
	Student_(String name, int age, int test_scores){// 构造器
		this.name=name;
		this.age=age;
		this.test_scores=test_scores;
	}
	// 这里要用静态类
	static class TestScoresCompare<T> implements Comparator<T>{
		// 注意：Comparator<T>是泛型，实现了这个接口的类也要是泛型
		 实现比较器
		@Override
		public int compare(T o1, T o2) {
			Student_ stu1=(Student_)o1;
			Student_ stu2=(Student_)o2;
			
			if(stu1.test_scores>stu2.test_scores){
				return 1;
			}
			return -1;
		}
		
	}
	// 泛型参数可以出现在：类class，接口superface，成员方法，内嵌类（接口）中
}

源代码和详细的注释已经给出，希望对大家有所帮助，谢谢查阅！

最新最全的的java学习视频教程：http://pro.net.itcast.cn/View-22-1458.aspx

-------android培训、java培训、java学习型技术博客、期待与您交流！ ----------

详细请查看：http://edu.csdn.net/heima