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,成员方法,内嵌类(接口)中
}
源代码和详细的注释已经给出,希望对大家有所帮助,谢谢查阅!