javaSE各阶段练习题--面向对象-StringBuilder-继承-包和访问权限

1、将前一天作业，用StringBuffer进行改造，尽量提升时间和空间效率
定义一个方法，功能如下：给定一个数组，转换成一个字符串
例如：数组为int[] arr = {1, 2, 3}，字符串为[1, 2, 3]
	
	int[] arr = {1,2,3};
	StringBuilder sBuilder = new StringBuilder();
	sBuilder.append("[");
	for (int i = 0; i < arr.length; i++) {
		sBuilder.append(arr[i]).append(",");
	}
	sBuilder.deleteCharAt(sBuilder.length()-1);
	sBuilder.append("]");
	System.out.println(sBuilder.toString());
分析以下需求，并用代码实现：
	(1)从键盘循环录入录入一个字符串,输入"end"表示结束
	(2)将字符串中大写字母变成小写字母，小写字母变成大写字母，其它字符用"*"代替,并统计字母的个数
		举例:
			键盘录入：Hello12345World
StringBuilder sBuilder = new StringBuilder();
		boolean flag = true;
		while(flag) {
			Scanner sc = new Scanner(System.in);
			System.out.println("请输入:");
			String str = sc.nextLine();
			if (str.equals("end")) {
				flag = false;
				break;
			}
			sBuilder.append(str);			
		}
		String str = sBuilder.toString();
		sBuilder.delete(0, sBuilder.length());//清空sBuilder
		int count = 0;
		for (int i = 0; i < str.length(); i++) {
			char c = str.charAt(i);
			if (c >= 65 && c <= 90) {
				sBuilder.append((char)(c+32));
				count++;
			}else if (c >= 97 && c <= 122) {
				sBuilder.append((char)(c-32));
				count++;
			}else if (c <= 57 && c >= 48) {
				sBuilder.append((char)42);
			}else {
				sBuilder = sBuilder;
			}
		}
		System.out.println(sBuilder.toString());
		System.out.println("总共"+count+"个字母");
			输出结果：hELLO*****wORLD
					  总共10个字母


2、代码分析：
	第一个：分析如下代码，判断哪行报错，并说出报错原因
		class Demo{
			final int a = 10;
		}

		class Test{
			public static void main(String[] args) {
				Demo d = new Demo();
				d = new Demo();
				d.a = 20;      //这一行会报错，因为final修饰的变量是常量，初始化后不能被修改
			}
		}


	第二个：分析如下代码，判断哪行报错，并说出报错原因
		class Demo{
			int a = 10;
		}

		class Test{
			public static void main(String[] args) {
				final Demo d = new Demo();
				d = new Demo();//这行会报错，final表示最终的意思，用final修饰的类、方法和变量不可改变
				d.a = 20;
			}
		}
	第三个：分析如下代码，判断哪行报错，并说出报错原因
		class Demo{
			final int a = 10;
		}

		class Test{
			public static void main(String[] args) {
				final Demo d = new Demo();
				d = new Demo();//这行会报错，final表示最终的意思，用final修饰的类、方法和变量不可改变
				d.a = 20;//这一行会报错，因为final修饰的变量是常量，初始化后不能被修改
			}
		}
	第四个：分析如下代码，判断哪行报错，并说出报错原因
		class Demo{
			int a = 10;
		}

		class Test{
			public static void main(String[] args) {
				Demo d = new Demo();
				d = new Demo();
				d.a = 20;
			}
		}
			无错误！

	第五个：分析如下代码，判断哪行报错，并说出报错原因
		class Demo{
			final int a;
		}

		class Test{
			public static void main(String[] args) {
				Demo d = new Demo();
				d = new Demo();
				d.a = 20;//？？？确定题没有重复？
			}
		}
3 定义两个类Dog,SmallDog，SmallDog继承Dog
  说明一：关于Dog
  两个属性，狗的名字(dogName,String)，狗的年龄(dogAge,int)
  一个方法，dogWalk()，打印一句话简单描述狗走路的样子
  一个构造方法，无参数，在此构造方法中初始化dogName,dogAge
  说明二：关于SmallDog
  继承Dog，不添加任何属性和方法 
  最后，在测试类中的main方法中生成SmallDog类的对象，
  访问属性dogName和dogAge，并打印出他们的值；调用dogWalk()，看看效果
Dog类
package com.henu;

public class Dog {
	private String dogName;
	private int dogAge;
	
	public Dog() {
		this.dogName = "狗王";
		this.dogAge = 6;
	}

	public void dogWark() {
		System.out.println("雄赳赳气昂昂");
	}

	public String getDogName() {
		return dogName;
	}

	public void setDogName(String dogName) {
		this.dogName = dogName;
	}

	public int getDogAge() {
		return dogAge;
	}

	public void setDogAge(int dogAge) {
		this.dogAge = dogAge;
	}
	
	
}

SmallDog类
package com.henu;

public class SmallDog extends Dog{
	
	

}

DogTest类
package com.henu;

public class DogTest {

	public static void main(String[] args) {
		
		SmallDog sDog = new SmallDog();
		String dogName = sDog.getDogName();
		int dogAge = sDog.getDogAge();
		System.out.println(dogName +"->"+dogAge);
		sDog.dogWark();
		
	}

}

输出结果：


4.在第1题的基础做修改
  说明：关于SmallDog
  添加两个set方法分别能够设置属性dogName和dogAge的值，
  在测试类中的main方法中调用这两个方法为属性设置值，
  再次访问这两个属性并打印看看和第二题的打印输出是否相同
  重写dogWalk()，打印一句话具体描述小狗走路的样子，
  在测试类main方法中调用dogWalk()，看看和第二题中的调用效果是否有变化
SmallDog类
private String dogName;
	private int dogAge;
	public String getDogName() {
		return dogName;
	}
	public void setDogName(String dogName) {
		this.dogName = dogName;
	}
	public int getDogAge() {
		return dogAge;
	}
	public void setDogAge(int dogAge) {
		this.dogAge = dogAge;
	}
	@Override
	public void dogWark() {
		System.out.println("小短腿跑起来");
	}
DogTest类
SmallDog sDog = new SmallDog();
		String dogName = sDog.getDogName();
		int dogAge = sDog.getDogAge();
		System.out.println(dogName +"->"+dogAge);
		sDog.dogWark();	
		
		sDog.setDogName("大黄");
		sDog.setDogAge(2);
		String dogName2 = sDog.getDogName();
		int dogAge2 = sDog.getDogAge();
		System.out.println(dogName2 +"->"+dogAge2);
		sDog.dogWark();
输出结果

5.定义一个运输类(Transport)和它的两个子类；
汽车类(Vehicle)和飞机类(Airplane)
  说明一：关于Transport
  两个属性，速度(speed,int)载重量(load,float)
  两个get方法，能够取得两个属性的值
  一个构造方法，能够初始化这两个属性
  一个show()方法，调用俩个get方法，取得两个属性的值并打印

  说明二：关于Vehicle(交通工具)
  继承Transport
  添加两个属性，车轮数(wheels,int)，车重量(weight,float)
  添加两个get方法，能够取得两个新添加属性的值
  一个构造方法，调用父类的构造方法，并且能够初始化新添加的两个属性
  一个show()方法，
  调用父类的show()方法打印speed和load两个属性，
  调用新添加的两个get方法取得wheels和weight属性的值并打印

  说明三：关于Airplane
  和说明二的要求一致，只要求新添加的两个属性
  为发动机类型(enginertype,String)发动机数量(enginers,int)
  最后，在测试类main方法中生成汽车类和飞机类的对象
Transport类
//运输类
	private int speed;//速度
	private float load;//载重量
	public int getSpeed() {
		return speed;
	}
	public float getLoad() {
		return load;
	}
	public Transport(int speed, float load) {
		super();
		this.speed = speed;
		this.load = load;
	}
	public void show() {
		System.out.println("速度="+this.getSpeed()+",载重量="+this.getLoad());
	}
Vehicle类
private int wheels;//轮子
	private float weight;//车重量
	
	public Vehicle(int speed, float load, int wheels, float weight) {
		super(speed, load);
		this.wheels = wheels;
		this.weight = weight;
	}

	public int getWheels() {
		return wheels;
	}

	public float getWeight() {
		return weight;
	}
	
	@Override
	public void show() {
		super.show();
		System.out.println("轮子="+this.getWheels()+",车重量="+this.getWeight());
	}
Airplane类
private String enginertype;//发动机类型
	private int enginers;//发动机数量
	public Airplane(int speed, float load, String enginertype, int enginers) {
		super(speed, load);
		this.enginertype = enginertype;
		this.enginers = enginers;
	}
	public String getEnginertype() {
		return enginertype;
	}
	public int getEnginers() {
		return enginers;
	}
	@Override
		public void show() {
			super.show();
			System.out.println("发动机类型="+this.getEnginertype()+",发动机数量="+this.getEnginers());
		}
Main类
Vehicle vehicle = new Vehicle(100, 500, 4, 1000);
		vehicle.show();
		Airplane airplane = new Airplane(1000, 1000, "华为制造", 8);
		airplane.show();
输出结果