(Java)记录我的Java学习过程

java学习第二周

分享我的学习过程,总结一周所学
老师讲课的内容部分引用@刘洋

周一

方法

方法就是一段具有特定功能的代码,可以通过方法名重复使用

方法的定义

方法的声明+方法的实现

语法:
修饰符  返回值类型 方法名(形式参数列表){
方法的具体实现代码;
}

方法定义在类中

方法的三要素

返回值类型, 方法名, 形参列表

返回值类型: 就是一个数据类型(基本数据类型&&引用数据类型),当没有返回值的时候 类型定义为void, 表示该方法可以为方法的调用者提供什么类型的数据.
形式参数列表: 说明了这个方法在调用的时候,需要方法的调用者提供什么类型的数据

方法的调用和参数

方法不调用就不会执行

调用语法:
无参方法的调用: 方法名(); 
有参方法的调用: 方法名(实际参数1,实际参数2 ....);

方法的参数:
实际参数: 在方法调用时候,真正传入的实际的数据
形式参数: 声明在方法的形式参数列表中,表示此方法需要什么类型的数据( 数据的类型 数据的个数数据的顺序)

方法调用的本质: 就是将实际参数的值赋值给形式参数

注意事项: 在方法调用的过程中,要求方法安的实际参数和形式参数的(个数 类型 顺序 )必须一一对应

案例1:定义一个方法,功能是计算两个整数类型数据的和,将结果打印输出
public class Test {
	public static void main(String[] args) {
		//这个sum和result方法中的sum不是一个sum
		int sum = result(5, 6);
		System.out.println(sum);
	}

	//定义一个result方法,传入连个int型参数,返回值是int型
	public static int result(int a, int b) {
		//定义一个局部变量 sum 用于存储a+b
		int sum = a + b;
		//返回sum
		return sum;
	}
}

public class Demo1 {
案例二:输出三个数中的最大值
	//方法练习
	public static void main(String[] args) {
		//输出三个数中的最大值(调用方法getMax()方法)
		System.out.println(getMax(6, 6, 6));
		System.out.println(getMax(2, 4, 6));
	}

	//求三个数中的最大值           传入三个形参
	public static int getMax(int a, int b, int c) {
		int max = (a > b) ? a : b;//三元表达式
		max = (max > c) ? max : c;
		return max;//返回值是max
	}
}

方法练习题：科学计算器，四个功能
1. 计算两个整数和 2. 计算两个小数的和 3. 计算n的阶乘 4. 计算a的n次方     用完某一功能后返回功能选择界面
package baoming;

import java.util.Scanner;

public class Practice1 {
	public static void main(String[] args) {
		// 练习题：科学计算器，四个功能
		// 1. 计算两个整数和 2. 计算两个小数的和 3. 计算n的阶乘 4. 计算a的n次方
		// 用完某一功能后返回功能选择界面

		for (; true;) {// 循环

			Scanner scanner = new Scanner(System.in);
			System.out.println("按下enter键开始");
			scanner.hasNextLine();// 接收enter键，显示菜单
			//菜单
			System.out.println("请选择功能");
			System.out.println("1. 计算两个整数和");
			System.out.println("2. 计算两个小数的和");
			System.out.println("3. 计算n的阶乘");
			System.out.println("4. 计算a的n次方");
			System.out.println("5. exit");

			int i = scanner.nextInt();// 输入数字
			xuanZe(i);// 调用xuanZe()方法,进入功能

			if (i == 5)
				return;// 退出程序
		}
	}

	// 计算两个整数和         无参方法
	public static void gongNeng1() {
		//接收数据
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入数字一");
		int input1 = scanner.nextInt();
		System.out.println("请输入数字二");
		int input2 = scanner.nextInt();
		
		int sum = input1 + input2;

		System.out.println(sum);

		return;
	}

	// 计算两个小数的和           无参方法
	public static void gongNeng2() {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入数字一");
		double input1 = scanner.nextDouble();
		System.out.println("请输入数字二");
		double input2 = scanner.nextDouble();

		double sum = input1 + input2;

		System.out.println(sum);

		return;
	}

	// 计算n的阶乘                         无参方法
	public static void gongNeng3() {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入数字n，即将计算n!");
		int n = scanner.nextInt();

		int result = 1;

		for (int i = 1; i <= n; i++) {
			result *= i;
		}

		System.out.println(result);

		return;
	}

	// 计算a的n次方   无参方法
	public static void gongNeng4() {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入底数");
		int a = scanner.nextInt();
		System.out.println("请输入次幂");
		int n = scanner.nextInt();

		int result = 1;
		
		for (int i = 1; i <= n; i++) {
			result *= a;
		}
		
		System.out.println(result);
		
		return;
	}

	// 功能选择   有参方法
	public static void xuanZe(int i) {
		
		switch (i) {
		case 1:
			gongNeng1();
			return;
		case 2:
			gongNeng2();
			return;
		case 3:
			gongNeng3();
			return;
		case 4:
			gongNeng4();
			return;
		default:
			return;
		}
	}
}

数组

数组: 就是内存中一块 连续的 内存空间,可以存储多个 类型相同 的数据 ,就是一个数据存储的容器.

数组的定义

1. 数组的声明: 意义在于 规定了数组的名字和数组中存放的数据是什么类型
2. 为数组分配空间 / 直接为数组元素进行赋值: 意义在于直接为数组开辟空间,进行赋值

语法:
数据类型[] 数组名 = new 数据类型[数组长度];
例:int[] a = new int[2];
或者声明的同时直接赋值
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3…};
例:int[] a = new int[]{2,5,6,8,9};
简化方式: 数据类型[] 数组名 = {元素1,元素2,元素3…};

数组的使用

// 数据的存储   
//定义一个数组  分配空间之后 再进行存储 
	int[] a = new int[3];
	a[0] = 100;
	a[1] = 200;
	a[2] = 300;

// 在定义的同时 并进行数据的存储 
	int[] b = {3,4,5,6,7};

//数据的访问
	System.out.println(a[0]);
	System.out.println(b[1]);

//数据的修改
	a[0] = 123;
	System.out.println(a[0]);

//获取数组的长度
System.out.println(a.length)

数组的遍历

依次访问数组中的元素

利用循环实现数组遍历:循环 + 数组.length + 下标
例:

	//定义一个数组并赋值
	int[] b = {3,4,5,6,7,435,234,5234,532,4523,5,234532};
	//打印数组的长度
	System.out.println("数组的长度为:"+b.length);
	//数组的遍历
	for (int i = 0; i < b.length; i++) {
		System.out.println(b[i]);
	}

数组元素的默认值

基本数据类型
整数类型(byte short int long ) 默认值: 0
小数类型(float double) 默认值: 0.0
字符类型(char) 默认值: 空字符 空格 ‘\u0000’
布尔类型(boolean) 默认值: false
引用数据类型
String 默认值: null

关于直接打印数组的引用结果的解释

//定义一个变量 简单数据类型变量 
// int b = 20; // 
	System.out.println(b);//结果20 
//定义一个数组 数组是一个引用数据类型 
	int[] a = {214,13,51,35,3145,6}; 
	System.out.println(a);//结果[I@15db9742 
	System.out.println(a.toString()); 
//getClass().getName() + "@" + Integer.toHexString(hashCode()); 				
	System.out.println(a.getClass().getName());
	System.out.println(a.hashCode());//哈希值 366712642 --> 10进制 
	System.out.println(Integer.toHexString(366712642));//15db9742 --> 16 进制的 
//[ ---> 表示a引用数据类型是一个数组类型 
//I --> 表示a是一个int数组 
//@ ---> 就是 @ 连接符 
//15db9742 ----> 数组的地址调用hashCode方法 ---> 哈希值(int) ---> 转换为16 进制后的结果

数组中常见的异常

数组下标越界异常

导致的原因: 下标范围超过了 0 — 数组名.length-1

空指针异常

	int[] a = { 1, 2, 3, 4, 5, 6 };
	a = null;//在内存中谁也不指向
	System.out.println(a[0]);

示例

1.数组的遍历 2.数组的最值3.数组的反转(倒序)

public class Demo2 {
	/*
	  数组的遍历 
	  数组的反转（倒序） 
	  数组的最值
	 */
	public static void main(String[] args) {//主方法
		//定义一个int[]型数组,元素随便放一些整数进去
		int[] arr = {51,1,53,32,321,512,12,135,11,5,-55};
		
		//将arr数组倒序，然后遍历打印出来
		//调用daYin()方法，传递参数daoXu（arr），参数调用daoXu()方法，传递arr参数
		daYin(daoXu(arr));//该语句执行完后，数组arr中的元素就顺序颠倒了
		System.out.println(getMax(arr));//打印输出arr数组中的最大值，调用getMax()方法
		System.out.println(getMin(arr));//打印输出arr数组中的最小值，调用getMax()方法
	}

	//获取int数组中的最大元素
	public static int getMax(int[] array) {
		int max = array[0];//int一个max变量，用于存储最大值，先将数组中第一个元素赋值给max
		for (int i = 0; i < array.length; i++) {//for循环
			max = (max > array[i]) ? max : array[i];//max挨个和数组中的元素作比较，较大的值赋值给max
		}
		return max;
	}

	//获取int数组中的最小元素
	public static int getMin(int[] array) {
		int min = array[0];int一个min变量，用于存储最小值，先将数组中第一个元素赋值给min
		for (int i = 0; i < array.length; i++) {
			min = (min < array[i]) ? min : array[i];
		}
		return min;
	}
	
	//该方法可以将数组元素倒序排列
	public static int[] daoXu(int[] array) {
		for (int i = 0; i < array.length/2; i++) {
			//第一个元素和最后一个元素交换顺序
			//第二个元素和倒数第二个元素交换顺序...
			//一直交换到中间两个元素互相交换，或者最中间一个元素的旁边两个元素互相交换
			int a = array[i];
			array[i] = array[array.length-i-1];
			array[array.length-i-1] = a;
		}
		return array;
	}
	
	//遍历数组，以，隔开每个元素，最后一个元素后面没有，
	public static void daYin(int[] arr) {
		//for循环依次访问数组元素
		for (int i = 0; i < arr.length-1; i++) {
			System.out.print(arr[i]+",");
		}
		System.out.println(arr[arr.length-1]);
	}
}

public class Demo3 {
	public static void main(String[] args) {
		//编程题：定义一个 char 类型的数组，并存储多个数据； 统计数组中小写字母的个数
		//先定义一个char类型数组，元素随便填
		char[] c = { 'a', 'b', 'c', 2, 96, 97, 98, 65 };
		int jiShuQi = 0;//计数器，存储小写字母的个数
		
		for (int i = 0; i < c.length; i++) {
			int zhuan = c[i];
			if (zhuan >= 97 && zhuan <= 123) {//97~123是小写字母
				jiShuQi++;//计数器+1
			}
		}
		System.out.println(jiShuQi);//打印输出计数器
	}
}

周二

jvm中内存划分

栈内存: 用于执行方法,每个方法运行的时候会分配一段内存空间,这段空间叫做一个栈帧把方法的运行加载过程叫做压栈,方法结束运行数据的销毁弹栈 栈内存数据存储的特点是:filo first in last out 先进后出.
堆内存: 用于存放数组 对象 等数据量比较大的数据, 引用数据类型存储在堆内存中.
方法区: 用于存储字节码对象(类对象) 存储常量 静态变量等
本地方法区: 用于执行本地方法 方法的实现不是用java实现的 可能是c c++实现的
程序计数器: 用于控制程序执行的区域, 作用控制执行哪行代码

数组的内存分析

基本数据类型: 传递的是值
引用数据类型: 传递的是地址值
数组是引用数据类型

练习题：打印的结果是？
public class Practice2 {
    public static void main(String[] args) {
   	int a =10;
   	a1(a);
   	System.out.println(a);
   		}
    public static void a1 (int a) {
   	 a++;
   	 System.out.println(a);
    }
}

打印的结果是？
public class Practice2{
   public static void main(String[] args) {
   	int[] a = {10,11};
   	a1(a);
   	System.out.println(a[0]);
   }
   public static void a1 (int[] a) {
   	a[0]++;
   	System.out.println(a[0]);
   }
}

打印的结果是？
public class Practice2 {
   public static void main(String[] args) {
   	int[] a = { 10, 11 };
   	a1(a);
   	System.out.println(a[0]);
   }

   public static void a1(int[] a) {
   	a[0]++;
   	a = new int[2];
   	System.out.println(a[0]);
   }
}
答案:
1.  11   10
2.  11   11
3.  0    11

面向对象

面向对象的思想

java中万物皆对象 现实生活中任何存在的事物都可以看成对象 大到宇宙 小到夸克 在java的世界中都 是对象

编程思想
	就是用编程语言解决实际问题的思路
		面向过程
			c语言等
				遇到问题需要自己一步步解决
		面向对象
			java等
				遇到问题，找到合适的对象帮忙解决
对象
	java中万物皆对象
	创建语法
		类名 对象名 = new 类名();
	存储在堆内存中

类与对象

类
	就是对一类事物共性特征的抽取 (抽象)
关系
	对象是类的实例 类是对象的模版
成员变量
	语法:
			数据类型 变量名; //没有初始值 
			数据类型 变量名 = 变量值; //有初始值
	定义位置
		类中方法外
	范围
		至少在本类
	存储位置
		成员变量是属于对象 ,所以存储在堆内存中的对象中
	在同一个类中,不可以定义两个同名的成员变量
	成员变量是有默认值的,默认值的类型和数组元素的默认值类型一样
成员方法
	语法:
			访问修饰符 返回值类型 方法名(形式参数列表){ 方法的实现; }
	成员方法的调用
		对象名.方法名(实际参数列表);

对象的创建

类名 对象名 = new 类名();
例:

//定义一个Dog类
public class Dog {
	//定义成员变量
	int age;
	String yanSe;
	String name;
	String sex;
	
	//定义成员方法
	public void jiao(int n){
		for (int i = 0; i < n; i++) {
			System.out.print("汪");
		}
	}
	
	public void chi() {
		System.out.println("吃了一顿饭");
	}
	
	public void shui() {
		System.out.println("睡了一觉");
	}
}


//创建一个Dog类的对象
public class XiaoGou {
	public static void main(String[] args) {
		//创建对象
		Dog xiaoGou = new Dog();
		//给对象的属性赋值
		xiaoGou.name = "黑皮";
		xiaoGou.sex = "公狗";
		xiaoGou.yanSe = "黑色";
		System.out.println(xiaoGou.yanSe+"的"+xiaoGou.name);
		//调用方法
		xiaoGou.chi();
		xiaoGou.jiao(3);
	}
}
注:两个public class , 两个public类 , 要在同一个包下创建两个class

局部变量和成员变量对比

周三

方法的重载

方法的重载: 在一个类中,存在多个名字相同的方法,但是它们之间的形式参数不同(个数 类型 顺序) 产生的现象

方法重载的要求

1. 方法名相同
2. 形式参数列表不同(个数 类型 顺序) —> 个数 类型 顺序 满足其中一种不同即可
3. 和访问修饰符 返回值类型没有关系

例:

//方法的重载
public class Test {
	public static void main(String[] args) {
		//创建对象
		DaYin daYin = new DaYin();
		//调用方法
		daYin.daYin();
		daYin.daYin(23);
		daYin.daYin("打印",232);
	}
}

//定义一个打印类
class DaYin{
	//定义三个方法
	public void daYin() {
		System.out.println("无参的daYIn方法");
	}
	
	public void daYin(int a) {
		System.out.println("一个参数的daYin方法");
		System.out.println("打印传入的参数:"+a);
	}
	
	public void daYin(String a,int b) {
		System.out.println("两个参数的daYin方法");
		System.out.println("打印传入的参数a:"+a+",打印传入的参数b:"+b);
	}
}

构造方法

概念: 就是一个特殊的方法,也称为构造器 构造函数

特点

1. 构造方法的方法名必须和类名一致(大小写都得一致)
2. 构造方法没有返回值类型,连void都没有
3. 构造方法可以重载
4. 构造方法不可以使用对象的引用去手动调用,只能在创建对象的时候,有jvm自动调用只调用一次.
5. 当定义一个类的时候,没有定义任何的构造方法 —> 系统自动的为这个类提供一个公开的无参的构造 方法
6. 当定义一个类的时候,定义了其他的构造方法 —> 系统就不再为这个类提供公开的无参的构造方法 了,如果需要使用无参的公开的构造方法必须手动补出来.

例:

public class Demo1 {
	public static void main(String[] args) {
		//创建对象
		Li li1 = new Li();
		System.out.println(li1.a);
		
		Li li2 = new Li(23);
		System.out.println(li2.a);
		
		Li li3 = new Li(33,232);
		System.out.println(li3.a);
	}
}

//构造方法示例
class Li{
	//定义成员变量
	int a;//不赋值,默认值是0
	int b;
	Li(){
		System.out.println("这是无参的构造方法");
	}
	Li(int a){
		System.out.println("这是一个参数的构造方法");
		//将传入的参数赋值给a
		this.a = a;
	}
	Li(int a,int b){
		System.out.println("这是两个参数的构造方法");
		//将传入的参数赋值给a,b
		this.a = a;
		this.b = b;
	}
}

匿名对象的使用

就是没有引用名字的对象
语法:

new 类名();//只有对象的实体

用法:

1. 当只需要调用一次方法的时候,可以使用匿名对象
2. 可以作为一个方法的实际参数
3. 可以作为方法的返回值

对象创建的过程

对象创建的过程

1. 当第一次使用这个类的时候,jvm会将硬盘中的字节码文件信息,加载到方法区中,形成字节码对象,这个过程叫做类加载
2. 在栈内存声明了一个引用
3. 在堆内存中开辟了一块空间
4. 为对象的属性赋默认值
5. 为对象的属性赋初始值
6. 调用构造方法创建对象,如果是有参构造,再次为属性进行赋值
7. 最后将堆内存中的地址赋值给栈内存的变量

类加载:在一个程序运行周期内只进行一次

this关键字

this:代表当前对象的引用,谁调用this,this指向谁
语法:
this. 属性 / this.方法名();
this(实际参数) : 在构造方法中去调用本类中其他的构造方法,实现代码简化的目的

封装

封装: 隐藏事物的属性和实现的细节,对外提供公开的访问方式

private 修饰符

私有的: 被private修饰的成员(成员变量和成员方法),只能在本类访问

封装的步骤

1. 对需要封装的属性进行私有化(用private修饰) 
2. 对私有的属性提供公开的get(获取)/set(设置) 方法
3. 根据项目的需要,可以在get/set方法中 对数据进行一系列的操作

get和set方法(getter/setter)

get方法: 作用是获取对象的属性值,不需要形式参数,但是需要有返回值类型,类型是和属性的类型一致
set方法: 作用是为属性进行赋值操作,是有形式参数,返回值类型为void,参数类型和属性的类型是一样的

例:

public class PersonTest {
	public static void main(String[] args) {
		//Person类测试,创建对象,调用构造方法赋值
		Person a = new Person("ajiang", 18);
		System.out.println(a.getAge());
		a.setAge(188);
		System.out.println(a.getAge());
	}
}

//封装一个 Person 类
class Person {
	//将成员变量私有化,封装
	private String name;
	private int age;

	//构造方法,传入参数为属性赋值,可以在创建对象时就赋值
	Person(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		//设置条件,只有当传入参数不小于0且不大于150时才能为属性赋值
		if (age <= 150 && age >= 0)
			this.age = age;
		else
			System.out.println("数据错误");
	}
}

练习:

编程：定义一个 Dog 类，类中属性有名字、年龄、性别，要求如下：
(1) 提供一个无参数的构造方法和一个带有三个参数的构造方法
(2) 类中定义一个无参数的 play 方法：输出 宠物狗
(3) 类中定义一个带有一个参数的 play 方法，参数类型为 int hours，打印输出玩的小时数
(4) 定义一个测试类，分别用无参数的构造法和有参数的构造方法创建对象，并对属性赋值，分别将对象的信息打印在控制台上，调用 play 方法

class Dog {
	//封装属性
	private String name;
	private int age;
	private String sex;

	//构造方法
	Dog() {

	}

	Dog(String name, int age, String sex) {
		this.name = name;
		this.age = age;
		this.sex = sex;
	}

	//提供接口
	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 String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	//静态方法
	public static void play() {
		System.out.println("宠物狗");
	}
	
	//静态方法
	public static int play(int hours) {
		System.out.println("玩了" + hours + "小时");
		return hours;
	}
}

//public 类
public class Practice1 {
	//主方法
	public static void main(String[] args) {
		//创建对象,调用无参构造
		Dog d1 = new Dog();
		//创建对象,调用有参构造
		Dog d2 = new Dog("小狗", 3, "公狗");

		//为d1的属性赋值
		d1.setName("小白");
		d1.setAge(2);
		d1.setSex("母狗");
		
		//更改d2的属性
		d2.setName("小黑");

		System.out.println(d1.getName()+"的年龄是"+d1.getAge()+"-"+d1.getSex());
		System.out.println(d2.getName()+"的年龄是"+d2.getAge()+"-"+d2.getSex());

		d1.play();
		d2.play(2);
	}
}

周四

static 修饰符

修饰成员方法

static修饰成员方法叫做静态方法

访问方式:
1.  可以通过引用去调用 ----> 不推荐 浪费内存
2.  可以直接通过 类名.方法名(); 直接调用 ----> 推荐

特点

1 静态方法不可以直接访问非静态成员(成员变量 & 成员方法),但是非静态方法中可以直接访问静态成员(静态变量 & 静态方法) 和 非静态成员(成员方法 & 成员变量) 
2 如果非要在静态方法中访问非静态成员,只能创建对象,用对象的引用去访问 
3 静态方法中,不能使用 this / super 关键字,因为 this&super 都是和对象有关,静态方法是属于类,类的存在优先于对象的存在,当使用 类名.方法名 直接调用静态方法的时候,这个时候还没有对象存在,this/super 就不知道代表谁了,编译报错

工具类的编写

工具类: 在一个类中定义的方法都是静态方法,方法可以通过 类名.方法名 直接进行调用,而不用创建对象,这样的类叫做工具类

java中常见的工具类

 Array(数组) ----> Arrays 工具类
 Collection(集合接口) ----> Collections 工具类

案例:自己实现一个数组工具类
功能:遍历int数组
获取int数组的最大值 和 最小值
可以实现 int数组的反转

public class MyArrays {
   // 获取int数组中的最小元素
   public static int getMax(int[] array) {
   	int max = array[0];// int一个max变量，用于存储最大值，先将数组中第一个元素赋值给max
   	for (int i = 0; i < array.length; i++) {// for循环
   		max = (max > array[i]) ? max : array[i];// max挨个和数组中的元素作比较，较大的值赋值给max
   	}
   	return max;
   }

   // 获取int数组中的最小元素
   public static int getMin(int[] array) {
   	int min = array[0]; int一个min变量，用于存储最小值，先将数组中第一个元素赋值给min
   	for (int i = 0; i < array.length; i++) {
   		min = (min < array[i]) ? min : array[i];
   	}
   	return min;
   }

   // 该方法可以将数组元素倒序排列
   public static int[] reverse(int[] array) {
   	for (int i = 0; i < array.length / 2; i++) {
   		// 第一个元素和最后一个元素交换顺序
   		// 第二个元素和倒数第二个元素交换顺序...
   		// 一直交换到中间两个元素互相交换，或者最中间一个元素的旁边两个元素互相交换
   		int a = array[i];
   		array[i] = array[array.length - i - 1];
   		array[array.length - i - 1] = a;
   	}
   	return array;
   }

   // 遍历数组，以，隔开每个元素，最后一个元素后面没有，
   public static void printArray(int[] arr) {
   	// for循环依次访问数组元素
   	for (int i = 0; i < arr.length - 1; i++) {
   		System.out.print(arr[i] + ",");
   	}
   	System.out.println(arr[arr.length - 1]);
   }
}

帮助文档的制作

当工具类制作好之后, 编译生成了字节码文件,可以供给他人使用,为了方便于他人 可以为这个工具类制作一个帮助文档

注释

单行注释: // 单行注释 
 多行注释: 
 /* 
 多行注释
 */ 
 文档注释: 
 /**
 	文档注释 
 */
 特点: 可以使用javadoc.exe工具 生成一个类似于网站的一组网页

文档注释的注解
将来生成文档的时候, 会根据注解进行解析 可以解析出具体的数据

@author ---> 作者 可以解析出作者 
@version ---> 版本 可以解析版本 
@since ---> 可以解析这个功能从哪个版本开始的
@param ---> 参数名称 可以解析参数的意思 
@return ---> 对方法的返回值进行解析

帮助文档的生成

1. 可以通过cmd命令行 生成 语法: javadoc -d 文件夹名称(-author -version) java源文件名.java
2. 利用eclipse 进行生成

局部变量和成员变量和静态变量对比

继承

里氏代换原则: 两个类之间必须满足is a关系,才可以定义两个类的继承关系

关键字 extends

语法:

class 父类{
 }
class 子类 extends 父类{ 
}

示例:

public class Practice1{
	public static void main(String[] args) {
		//创建Zi对象
		Zi z1 = new Zi();
	}
}

//定义父类
class Fu{
	int a = 1;
	private int b = 3;

}
//定义子类
class Zi extends Fu{
	int c = b;//这里会报错,因为上面的b被private修饰
	Zi(){
		//无参构造方法,创建对象时打印a
		System.out.println(a);
	}
}

特点

1. 当一个子类继承父类之后,子类就拥有了父类中所有的 非私有的属性和方法的 使用权
2. 构造方法是不能被继承的
3. java是单继承(一个类只能有一个直接父类 但是可以有多个间接的父类)

java中使用接口处理多继承的关系

访问修饰符

子类对象创建的过程

1. 类加载过程 
(1) 父类的类加载 
(2) 子类的类加载
2. 创建对象过程
(1) 创建父类对象 
为父类对象的属性赋 默认值 
为父类对象的属性赋 初始值 
调用父类的构造方法(再次赋值)完成父类对象的创建 
(2) 创建子类对象 
为子类对象的属性赋 默认值
为子类对象的属性赋 初始值 
调用子类的构造方法(再次赋值)完成子类对象的创建

super 关键字

super: 超级的 super在java中代表当前对象的 直接父类 对象的引用

super.  : super代表当前对象的直接父类对象的引用,作用是区分重名的子类和父类的属性和方法
super(实际参数) :作用在子类构造方法中调用父类的构造方法 
注意事项: 
1. super(实际参数): 语句必须用在子类的构造方法中, 必须是第一条有效语句.
2. 如果子类的构造方法的第一条语句不是 this()/this(实际参数)/super(实际参数),默认在子类的构造方法的第一条语句是super();

练习:写出下面代码的运行结果

public class Test {
	public static void main(String[] args) {
		Sub sub1 = new Sub();
		Sub sub2 = new Sub(10);
		Sub sub3 = new Sub("hello");
	}
}

class Super {
	public Super() {
		System.out.println("Super()");
	}

	public Super(String string) {
		System.out.println("Super(String)");
	}
}

class Sub extends Super {
	public Sub() {
		System.out.println("Sub()");
	}

	public Sub(int i) {
		this();
		System.out.println("Sub(int)");
	}

	public Sub(String string) {
		super(string);
		System.out.println("Sub(String)");
	}
}

结果:

Super()
Sub()
Super()
Sub()
Sub(int)
Super(String)
Sub(String)

提高练习:定义一个类 Te类 要求这个类只能创建10个对象,当创建第11个对象的时候返回的是 null

public class Test {
	public static void main(String[] args) {
		//创建一个元素类型是Te类类型的数组对象,长度13
		Te[] tes = new Te[13];
		//为数组赋值,即创建对象
		for (int i = 0; i < tes.length; i++) {
			tes[i] = Te.test();
			//遍历数组,看看结果
			System.out.println(tes[i]);
		}
	}
}

class Te {
	// 定义一个私有静态变量i
	private static int i = 1;

	private Te() {
		// 一旦创建类的对象就会调用此构造方法,使i+1
		i++;
	}

	// 创建一个静态方法,可以创建类的对象
	static Te test() {
		//如果i不大于10则返回一个新对象
		if (i <= 10)
			return new Te();
		else
			return null;//否则返回null
	}
}

周五

方法的重写

方法的重写(覆盖): 当父类中继承给子类的方法,不能满足子类的需要,这个时候,需要在子类中定义一个声明相同(方法名 形式参数列表 返回值类型 )的方法,但是方法的具体实现不同,这种语法现象叫做方法的重写.

要求:

1. 方法名 形式参数列表 返回值类型 都相同
2. 子类方法的访问修饰符的权限要比父类大或者相同
3. 方法的重写只能发生在子父类之间

@Override : 加载子类的方法上 用来检测方法是否是重写的关系

当子类重写父类后的方法,创建子类对象,调用重写后的方法,执行的是子类重写后的方法实现

overload和override 的区别

方法重载:
1. 方法名相同 
2. 参数列表不同(类型 顺序 个数) 
3. 和修饰符 返回值类型无关
4. 方法的重载可以发生在本类 / 也可以发生在子父类之间 
方法的重写: 
1. 方法名 返回值类型 形式参数列表 都相同
2. 子类方法的访问修饰符比父类的更宽/一样 
3. 方法的重写只能发生在子父类之间

案例1:子父类之间的方法的重载

public class Demo1 {
	public static void main(String[] args) {
		Son son = new Son();
		son.eat();
		son.eat("米饭");
	}
}

class Father{
	public void eat() {
		System.out.println("父亲吃饭");
	}
}

class Son extends Father{
	public void eat(String food) {
		System.out.println("儿子吃"+food);
	}
}

案例2:子父类之间方法的重写

public class Demo1 {
	public static void main(String[] args) {
		Son son = new Son();
		son.eat();
	}
}

class Father{
	public void eat() {
		System.out.println("父亲吃饭");
	}
}

class Son extends Father{
	@Override
	public void eat() {
		super.eat();//调用父类eat()方法
		System.out.println("儿子吃米饭");
	}
}

代码块

代码块: 放在不同的位置有不同的作用

{代码块}

局部代码块 :
局部代码块定义在方法中,和局部变量是一个位置,用于限定局部变量的作用域范围,控制局部变量的生命周期

构造代码块(动态代码块 初始代码块) :
位置: 类中 方法外 和成员的位置一样
作用: 可以为成员变量进行初始化赋值操作
执行时机: 创建对象的时候,和成员变量按照顺序进行依次执行
应用: 可以将所有构造方法*同执行的代码,提取到构造代码块中,从而实现代码简化的目的.

静态代码块 :
概念: 就是被static修饰的构造代码块
位置: 类中 方法外 和 静态变量位置一样
加载时机: 在类加载的时候,和静态变量按照顺序依次执行.
作用: 可以为静态变量进行初始化赋值操作,一般用于驱动的加载.(jdbc )

同步代码块(在线程中讲)

final 修饰符

可以被final修饰的:
1. 变量:局部变量 成员变量 静态变量 
2. 方法:成员方法 静态方法 
3. 类

final修饰的局部变量,只有一次赋值机会,一旦赋值其值不可改变

final修饰成员变量没有默认值,只有一次赋值机会,一旦赋值其值不可以再改变

final修饰的静态变量没有默认值,只有一次赋值机会,一旦赋值其值不可以再改变

 常量的分类: 
 普通常量: 只被final修饰的变量 
 静态常量: 被static & final同时修饰 
 公开静态常量: 被 public static final 同时修饰

final修饰方法(静态方法,成员方法)
都可以被继承,都可以被重载 ,但是都不能被重写

final修饰的类 不允许有子类

内部类

内部类: 定义在一个类内部的类 叫做内部类

成员内部类
静态内部类
局部内部类
匿名内部类

成员内部类

位置: 类中方法外 和 成员变量/成员方法的地位一样

格式:
class Outer{ 
	//定义一个成员内部类 
	class Inner{
	} 
}

对象的创建方式
成员内部类的对象创建必须依赖于外部类对象 才能创建 
语法: 
(1) 外部类类名 外部类对象名 = new 外部类类名(); 
外部类类名.内部类类名 内部类对象名 = 外部类对象名.new 内部类类名(); 
(2) 外部类类名.内部类类名 内部类对象名 = new 外部类类名().new 内部类类名();

特点
1. 成员内部类可以直接访问外部类的私有成员而不破坏封装 
2. 成员内部类中不可以定义静态成员(静态变量 & 静态方法 & 静态代码块),原因是生命周期不同. 
3. 如果外部类要访问内部类的成员,必须要创建内部的对象.

例:

//成员内部类
public class Practice1 {
	public static void main(String[] args) {
	Test.Te te = new Test().new Te();
	te.mz(); 
	}
}

class Test {
	private int a = 2;
	private static int b =23;
	
	private static final int C = 222;
	
	class Te{
		{
			System.out.println(a+b+C);
		}
		void mz() {
			System.out.println(C);
		}
	}
}

静态内部类

静态内部类: 就是被static修饰的成员内部类
位置: 类中方法外 和 静态成员位置和地位一样

对象创建方式,语法:
外部类类名.内部类的类名 内部类的对象名 = new 外部类类名.内部类类名();

特点
1. 静态内部类只能直接访问外部类的静态成员,如果非要访问外部类的非静态成员,必须创建外部类的对象.通过对象访问. 
2. 对于静态内部类中的静态成员,可以通过外部类类名.内部类类名.静态属性名/ 静态方法名 来进行直接调用.

练习:

1.(继承+封装)编程：定义一个人类(Person)，包括属性：姓名、性别、年龄、国籍； 包括的方法:吃饭、睡觉，工作 
(1) 根据人类，定义一个学生类，增加属性：学校、学号；重写工作方法(实现内容为学习)
(2) 根据人类，定义一个工人类，增加属性：单位，工龄；重写工作方法 
(3) 根据学生类，定义一个学生*类(StudentLeader)，增加属性：职务；增加方法：开会 
(4) 定义一个测试类，分别创建上述 3 类具体人物的对象并将信息打印在控制台上。
2. 编程 有以下几个类,根据下面的继承关系图,用Java代码实现. 要求必须封装 
 (1) Circle 类圆形 属性: 半径 方法:求周长 求面积 
 (2) Rect 类 矩形 属性: 长 宽 方法: 求周长 求面积 
 (3) Square 类 正方形 属性: 边长 方法 求周长 求面积 提示: 正方形是特殊的矩形

这俩我还没写,回来写了放上来

本文地址：https://blog.csdn.net/xiaojiang5503/article/details/109543777