黑马程序员——解题笔记（2）——我的基础测试题

------- android培训、java培训、期待与您交流！
----------

package com.itheima;
/**
* 1、 编写一个函数，函数内输出一个字符串，并在主函数内调用它
* @author Pan
*
*/
public class Test1 {

public static void main(String[] args) {
//调用函数
String str = getString();
//打印该字符串
System.out.println(str);
}

//函数内输出字符串
public static String getString() {

//定义一个字符串
String s = "itheima";

//返回该字符串
return s;
}

}

package com.itheima;

/**
* 2、 编写程序计算12+22+32+....+1002的和
* 思路：
* （1）看到题目想到用循环或者递归，而递归效率较低，故用for循环
* （2）for循环初值12，步长10
* （3）定义一个变量存储累加的结果
* @author Pan
*/
public class Test2 {

public static void main(String[] args) {

getSum();
}

public static void getSum() {

//定义变量存储累加的结果
int sum = 0;

//通过for循环赋初值，并设定步长，结果累加到sum中
for (int i=12; i<=1002 ; i+=10 ){
sum += i;
}
//打印结果
System.out.println("12+22+32+....+1002="+sum);
}

}

package com.itheima;
/**
* 3、 定义一个二维int数组，编写代码获取最小元素
* 思路：
* （1）定义一个变量min存储最小值
* （2）将二维数组第一个元素赋值给min
* （3）遍历二维数组，将其值与min比较，若某一个值比min小，
* 将其值赋给min，依次类推
* @author Pan
*
*/
public class Test3 {

public static void main(String[] args) {

//定义一个二维数组
int[][] arr = {{4,2,7,6},{5,9,3,8}};

int min = getMin(arr);

System.out.println("min="+min);

}

private static int getMin(int[][] arr) {

//先假设最小值min是角标[0][0]的元素
int min = arr[0][0];

//遍历二维数组，将其中元素与min的值比较
for (int i=0; i<arr.length; i++)
for (int j=0; j<arr[i].length; j++){

//如果min的值比该元素的值大，则把该元素赋值给min
if (min>arr[i][j])
min = arr[i][j];
}

return min;
}

}

package com.itheima;
/**
* 4、 什么情况下适合用UDP协议，什么情况下适合用TCP协议？
*
* UDP协议特点：
* （1）面向无连接，将数据、源和目的封装在数据包内
* （2）大小有限制，每个数据包在64K以内
* （3）因为面向无连接，所以不可靠
* （4）不需要建立连接，速度快
* 因此UDP常常在聊天、视频通话等对速度有要求，不怕丢包的服务中
*
* TCP协议特点：
* （1）面向连接，必须建立数据传输的通道
* （2）可以进行大量数据的传输
* （3）通过三次握手才能完成连接，是可靠协议
* （4）因需要建立连接，所以效率稍低
* 因此TCP常常应用在文件下载、大量数据传输等方面
*
* @author Pan
*
*/
public class Test4 {

public static void main(String[] args) {

System.out.println("Hello Heima!");
}

}

package com.itheima;
/**
* 5、 定义一个包含私有成员变量和函数的类，再定义一个内部类，
* 在内部类函数中访问外部成员变量，并调用外部函数。
* 在外部类函数中创建内部类对象，调用内部类函数。
* 思路：
* 1. 内部类访问外部成员变量，外部类成员变量必须被final修饰符修饰
* 2. 外部类函数创建内部类对象并调用其方法，可以在构造函数中完成
* 3. 内部类调用外部类函数，可调用其静态函数，通过类名调用，不需要
* 创建外部类对象
* @author Pan
*
*/
public class Test5 {

public static void main(String[] args) {

new Outer();

}

}

class Outer {
//定义外部成员私有变量，为了让内部类访问，需用final修饰
private final String str = "heima";

//外部类函数创建内部类对象，并调用内部类方法
Outer(){
new Inner().show();
}

//定义内部类
class Inner {
public void show(){
//内部类中访问外部类变量
System.out.println("Inner"+str);

//内部类中调用外部函数
Outer.play();
}

}

//因内部类调用该函数，为防止发生死循环，用静态修饰该函数
public static void play(){
System.out.println("Outer");
}
}

package com.itheima;

import java.util.Scanner;

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

public static void main(String[] args) {

//创建Person类对象
Person p = new Person();

//从键盘输入姓名、年龄
Scanner in = new Scanner(System.in);

//设置姓名
System.out.println("请输入姓名：");
p.setName(in.nextLine());
//设置年龄
System.out.println("请输入年龄：");
p.setAge(in.nextInt());

//调用sayHello方法
p.sayHello();

}

}

class Person {
//定义name、age变量，并set、get两个变量
private String name;
private int age;

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 void sayHello(){

System.out.println("我叫"+getName()+"，今年"+getAge()+"岁了。");
}

}

//声明类Chinese继承Person
class Chinese extends Person {

}

package com.itheima;
/**
* 7、 编程列出一个字符串的全字符组合情况，原始字符串中没有重复字符
* 例如：原始字符串是"abc"，打印得到下列所有组合情况：
* "a" "b" "c"
*  "ab" "bc" "ca" "ba" "cb" "ac"
*  "abc" "acb" "bac" "bca" "cab" "cba"
*
*  思路：
*  （1）字符全排列，考虑到使用递归
*  （2）使用递归应设置结束条件
*  （3）在循环中取字符，在循环中取分别以a、b、c为前缀的单个字符
*  再通过递归与后面的字符累加。
*  （4）字符中不能有重复字符，因此要判断是否包含，用contains方法
*  （5）判断后将累加所得字符输出，并将字符传入下一层递归
*
* @author Pan
*
*/

public class Test7 {

public static void main(String[] args) {
//定义字符串
String str = "abc";
//定义循环次数
int cycleTimes = 0;
//定义变量存储累加后的字符串
String temp = "";
//将字符串、循环次数等传入函数
show(str,temp,cycleTimes);
}
// 递归 函数
public static void show(String str,String temp,int cycleTimes) {

//每次循环增加一字符，因此循环次数小于字符串长度
if (cycleTimes < str.length()) {

//通过循环取分别以a、b、c为前缀的字符
for (int i = 0; i < str.length(); i++) {

//字符不能重复，判断是否包含该字符
if (!(temp.contains(str.substring(i, i+1)))) {
//输出每次累加后的字符串
//不能改变temp的赋值，下层递归结束后，此层递归还要继续运算
System.out.print( temp + str.substring(i,i + 1)+"\t");

//将改变后的字符串传入下一层，并将循环次数加一
show(str, temp + str.substring(i,i + 1),cycleTimes + 1);
}
}
}
}
}

package com.itheima;
/**
* 8、 throw和throws有什么区别？
* throw是抛出一个具体的异常类型，用在函数内部，后面抛出异常对象。
* throws是用来声明一个方法可能抛出的异常信息，用在函数上，
* 		  后面可以跟多个异常类名，用逗号隔开。
*
*  try、catch、finally分别在什么情况下使用？
*  （1）try语句：
*  某段代码中可能抛出异常，将其放入try语句，用来检测异常。
*  一旦发生异常就会跳转到catch，否则不会执行catch
*  （2）catch语句：
*  除非try语句中的代码发生异常，否则这里的代码不会执行，用来接收并处理
*  try语句中发生的异常，参数中的异常类型必须是Throwable类的子类对象。
*  （3）finally语句：
*  finally所指定的代码一定会执行，它提供了统一的出口，用来存放
*  一定会执行的语句，比如关闭线程等。
*
* @author Pan
*
*/
public class Test8 {

public static void main(String[] args) {

System.out.println("Hello Heima!");
}

}

package com.itheima;
/**
* 9、 有这样三个类，Person、Student、GoodStudent。
* 其中GoodStudent继承于Student，Student继承于Person。
* 如何证明创建GoodStudent时是否调用了Person的构造函数？
* 在GoodStudent中是否能指定调用Student的哪个构造函数？
* 在GoodStudent中是否能指定调用Person的哪个构造函数？
*
* 思路：
* 1. 证明创建GoodStudent时调用了Person的构造函数
* 在Person类中空参数构造函数里写内容，观察是否会运行
* 2. GoodStudent中指定调用Student的构造函数
* 可以调用，子类构造函数中第一句有隐式的super(),把隐式改为显示
* 即可调用指定的构造函数
* 3. GoodStudent中指定调用Person的构造函数
* 不可以直接调用，只能通过Student调用，GoodStudent和Person
* 没有直接继承关系
* @author Pan
*
*/
public class Test9 {

public static void main(String[] args) {

new GoodStudent();
new GoodStudent("黑马",10);

}

}

//因Test6中定义了Person类，所以只能重命名该类
class Person_1 {

//空参数的Person构造函数，会被未指定参数的子类构造函数调用
public Person_1() {
System.out.println("person run");
}

//带参数的Person构造函数，会被指定参数的子类构造函数调用
public Person_1(String name,int age) {

System.out.println("person"+name+age);
}
}

//Student继承Person
class Student extends Person_1 {

//空参数的Student构造函数，会被未指定参数的子类构造函数调用
public Student() {
System.out.println("studnt run");
}

//带参数的Student构造函数，会被指定参数的子类构造函数调用
public Student(String name,int age) {
//显式super语句，调用带参数的Person类构造函数
super(name,age);

System.out.println("student"+name+age);
}
}

//GoodStudent继承Student
class GoodStudent extends Student {

//有隐式super()；会调用空参数Student构造函数
public GoodStudent() {
System.out.println("goodstudnt run");
}

public GoodStudent(String name,int age) {
//显式super语句，调用带参数的Student类构造函数
super(name,age);

System.out.println("goodstudent"+name+age);
}
}

package com.itheima;
/**
* 10、 小明的妈妈每天会给他20元零花钱。平日里，小明先花掉一半，
* 再把一半存起来。每到周日，小明拿到钱后会把所有零花钱花掉一半。
* 请编程计算，从周一开始，小明需要多少天才能存够100元？
* 思路：
* （1）定义两个变量，day和money，控制天数和钱
* （2）使用while循环，天数每天自增，每天妈妈会给小明20元
* （3）每到第七天，小明会花掉总钱数的一半
* （4）其他六天每天只花10块钱
* @author Pan
*
*/
public class Test10 {

public static void main(String[] args) {
//定义两个变量并赋初值
int money = 0;
int day = 0;

//当存够100元时结束循环
while (money < 100) {
//天数每天自增
day++;
//每天钱固定增加20
money += 20;

//每到第七天钱数减少一半
if(day % 7 == 0) {
money /= 2;
}
else {
//其他时候每天只用20块的一半
money -= 20/2;
}

}

System.out.println("第"+day+"天存够了"+money+"元");

}

}

------- android培训、java培训、期待与您交流！
----------