public class StringDemo01 {
	public static void main(String[] args) {
		//public String()：创建一个空白字符串对象，不含有任何内容
		String s1 = new String();
		System.out.println("s1:" + s1);
		
		//public String(char[] chs)：根据字符数组的内容，来创建字符串对象
		char[] chs = {'a', 'b', 'c'};
		String s2 = new String(chs);
		System.out.println("s2:" + s2);
		
		//public String(byte[] bys)：根据字节数组的内容，来创建字符串对象
		byte[] bys = {97, 98, 99};	//97,98,99对应分别为a,b,c
		String s3 = new String(bys);
		System.out.println("s3:" + s3);
		
		//String s = “abc”; 直接赋值的方式创建字符串对象，内容就是abc
		String s4 = "abc";
		System.out.println("s4:" + s4);
	}
}

/*
运行结果：
s1:
s2:abc
s3:abc
s4:abc
*/

//通用格式
public class StringTest02 {
	public static void main(String[] args) {
		//键盘录入一个字符串，用 Scanner 实现
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入一个字符串：");
		String line = sc.nextLine();
		
		for(int i=0; i<line.length(); i++) {
			System.out.println(line.charAt(i));
		}
	}
}

/*
	思路：
		1:定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
		2:定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回。
返回值类型 String，参数列表 int[] arr
		3:在方法中遍历数组，按照要求进行拼接
		4:调用方法，用一个变量接收结果
		5:输出结果
*/
public class StringTest04 {
	public static void main(String[] args) {
		//定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
		int[] arr = {1, 2, 3};
		
		//调用方法，用一个变量接收结果
		String s = arrayToString(arr);
		
		//输出结果
		System.out.println("s:" + s);
	}
	//定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回
	/*
		两个明确：
		返回值类型：String
		参数：int[] arr
	*/
	public static String arrayToString(int[] arr) {
		//在方法中遍历数组，按照要求进行拼接
		String s = "";
		
		s += "[";
		
		for(int i=0; i<arr.length; i++) {
			if(i==arr.length-1) {
				s += arr[i];
			} else {
				s += arr[i];
				s += ", ";
			}
		}
		s += "]";
		return s;
	}
}

/*
	思路：
		1:定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
		2:定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回。
返回值类型 String，参数列表 int[] arr
		3:在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
		4:调用方法，用一个变量接收结果
		5:输出结果
*/
public class StringBuilderTest01 {
	public static void main(String[] args) {
		//定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
		int[] arr = {1, 2, 3};
		
		//调用方法，用一个变量接收结果
		String s = arrayToString(arr);
		
		//输出结果
		System.out.println("s:" + s);
	}
//定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回
/*
两个明确：
返回值类型：String
参数：int[] arr
*/

	public static String arrayToString(int[] arr) {
	//在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
	StringBuilder sb = new StringBuilder();
	
	sb.append("[");
	
	for(int i=0; i<arr.length; i++) {
		if(i == arr.length-1) {
			sb.append(arr[i]);
		} else {
			sb.append(arr[i]).append(", ");
		}
	}
	
	sb.append("]");
	
	String s = sb.toString();
	
	return s;
	}
}

/*
	思路：
		1:键盘录入一个字符串，用 Scanner 实现
		2:定义一个方法，实现字符串反转。返回值类型 String，参数 String s
		3:在方法中用StringBuilder实现字符串的反转，并把结果转成String返回
		4:调用方法，用一个变量接收结果
		5:输出结果
*/
public class StringBuilderTest02 {
	public static void main(String[] args) {
		//键盘录入一个字符串，用 Scanner 实现
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个字符串：");
		String line = sc.nextLine();
		
		//调用方法，用一个变量接收结果
		String s = myReverse(line);
		
		//输出结果
		System.out.println("s:" + s);
}
	//定义一个方法，实现字符串反转。返回值类型 String，参数 String s
	/*
		两个明确：
			返回值类型：String
			参数：String s
	*/
	public static String myReverse(String s) {
	//在方法中用StringBuilder实现字符串的反转，并把结果转成String返回
	//String --- StringBuilder --- reverse() --- String
	// StringBuilder sb = new StringBuilder(s);
	// sb.reverse();
	// String ss = sb.toString();
	// return ss;
	return new StringBuilder(s).reverse().toString();
	}
}

public class ArrayListDemo02 {
	public static void main(String[] args) {
	//创建集合
	ArrayList<String> array = new ArrayList<String>();
	
	//添加元素
	array.add("hello");
	array.add("world");
	array.add("java");
	
	//public boolean remove(Object o)：删除指定的元素，返回删除是否成功
	// System.out.println(array.remove("world"));
	// System.out.println(array.remove("javaee"));
	
	//public E remove(int index)：删除指定索引处的元素，返回被删除的元素
	// System.out.println(array.remove(1));
	
	//IndexOutOfBoundsException（索引越界）
	// System.out.println(array.remove(3));
	
	//public E set(int index,E element)：修改指定索引处的元素，返回被修改的元素
	// System.out.println(array.set(1,"javaee"));
	
	//IndexOutOfBoundsException（索引越界）
	// System.out.println(array.set(3,"javaee"));
	
	//public E get(int index)：返回指定索引处的元素
	// System.out.println(array.get(0));
	// System.out.println(array.get(1));
	// System.out.println(array.get(2));
	//System.out.println(array.get(3)); //？？？？？？ 自己测试
	
	//public int size()：返回集合中的元素的个数
	System.out.println(array.size());
	
	//输出集合
	System.out.println("array:" + array);
	}
}

/*
	思路：
		1:定义学生类
		2:创建集合对象
		3:创建学生对象
		4:添加学生对象到集合中
		5:遍历集合，采用通用遍历格式实现
*/

public class ArrayListTest02 {
	public static void main(String[] args) {
		//创建集合对象
		ArrayList<Student> array = new ArrayList<>();
		
		//创建学生对象
		Student s1 = new Student("林青霞", 30);
		Student s2 = new Student("风清扬", 33);
		Student s3 = new Student("张曼玉", 18);
		
		//添加学生对象到集合中
		array.add(s1);
		array.add(s2);
		array.add(s3);
		
		//遍历集合，采用通用遍历格式实现
		for (int i = 0; i < array.size(); i++) {
		Student s = array.get(i);
		System.out.println(s.getName() + "," + s.getAge());
		}
	}
}

/*
	思路：
		1:定义学生类，为了键盘录入数据方便，把学生类中的成员变量都定义为String类型
		2:创建集合对象
		3:键盘录入学生对象所需要的数据
		4:创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
		5:往集合中添加学生对象
		6:遍历集合，采用通用遍历格式实现
*/

public class ArrayListTest {
	public static void main(String[] args) {
	//创建集合对象
	ArrayList<Student> array = new ArrayList<Student>();
	
	//为了提高代码的复用性，我们用方法来改进程序
	addStudent(array);
	addStudent(array);
	addStudent(array);
	
	//遍历集合，采用通用遍历格式实现
	for (int i = 0; i < array.size(); i++) {
		Student s = array.get(i);
		System.out.println(s.getName() + "," + s.getAge());
	}
}
/*
	两个明确：
		返回值类型：void
		参数：ArrayList<Student> array
*/
	public static void addStudent(ArrayList<Student> array) {
		//键盘录入学生对象所需要的数据
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入学生姓名:");
		String name = sc.nextLine();
		
		System.out.println("请输入学生年龄:");
		String age = sc.nextLine();
		
		//创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
		Student s = new Student();
		s.setName(name);
		s.setAge(age);
		
		//往集合中添加学生对象
		array.add(s);
	}
}

public class Fu {
	private void show() {
		System.out.println("Fu中show()方法被调用");
	}
	
	void method() {
		System.out.println("Fu中method()方法被调用");
	}
}

public class Zi extends Fu {

	/* 编译【出错】，子类不能重写父类私有的方法*/
	@Override
	private void show() {
		System.out.println("Zi中show()方法被调用");
	}
	
	/* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */
	@Override
	private void method() {
		System.out.println("Zi中method()方法被调用");
	}
	/* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */
	@Override
	public void method() {
		System.out.println("Zi中method()方法被调用");
	}
}