首页 > 代码库 > 第三、四天笔记总结

第三、四天笔记总结

一: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);


第三、四天笔记总结