黑马程序员——黑马基础测试

package com.itheima;

import java.util.ArrayList;
import java.util.Iterator;

/**
需求：创建ArrayList对象，添加5个元素，使用Iterator遍历输出

思路：
建立一个新的ArrayList集合对象
添加5个元素
用Iterator遍历输出
@author run_wind
*/
class Test1
{
public static void main(String[] args)
{
//实例化ArraryList对象，加泛型将运行时期出现的ClassCastException转移到编译时期。
ArrayList<String> arr = new ArrayList<String>();

//添加5个新元素
arr.add("Hello");
arr.add("Java");
arr.add("Hello");
arr.add("Heima");
arr.add("future");

//用迭代器，遍历输出
for(Iterator<String> it =arr.iterator();it.hasNext(); )
{
System.out.println(it.next());
}
}
}

package com.itheima;

import java.util.Scanner;

/**
需求： 从键盘接受一个数字，打印该数字表示的时间，最大单位到天，例如：
键盘输入6，打印6秒；
键盘输入60，打印1分；
键盘输入66，打印1分6秒；
键盘输入666，打印11分6秒；
键盘输入3601，打印1小时1秒

思路：		写一个函数，功能为输入一个正整数，按照格式打印出来
建立一个数组，分别对应天，时，分，秒
换算
按格式输出
用Scanner扫描，输入的数并传递
调用功能函数
@author run_wind
*/

class Test2
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
while (true)
{
//输入一个数，并将输入信息的下一个标记扫描为一个 int
System.out.print("请输入一个正整数：");
int num = in.nextInt();
printTime(num);
}
}
//输入一个数，转换成对应的时间并打印
public static void printTime(int num)
{
//数组arr[0],arr[1],arr[2],arr[3]分别对应天，时，分，秒
int[]arr = new int[4];
int pos = arr.length;
while (num>0)
{
//如果分秒大于60分钟，则进1
int tmp = num%60;
arr[--pos] = tmp;
num = num/60;

//小时如果大于24小时，则进1
if (arr[1]>=24)
{
arr[0] = arr[1]/24;
arr[1] = arr[1]%24;
}
}

//按格式输出数组
for (int i=0; i<arr.length; i++)
{
//如果不等于0则进入循环选择打印
if (arr[i]!=0)
{
switch (i)
{
case 0:System.out.print(arr[i] + " 天 "); break;
case 1:System.out.print(arr[i] + " 时 "); break;
case 2:System.out.print(arr[i] + " 分 "); break;
case 3:System.out.print(arr[i] + " 秒 "); break;
default:break;
}
}
}
System.out.println();//换行
}
}

package com.itheima;

/**
需求：什么情况下适合用UDP协议，什么情况下适合用TCP协议？

答：UDP 将数据及源和目的封装成数据包中
不需要连接，速度快
每个数据包的大小限制在64k内
不安全，有可能丢失文件、
当通信对速度有要求，同时可以允许一定的丢包率的情况下，采用UDP，像即时通信，在线视频

TCP 建立连接，形成传输数据的通道
可以在连接中进行大数据传输。
通过三次握手完成连接，是可靠协议。
因为必须建立连接，所以相对较慢。
当通信对数据的准确性要求较高的时候就采用TCP，像收发电子邮件或者下载文件

总结一句话：追求安全，对传输数据要求高的话就用TCP，否则UDP
@author run_wind
*/

class Test3
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}

package com.itheima;

/**
需求：编程计算3乘8等于几，什么方法效率更高？

@author run_wind
*/

class Test4
{
public static void main(String[] args)
{
//位移运算符是效率最高的计算方式
System.out.println(3<<3);
}
}

package com.itheima;

/**
需求：分析运行结果，说明原理。(没有分析结果不得分)

class A
{
void fun1()
{
System.out.println(fun2());
}
int fun2()
{
return 123;
}
}
public class B extends A
{
int fun2()
{
return 456;
}
public static void main(String args[])
{
B b = new B();
b.fun1();
A a = b;
a.fun1();
}
}

@author run_wind
*/

/*
B b = new B();   把B函数实例化b，B继承了A函数，子类中出现与父类一模一样的方法时，会出现覆盖操作，复写了其中重名的方法
b.fun1(); 		 fun1()执行调用重写后fun2(),返回456  打印456
A a = b; 		    运用了多态，类型提升：向上转型。父类的引用指向或者接收自己的子类对象，a和b指向对内存中的同一对象。
a.fun1(); 		    成员函数在多态调用时，编译看左边，运行看右边。 所以一样的，依旧打印456

结果：456
456

*/
class Test5
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}

package com.itheima;

import java.util.Scanner;

/**
需求：声明类Person，包含2个成员变量：name、age。定义函数sayHello()，调用时输出：我叫***，今年***岁了。声明类Chinese继承Person。

思路：		声明Person类，声明name,age变量。
定义函数sayHello(),功能调用时输出：我叫***，今年***岁了
声明类Chinese继承Person。
输入名字，年龄，扫描通过sayHello函数输出。

@author run_wind
*/

class Person//声明一个Person类
{
private String name;
private int age;

//设置set，get修改方法
public void setName(String name)
{
this.name = name;
}
public void setAge(int age)
{
this.age = age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}

//定义sayHello函数，功能调用时输出：我叫***，今年***岁了
public void sayHello(String name,int age)
{
this.name = name;
this.age = age;
System.out.println("我叫"+name+",今年"+age+"岁了。");
}
}

class Chinese extends Person//声明一个Chinese类继承Person
{
}

class  Test6
{
public static void main(String[] args)
{
Person p = new Person();//实例化Person

//输入姓名，年龄，通过sayHello()调用。
Scanner in = new Scanner(System.in);//获取键盘输入的实例

System.out.print("请输入姓名：");
String name = in.nextLine();

System.out.print("请输入年龄：");
int age = in.nextInt();

p.sayHello(name,age);
}
}

package com.itheima;
/**
需求：用控制台程序倒着输出九九乘法表；输出结果按下图所示：

1*9=9    2*9=18    3*9=27    4*9=36    5*9=45    6*9=54    7*9=63    8*9=72    9*9=81

……

1*3=3   2*3=6   3*3=9

1*2=2   2*2=4

1*1=1
思路：分析图，是一个倒的乘法口诀表
大圈套小圈思想，可以用for循环嵌套来实现
设被乘数x,乘数y
横排x递增，y不变，一共y列
竖排x不变，y递减，一共9行不变
打印，tab分隔距离，打完一行要换行
@author run_wind
*/

class Test7
{
public static void main(String[] args)
{
for (int y=9; y>=1; y--)//竖排x不变，y递减，一共9行不变
{
for (int x=1; x<=y; x++)//横排x递增，y不变，一共y列
{
System.out.print(x+"*"+y+"="+x*y+"\t");// 打印，tab分隔距离
}
System.out.println();//换行
}
}
}

package com.itheima;
/**
需求：声明类Student，包含3个成员变量：name、age、score
要求可以通过 new Student("张三", 22, 95) 的方式创建对象，并可以通过set和get方法访问成员变量

思路：  声明一个学生类，私有名字，年龄，分数。
创建一个Student(name,age,score)的构造函数，可以通过new Student("张三", 22, 95) 的方式创建对象
依次写出get set方法
因为私有，所以只能本类函数访问，所以声明一个打印的方法
主函数调用测试
@author run_wind
*/
class Student//声明一个学生类
{
private String name;//名字
private int age;//年龄
private int score;//分数

//构造构造函数
Student(String name,int age,int score)
{
this.name = name;
this.age = age;
this.score = score;
}

//依次写出get set方法
public void setName(String name)
{
this.name = name;
}
public void setAge(int age)
{
this.age = age;
}
public void setScore(int score)
{
this.score = score;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public int getScore()
{
return score;
}

public void show()//因为私有，所以只能本类函数访问，所以声明一个打印的方法show()
{
System.out.println("   name:"+name+"   age:"+age+"   score:"+score);
}
}

class Test8
{
public static void main(String[] args)
{
Student stu = new Student("张三",25,76);//实例化一个Student对线，并初始化
stu.show();//打印

//修改名字，年龄，分数 测试
stu.setName("李四");
stu.setAge(26);
stu.setScore(90);
stu.show();//打印
}
}

package com.itheima;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
需求：写一个正则表达式，可以匹配尾号5连的手机号。
规则: 第1位是1，第二位可以是数字3458其中之一，后面4位任意数字，最后5位为任意相同的数字。例如：18601088888、13912366666
@author run_wind
*/

class Test9
{
public static void main(String args[]) throws IOException
{
// 定义一个缓冲区
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入电话号码:");
String num = null;
try
{
// 读取输入的字符串
num = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
// 正则表达式规则
String phone = "[1][3-5[8]]\\d{4}(\\d)\\1{4}";

System.out.println(num.matches(phone));
}
}

package com.itheima;

import java.io.IOException;
import java.util.Scanner;

/**
需求：编写函数，从一个字符串中按字节数截取一部分，但不能截取出半个中文（GBK码表）。
例如：从“HM程序员”中截取2个字节是“HM”，截取4个则是“HM程”，截取3个字节也要是"HM"而不要出现半个中文

思路：  输入一个字符串，和要截取的字数
定义一个函数，函数功能：从一个字符串中按字节数截取一部分，但不能截取出半个中文（GBK码表）
把字符串转成字节数组
因为中文GBK是返回两个负数，所以从最后一个开始往前遍历
定义一个计数器，遍历，如果便利到负数就+1。
如果负数个数为单数，那么为半个中文，舍弃，返回-1之前的数，转换成字符串输出
否则为一个中文，转换成字符串输出
@author run_wind
*/

class Test10
{
public static void main(String[] args) throws IOException
{

Scanner in = new Scanner(System.in);//获取键盘输入的实例
System.out.print("请输入字符串（直接回车默认HM程序员）：");
String string = in.nextLine();
if (string.equals(""))
string = "HM程序员";
System.out.print("请输入截取的字节数：");
int byte_num = in.nextInt();

Test10 t10 = new Test10();
System.out.println(t10.getString(string, byte_num));
}

//函数功能：从一个字符串中按字节数截取一部分，但不能截取出半个中文（GBK码表）
public String getString(String str,int key) throws IOException
{
byte[] buf = str.getBytes("gbk");//编码

//因为中文GBK是返回两个负数，所以从最后一个开始往前遍历
//如果负数个数为单数，那么为半个中文，舍弃，否则为一个中文，返回
int count = 0;
for(int x=key-1; x>=0; x--)
{
if(buf[x]<0)
count++;
else
break;
}

if(count%2==0)//解码。如果为单数就是半个中文，要舍弃最后的数
return new String(buf,0,key,"gbk");
else
return new String(buf,0,key-1,"gbk");
}
}