黑马程序员——解题笔记（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培训、期待与您交流！ ----------