第四天笔记总结

Posted 2020-09-08

一：java中方法的介绍
	1.1 函数：Java就是方法。

	方法：
		就是完成特定功能的代码块

	格式：
		修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {
			方法体;
			return 返回值;
		}

	解释：
		修饰符：目前就写
			public static
		
		返回值类型：
			用于限定返回值的数据类型

		方法名：
			方便我们调用方法

		参数类型：
			形式参数	就是接收实际参数的变量(定义时候的)
			实际参数	就是实际参与运算的变量(调用时候的)

		方法体：
			就是完成功能的代码。

		返回值：
			就是功能的返回结果。

		return 返回值：
			结束方法，把返回值带给调用者


	1.2 有明确返回值的方法调用（画图讲解方法的调用流程，写一个加法运算演示各种调用区别）：
		A:单独调用
			没有意义
		B:输出调用
			不是特别好,因为我们可能需要对结果进行进一步的操作。
		C:赋值调用
			推荐方案
			
	1.3 书写方法注意的事项：
	做到两个明确：
		返回值
			结果的数据类型
		参数
			参数的个数，以及类型

	1.4 需求：
		求两个数据和的功能。

		如果数据我没有说类型，默认int类型。

		返回值:
			int
		参数:
			int a,int b	
		
	1.5 方法的注意事项（依然用定义的加法的方法进行演示）：
		A:方法不调用不执行
		B:方法与方法是平级关系，不能嵌套定义
		C:方法定义的时候参数之间用逗号隔开
		D:方法调用的时候不用在传递数据类型
		E:如果方法有明确的返回值，一定要有return带回一个值			
			
	1.6 需求：写一个功能实现返回两个数的较大值。
		  要求，数据来自于键盘录入。
		
		做到两个明确：
		返回值
			结果的数据类型
		参数
			参数的个数，以及类型

	1.7 练习：
		写一个功能实现比较两个数据是否相等。
		要求，数据来自于键盘录入。			
		
		做到两个明确：
		返回值
			结果的数据类型
		参数
			参数的个数，以及类型
			
		
	1.8 需求1：请在控制台输出4行5列的星形。
		需求2：请在控制台输出6行7列的星形。
		需求3：请在控制台输出8行9列的星形。	
		（最终封装成方法进行调用）
	
	1.9 作业：需求：键盘录入三个数据，返回三个数中的最大值（写成一个方法可以直接调用并且返回值）		
			
			
二：方法重载
	2.1 需求1：求两个数据和
		需求2：求三个数据和
		需求3：求四个数据和

		我们曾说：
			见名知意。

		方法重载：
			在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

		方法重载特点
			与返回值类型无关，只看方法名和参数列表
			在调用时，虚拟机通过参数列表的不同来区分同名方法			
			
	2.2 需求：
		比较两个数据是否相等。参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，
		并在main方法中进行测试		
			
三：数组(容器，用来存储相同类型数据的容器)			
	3.1 		
	数组：数组是存储同一种数据类型多个元素的集合
	注意：数组既可以存储基本数据类型，也可以存储引用数据类型
	3.2
	数组的定义格式
		A:数据类型[] 数组名;
			int[] arr;
		B:数据类型 数组名[];
			int arr[];

		区别：念法上区别
			int[] arr;
				int类型的数组，arr
			int arr[];
				int类型的，arr[]
	3.3
	数组初始化概述:
		A:Java中的数组必须先初始化,然后才能使用。
		B:所谓初始化
			就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
	3.4
	如何为数组进行初始化呢?
		A:动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
		B:静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
	3.5
	动态初始化：
		初始化时只指定数组长度，由系统为数组分配初始值。

		格式：
			数据类型[] 数组名 = new 数据类型[数组长度];

			数组长度其实就是数组中元素的个数。
	3.6
	为了方便我们获取数组中的元素，数组就为每个元素进行了编号，从0开始。
	这个编号，专业叫法：索引。(角标,下标)
	有了索引如何获取元素呢?	
		格式：数组名[索引]			
			
	3.7
	演示一个int[] arr = new int[3];左边右边分别代表什么？
			
	3.8（如果不赋值的输出，赋值后的输出，画内存图进行演示）
	需求：定义一个数组，输出数组名及元素。然后给数组中的元素赋值，再次输出数组名及元素。	
	
	3.9（简单画内存图）
	定义两个数组，分别输出数组名及元素。然后分别给数组中的元素赋值，分别再次输出数组名及元素。	
			
	3.10
	定义两个数组，先定义一个数组，赋值，输出。
	然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。
	然后给第二个数组赋值，再次输出两个数组的名及元素。

	3.11
	静态初始化：
		初始化时指定每个数组元素的初始值，由系统决定数组长度。

		格式：
			数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};

		简化格式：
			数据类型[] 数组名 = {元素1,元素2,…};
			
	3.12（写一个案例进行演示）
	数组操作常见的两个小问题
		A:
			ArrayIndexOutOfBoundsException:数组索引越界异常
			怎么产生的：
				你访问了不存在的索引。
			如何解决：
				修改你的访问索引。
		B:
			NullPointerException:空指针异常
			怎么产生的：
				引用已经不再指向堆内存
			如何解决：
				一般来说，只要是引用类型的变量，我们在使用前，都要先判断是否为null。
				如果不为null，才继续使用。
	
	3.13		
	数组遍历:
		依次输出数组中的每一个元素

	数组遍历标准格式：
		for(int x=0; x<数组名.length; x++) {
			System.out.println(数组名[x]);
		}

	练习：
		自己定义一个数组，并遍历。			
			
			
	3.14
	我们可能有很多个数组需要遍历，所以我们把遍历写成一个功能。	
			
	3.15
	数组获取最值(获取数组中的最大值最小值)	
			
		
	***
	作业：数组元素查找(查找指定元素第一次在数组中出现的索引)，封装成方法实现		
	
			
四：面向对象思想（新开的txt文档进行讲解）

五：类与对象
		5.1:我们学习编程语言，就是为了模拟现实世界的事物，实现信息化。

		5.2:我们是如何描述现实世界的事物的呢?
			属性	就是该事物的描述信息（举例，人，汽车）
			行为	就是该事物能够做什么（举例，人，汽车）
			
		人：（类）
			属性：姓名，性别，年龄
			行为：吃，睡，学习
			
		张三：（人这个类对应的实例，也叫对象）
		
			
		汽车：
			属性：颜色，品牌，价格
			行为：拉人，拉货，跑滴滴
			
		奇瑞qq:（是汽车类的一个实例，或者叫对象）
			

		5.3:我们学习的Java语言最基本单位是类，所以，我们就应该把事物用一个类来体现。

		5.4:类与对象
			类：是一组相关的属性和行为的抽象
			对象：是该类事物的具体体现。(实例)

			举例：
				对象：张三
				类：学生
			
六：类的定义
		6.1
		类是用来描述现实世界事物的。
			
			事物：
				属性	特征
				行为	功能

			类：
				成员变量	特征
				成员方法	功能
			
			类的组成：
				成员变量	类中方法外的变量
				成员方法	没有static修饰的方法

			需求：
				用Java语言体现学生类。

			分析：
				A:得到学生事物
				B:把学生事物转换为学生类
				C:用代码体现学生类

			实现：
				A:得到学生事物
					属性：
					行为：
				B:把学生事物转换为学生类
					成员变量：
					成员方法：
				C:用代码体现学生类
					学生类：
						
					成员变量：
						
					成员方法：
						
		6.2
		练习：
			模仿学生类，写出手机类。
			1.得到手机类事物
			属性：
			行为：
			2.事物转换成手机类
			成员变量：
			成员方法：
			3.用java代码实现
			类：
			
			成员变量：
			
			成员方法：
			
七：
类的使用+内存图解（重要：new关键字的含义）
	7.1 一个文件一个类
		类的使用（拿学生类过来练习，并画内存图进行讲解）
		使用一个类，其实是使用该类的成员。(变量和方法)

		我们要想想用一个类的成员，就必须创建该类的对象。
		如何创建类的对象呢?
			格式：
				类名 对象名 = new 类名();

				就表示创建了该类类型的一个对象。

		如何使用成员呢?
			成员变量：
				对象名.变量;
			成员方法：
				对象名.方法名(...);

	7.2 练习：
		写出手机类的测试类

	7.3 一个文件多个类进行练习演示


八：成员变量和局部变量的区别？
		A:在类中的位置不同
			成员变量	类中方法外
			局部变量	方法内或者方法声明上
		B:在内存中的位置不同
			成员变量	堆内存
			局部变量	栈内存		
		C:生命周期不同
			成员变量	随着对象的存在而存在，随着对象的消失而消失
			局部变量	随着方法的调用而存在，随着方法的调用完毕而消失
		D:初始化值
			成员变量	有默认初始化值
			局部变量	没有默认初始化值
			
九：形式参数问题
	数据类型：
		基本类型：4类8种。byte,short,int,long,float,double,char,boolean
		基本类型实际参数传递的时候传递的是这个基本类型的具体的值
		引用类型：类,接口,数组
		引用类型进行参数传递的时候，传递的是该引用类型的（实例对象）说白了就是这个对象的地址值

	基本类型形式参数案例：
	1.创建一个类，里面写一个加法运算，在测试类中new对象，调方法进行使用
	
	形式参数案例：
	1.写一个类，类中有一个方法遍历数组，接收的参数为一个数组对象
	2.写一个学生类Student（里面有一个学习方法），创建一个StudenDemo这个类里面有个方法（method(Student s)），还有一个测试类进行测试
	
	
十：匿名对象（学生案例代码进行演示）
	匿名对象：就是没有名字的对象
		是对象一种简写形式。

	应用场景：
		A:调用方法(对象调用方法仅仅一次的时候)
		B:作为实际参数传递

第四天：


一：
	1.1
	封装：（案例演示，创建学生类年龄可以随意被设置成不符合要求的参数）
		是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

	好处：
		A:提高了代码的复用性
		B:提高安全性。

	体现：
		将不需要对外提供的内容都隐藏起来。
		做法：
			把属性隐藏，提供公共方法对其访问。


	现在我们可以给age赋值，但是赋予负数值居然也通过了。这是不满足实际需求的。
	我们应该对不满足需求的数据给与判断。
	而判断不能直接针对成员变量做，因为要判断，就必须写在方法中。
	所以，我们应该用一个方法给年龄赋值并判断。

	虽然我们已经通过一个方法做出了数据不正常的判断，但是我们还是可以通过对象直接访问成员变量。
	那么，为了让使用者使用方法来给成员变量赋值，就不能允许它们直接去访问成员变量。
	怎么办呢?
		为了解决这种情况，java就提供了一个修饰符关键字：private

	private：
		私有的意思。

		可以修饰成员变量和成员方法。

		特点：
			被private修饰的内容，只能在本类中访问。
			
	1.2
	封装加入private后的标准代码：
	A:把成员变量private修饰
	B:针对每一个成员变量给出
		getXxx()和setXxx()（注意首字母大写）
		注意：这里的xxx其实是成员变量名称。
			
二：this关键字详解（演示修改局部变量的变量名和成员变量相同的话的效果）
	常说：
		见名知意。

	局部变量如果有一个变量和成员变量名称一致，那么优先使用的是局部变量。
	就近原则。

	这样的话，就造成了局部变量隐藏了成员变量。
	如何解决呢?
		为了解决这种情况，java就提供了一个代表本类对象的关键字：this
		
三：构造方法
	3.1
	构造方法：
		作用：给对象的数据进行初始化
		格式特点：
			A:方法名和类名相同。
				public void Student() {}
			B:没有返回值类型。
				修饰符 返回值类型 方法名(...) {...}
			C:没有返回值。
				没有用return带明确的值回来。
				return;
	
	3.2
	构造方法注意事项
		A:如果你不提供构造方法，系统会给出默认无参构造方法
		B:如果你提供了构造方法，系统将不再提供默认无参构造方法
			这个时候怎么办呢?
				a:使用自己给的带参构造。
				b:要么自己再提供一个无参构造

				建议：建议永远自己给出无参构造方法。
		C:构造方法也是可以重载的。
	
	3.3
	给成员变量赋值：
		A:通过setXxx()方法
		B:通过带参构造方法			
			
			
四：
	成员方法：
		去掉static的方法。

	根据返回值类型：
		void类型
		非void类型

	根据参数列表：
		无参
		带参			
			
			
五：
标准代码的写法：
练习：
	手机类：
		成员变量：
			brand,price,color
		构造方法：
			无参，带参
		成员方法：
			getXxx()/setXxx()
			show(),call()		
			
练习：		
	学生类：
		成员变量：
			name,age,address
		构造方法：无参，带参
			
		成员方法：getXxx()/setXxx()
				  show(),study()			
			
			
六：
6.1 测试标准手机代码（两种创建对象方式，分别进行演示） 			
6.2 测试标准学生代码（两种创建对象方式，分别进行演示）

七：
面向对象练习：
7.1 定义一个类MyMath,提供基本的加减乘除功能，然后进行测试。
add(int a,int b)
sub(int a,int b)			
mul(int a,int b)			
div(int a,int b)			

7.2
定义一个长方形类,定义求周长和面积的方法，然后定义一个测试了Test2，进行测试。
周长：2*(长+宽)
面积：长*宽

变量的定义：
	范围越小越好。
	但是，如果这个变量和类有描述关系，就应该定义为成员变量。
			

八：
static关键字
8.1
为了体现共用的数据，java就提供了一个关键字：static。
static:
	作用：可以修饰成员变量和成员方法

	特点：
		A:随着类的加载而加载
		B:优先于对象存在
		C:被类的所有对象共享
			也是我们判断该不该使用静态修饰一个数据的依据。
			举例：
				饮水机：static
				水杯：特有的内容。
		D:可以通过类名调用
			静态变量：类变量
			非静态变量：实例变量，对象变量

			非静态的：创建对象访问
			静态的：可以通过类名，也可以通过对象访问。
	
			
8.2（写一个静态成员变量和静态成员方法进行演示）
	static关键字注意事项
		A:在静态方法中是没有this关键字的
			原因：静态的内容随着类的加载而加载，this是随着对象的创建而存在，所以，static中不能有this。
		B:静态方法只能访问静态的成员变量和静态的成员方法
			静态方法只能访问静态的成员。			
			
			
九：
API帮助文档使用简单讲解+java中的常用的一些包的讲解

十：
  String类讲解   char[] chs = {‘a‘,‘b‘,‘c‘};
	(1) 是由多个字符组成的一串数据。(字符序列)
		其实字符串可以看成是一个字符数组。
	
	(2)构造方法：
  		public String():无参构造方法
 		public String(byte[] bytes):把字节数组转换为字符串
 		public String(char[] value):把字符数组转换为字符串
 		public String(char[] value,int offset,int count):把字符数组的一部分转换为字符串
 		public String(String original):把一个字符串转换为字符串
 
	（需要利用到的一个成员方法）成员方法：
  		public int length()：返回此字符串的长度
	
	(3)String的特点及面试题
		A：
		String类的数据特点：
  		字符串是常量；它们的值在创建之后不能更改
		面试题：根据以上结论请问输出的s的值是多少
		String s = "hello";
		s += "world";
		System.out.println(s); 
		
  		结论：
		字符串的内容不能发生改变，但是字符串引用的指向是可以改变的。
		
		B:String s = new String("hello")和String s = "hello"的区别（画图讲解）
			前者创建了1个或者2个对象
			后缀创建了0个或者1个对象
		C:面试题(看程序写结果)
			A:new和直接赋值的区别
				String s1 = new String("hello");
				String s2 = new String("hello");
				System.out.println(s1==s2);
				System.out.println(s1.equals(s2));

				String s3 = new String("hello");
				String s4 = "hello";
				System.out.println(s3==s4);
				System.out.println(s3.equals(s4));

				String s5 = "hello";
				String s6 = "hello";
				System.out.println(s5==s6);
				System.out.println(s5.equals(s6));
				
		D：面试题：
		String s1 = "hello";
		String s2 = "world";
		String s3 = "helloworld";
		System.out.println(s3 == s1 + s2); 
		System.out.println(s3.equals(s1 + s2)); 

		System.out.println(s3 == "hello" + "world"); 
		System.out.println(s3.equals("hello" + "world")); 
		
		结论：
		看程序写结果
		变量相加，先开空间，在加。
 		常量相加，先加，找是否有这样的数据空间，如果没有才开空间。
	
	(4)String类的成员方法
		A:判断功能
		  boolean equals(Object obj):比较两个字符串的内容是否相同,严格区分大小写。(用户名,密码)
		  boolean equalsIgnoreCase(String str):比较两个字符串的内容是否相同,忽略大小写。(验证码)
		  boolean contains(String str):判断字符串中是否包含一个子串。
		  boolean startsWith(String str):判断是否以指定的字符串开头
		  boolean endsWith(String str):判断是否以指定的字符串结尾
		  boolean isEmpty():判断字符串的内容是否为空
		  问题：内容为空和对象为空是一个意思吗?
		  答：不是
		
		B:获取功能
		  String类的获取功能：
		  int length():返回字符串的长度。其实就是字符的个数。
		  char charAt(int index):返回字符串中指定索引处的字符。
		  int indexOf(int ch):返回指定的字符在字符串中第一次出现的索引。
				明明说的是字符，为什么是int呢?
				原因是int类型还可以接收char类型。
				97,‘a‘是一样的效果。
				但是如果参数是char类型，你就不能写97了。
		  int indexOf(String str):返回指定的字符串在字符串中第一次出现的索引。
		  String substring(int start):截取从start开始到末尾的字符串。
		  String substring(int start,int end):截取从start开始到end结束的字符串。
		
		C:转换功能
		  byte[] getBytes():把字符串转换为字节数组
		  char[] toCharArray():把字符串转换为字符数组
		  static String valueOf(char[] chs):把字符数组转换为字符串
		  static String valueOf(int i):把int类型的数据转换为字符串
				valueOf():可以把任意类型的数据转换为字符串。
		  String toLowerCase():把字符串转成小写
		  String toUpperCase():把字符串转成大写
		  String concat(String str):拼接字符串,前面我们使用过+进行字符串的拼接，不够专业。
		
		
		D:其他功能
		  A:替换功能
				String replace(char old,char new)
				String replace(String old,String new)
		  B:去除字符串两端空格	
				String trim()
 十一：
StringBuffer和StringBuilder
11.1
 * StringBuffer:
 * 线程安全的可变字符序列。
 * 
 * String和StringBuffer的区别?
 * A:String的内容不可变
 * B:StringBuffer的内容可变
 * 
 * StringBuffer和StringBuilder的区别?
 * A:StringBuffer 线程安全，效率低
 * B:StringBuilder 线程不安全，效率高
 * 
 * 线程安全：(同步)，效率低
 * 线程不安全：(不同步)，效率高
 * 
 * 构造方法：
 * 		StringBuffer():构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。
 * 		StringBuffer(int capacity):构造一个其中不带字符的字符串缓冲区，其初始容量为 capacity个字符。
 * 		StringBuffer(String str):构造一个其中带字符的字符串缓冲区，其初始容量为??? 个字符。
 * 
 * 成员方法：
 * 		public int length():返回长度（字符数）。实际值
 * 		public int capacity():返回当前容量。 理论值 
 * 添加功能：添加元素，并返回本身的对象。
 * 		A:public StringBuffer append(String str):追加数据,在末尾添加
 * 		B:public StringBuffer insert(int offset,String str):插入数据,在指定位置添加	
 * 删除功能：
 * 		public StringBuffer deleteCharAt(int index):删除指定索引处的字符
 *		public StringBuffer delete(int start,int end):删除从start开始到end结束的数据，包左不包右
 * 替换功能：
 * 		public StringBuffer replace(int start,int end,String str):用str替换从start到end的数据
 * 
 * 反转功能：
 * 		public StringBuffer reverse()
 * 截取功能:返回值类型是String类型，本身没有发生改变
 *		public String substring(int start)
 *		public String substring(int start,int end) 
 * 相互转换：
 * 
 * String 	--	StringBuffer
 * 		String s = "hello";
		// 方式1
		StringBuffer sb1 = new StringBuffer(s);
		// 方式2
		StringBuffer sb2 = new StringBuffer();
		sb2.append(s);
 * 
 * StringBuffer  --  String
 * 		StringBuffer sb = new StringBuffer("world");
		//方式1
		String s1 = sb.substring(0);
		//方式2
		String s2 = sb.toString();
		//方式3
		String s3 = new String(sb);