四万余字,细致讲解Java基础,让你轻松入门Java

Java 专栏收录该内容
3 篇文章 0 订阅

我决定了要成为海贼王便要为此而战,我必须变的更强。———路飞

此阶段大致梳理Java核心基础知识点,旨在明晓语法基础的同时透彻领悟Java的思想方法,为后续精益求精,Java进阶做铺垫

目录

Lesson1(变量和-int)

Lesson2(-double)

Lesson3(-boolean)

Lesson4(-String)

Lesson5(-用户输入)

Lesson6(-if)

Lesson7(-while循环)

习题-1

Lesson8(基本数据类型详解_)

1.基本数据类型详解_整数

2.基本数据类型详解_小数

3.基本数据类型详解_字符

4.基本数据类型详解_boolean

5.基本数据类型小结

6.基本数据类型转换

7.基本数据类型之间的运算

Lesson9(_break和_continue)

Lesson10(_数组)

Lesson11(_方法的概述)

Lesson12(_方法的定义)

Lesson13(_方法的返回值)

Lesson14(_方法的参数)

习题2(_方法练习)

Lesson15(_方法的重载)

Lesson16(_面向对象概述)

Lesson17(_面向过程和面向对象)

Lesson18(_类与对象)

Lesson19(_this关键字)

Lesson20(_构造方法)

Lesson21(_构造方法的重载)

习题3(面向对象_练习)

1.用面向对象的思想模拟<<海贼王>>中索隆上阵杀敌的技能:

2.用面向对象的思维模拟植物大战僵尸:

Lesson22(_static静态)

Lesson23(_包和导包)

Lesson24(_访问权限)

Lesson25(_getter和setter)

Lesson26(_继承)

Lesson27(_super关键字)

Lesson28(_方法的重写)

Lesson29(_多态)

Lesson30(_final关键字)

Lesson31(_抽象)

Lesson32(_接口)

习题4(面向对象_练习2)

Lesson33(_成员变量初始值)

Lesson34(_object)

Lesson35(_equals和==)

Lesson36(_toString)

Lesson37(_instanceof关键字)

Lesson38(_内存分析)

学到这很棒啦!!记得回顾总结Lesson16~38面向对象章节哟

Lesson39(_异常简介)

Lesson40(_异常的分类)

Lesson41(_异常处理_try...catch)

Lesson42(_异常处理_throws和throw)

Lesson43(_自定义异常)

Lesson44(_容器的概念)

Lesson45(_List)

Lesson46(_Set)

Lesson47(_Map)

练习1(容器)

Lesson48(_迭代器Iterator)

Lesson49(_泛型)

Lesson50(_增强for)

Lesson51(_Collections工具类)

JAVA基础学到这基本上完成,后续此内容需要补充的会不定时滚动补充,也欢迎各位大佬留言指正。

下面开始进阶课程...


Lesson1(变量和-int)

*变量

电话号码:

小球:18852525252

小球:19263636363

�0�2

变量:就是可以发生改变的量

变量的意义:把程序运行过程中产生的值,保存起来,方便后面使用

�0�2

变量的声明:

数据类型 变量 = 值

�0�2数据类型:人对数据进行分类,告诉计算机可以执行的操作

�0�2

java的数据类型:

1.int 整数

2.double 小数

3.boolean布尔值

4.String字符串

�0�2

-int

public class Lesson1 {
    public static void main(String[] args) {
/*	//先声明一个变量
	int a = 10;
	System.out.println(a);//10
	a = 20;//a前面不能再写int,此处是使用变量
	System.out.println(a);//20
*/	
	
	int a = 10;
	int b = 20;
	System.out.println(a + b);
	System.out.println(a - b);
	System.out.println(a * b);
	System.out.println(a / b);//如果运算两端都是int,结果就是int,整除  10 / 20 = 0......10
	System.out.println(a % b);//计算余数
	System.out.println(10 % 3);//10个苹果平均分给3个小朋友,最后剩几个?
	
}

}

int 整数:数学的算术运算

+�0�2 �0�2-�0�2 *�0�2 /�0�2 %

%计算余数

Lesson2(-double)

-double

(1)double类型的操作基本和int类型一样,不同的是double计算的结果一般是double类型

(2) = 是赋值操作,把等号右边的结果赋值给等号左边的变量

public class lesson2 {
public static void main(String[] args) {
	double price = 1.25;
	System.out.println(price);
	
	price = price + 0.6;//=表示赋值
	System.out.println(price);
	
	double total = price*2;//double类型的计算,得到的一般都是double类型,若定义为int total = price*3;则报错 
	System.out.println(total);
	
}
}

Lesson3(-boolean)

-boolean

这个世界,不光有数字,文字等这些东西,还有一种东西,它表示状态。

在计算机里,则用boolean表示状态

�0�2

boolean布尔值,保存的是一个状态,成立(ture),不成立(false)

取值范围:

ture成立->真

false不成立->假

命题:真命题,假命题

boolean布尔值主要用来做条件判断的

public class lesson3 {
public static void main(String[] args) {
	double money = 1000;
	double price = 20000;
	System.out.println(money > price);//false
	System.out.println(money < price);//ture
	
	//= 是赋值,不是数学上的判断
	//==条件判断,判断等号左右两端值是否相等
	System.out.println(1000 == 1000);//ture
	System.out.println(1000 == 999);//false
}
}

Lesson4(-String)

-String

在Java里字符串String里S是大写,在Java中用“ ”表示字符串

字符串拼接

public class lesson4 {
public static void main(String[] args) {
	//字符串的拼接
	String s1 = "周杰伦";
	String s2 = "昆凌";
	System.out.println(s1 + s2);//+ 两端只要有一个是字符串,最终都会实现字符串的拼接--->周杰伦昆凌
	System.out.println(1 + 1 + s1);//从左到右,先算数字1+1,得2,再用2和s1拼接
			
}
}
public class lesson4 {
public static void main(String[] args) {
	int a = 10;
	int b = 20;
	System.out.println("a + b = "+ a + b);//a + b = 1020
	System.out.println("a + b = "+ (a + b));//a + b = 30
//运算过程和数学上一样,从左到右,先算括号
}
}

�0�2

字符串可以执行+操作,表示字符串的拼接

字符串的拼接注意点:

(1)+ 两端只要有一个是字符串,最终都会实现字符串的拼接

(2)字符串运算过程和数学上一样,从左到右,先算括号

Lesson5(-用户输入)

-用户输入

Scanner:扫描器

Scanner是JDK提供的一个类,在 Java中用的时候要导包(两种方式):

(1)import java.util.Scanner;

(2)光标停在输入的Scanner上,Alt+回车

�0�2

先创建扫描器-->记住要导包:alt+回车

Scanner sc = new Scanner(System.in);

获取数据:

sc.nextInt();//整数类型
sc.nextDouble();//小数类型
sc.nextLine();//字符串类型

�0�2

�0�2

参照程序:

import java.util.Scanner;
public class lesson5 {
public static void main(String[] args) {
	//1.创建一个扫描器
	Scanner sc = new Scanner(System.in);
	
	//2.使用扫描器获取到用户输入的内容
	int a = sc.nextInt();//获取到整数
	System.out.println(a+1);//控制台出来等待输入界面,例如:输入666,出来667
	
	double d = sc.nextDouble();//获取到小数
	System.out.println("d = "+d);//控制台出来等待输入界面,例如:输入666,出来d = 666
	
	String s = sc.nextLine();//获取到字符串
	System.out.println(s);//控制台出来等待输入界面,例如:输入周杰伦,出来周杰伦
}
}

�0�2

《小小计算器》:

要求用户输入两个数:a,b,程序自动输出a + b的值

import java.util.Scanner;
public class lesson5 {
public static void main(String[] args) {
	//1.创建一个扫描器
	Scanner sc = new Scanner(System.in);
	
	//2.使用扫描器获取到用户输入的内容
	int a = sc.nextInt();
	int b = sc.nextInt();
	
	System.out.println("a + b = "+(a+b));//控制台出来等待输入界面,例如:输入1 3  ,输出a + b = 4
}
}

Lesson6(-if)

-if语句

�0�2

用来做条件判断的

if语句的语法:

if(条件){

�0�2 �0�2 �0�2xxxxxx

}

逻辑:

判断条件是否为真(ture),就去xxxxxx

�0�2

import java.util.Scanner;
public class lesson6 {
public static void main(String[] args) {
	System.out.println("告诉我你兜里的钱:");
	Scanner sc = new Scanner(System.in);
	
	//获取到钱
	double money =sc.nextDouble();
	
	//买手办要用的钱
	double price = 100;
	if(money > price)
	{
		System.out.println("你可以去买手办了!!");
	}
	System.out.println("学习!!");
}	
}
/*告诉我你兜里的钱:
88
学习!!
 */

/*告诉我你兜里的钱:
999
你可以去买手办了!!
学习!! 
 */

if-else语句

if(条件){

�0�2 �0�2 �0�2xxxxxx

}

else{

�0�2 �0�2 yyyyyy

}

逻辑:

如果条件为真,则xxxxxx,否则yyyyyy

import java.util.Scanner;
public class lesson6 {
public static void main(String[] args) {
	System.out.println("告诉我你兜里的钱:");
	Scanner sc = new Scanner(System.in);
	
	//获取到钱
	double money =sc.nextDouble();
	
	//买手办要用的钱
	double price = 100;
	if(money > price)
	{
		System.out.println("你可以去买手办了!!");
	}
    else{
        System.out.println("你攒钱了!!");
    }
	System.out.println("学习!!");
}	
}

if-else多条件分支语句

if(条件1){

�0�2 �0�2 �0�2 xxxxxx

}else if(条件2){

�0�2 �0�2 �0�2yyyyyy

}else if(条件3){

�0�2 �0�2 �0�2zzzz

}else {

�0�2 �0�2 �0�2nnnnnn

}

逻辑:

判断条件1是否成立,如果成立,执行xxxxx,否则如果条件2成立,执行yyyy,否则如果条件3成立,执行zzzz,若都不成立,则最终执行nnnnnnn

从上到下判断,一个条件成立则执行完就跳出,后面不再执行

Lesson7(-while循环)

-while循环

在Java中一共提供了3种循环:
1.while循环

2.for循环

3.do-while循环

while循环

while(条件){

�0�2 �0�2 �0�2 �0�2xxx(循环体)�0�2

}

循环逻辑:

判断条件是否为真,如果条件真,执行循环体,再次判断条件是否为真,如果条件为真,继续执行循环体。

public class lesson7 {
public static void main(String[] args) {
	/*
	 //死循环
	while(ture) {
		System.out.println("滚去学习!");
	}
	*/
	//改变条件:喊10次
	int i = 1;
	while(i <= 10) {
		System.out.println("滚去学习!");
		i = i + 1;
	}
}
}
/*滚去学习!
滚去学习!
滚去学习!
滚去学习!
滚去学习!
滚去学习!
滚去学习!
滚去学习!
滚去学习!
滚去学习!
*/

�0�2

习题-1

�0�2使用本章学习的知识点,完成猜数游戏

首先,我得先给出各位一段代码,这段代码可以帮我们产生一个随机数

Random rd = new random();

int n = rd.nextInt(100);//n是一个随机数,范围是[0,99]

System.out.println(n);//打印看看

OK,我们可以产生随机数了,剩下的请看要求:

让用户输入一个数字a,判断用户输入a与n之间的关系:

1.如果用户猜大了.提示 猜大了.继续猜.

2.如果用户猜小了.提示 猜小了.继续猜.

3.如果用户猜对了.提示 猜对了.结束循环.

�0�2

import java.util.Random;
import java.util.Scanner;
public class Homework1 {
public static void main(String[] args) {
	Random rd = new Random();

	int n = rd.nextInt(100);//n是一个随机数,范围是[0,99]

	System.out.println(n);//打印看看
	
	boolean flag = true;
	
	while(flag) {
	Scanner sc = new Scanner(System.in);
	
	System.out.println("请输入一个数字:");
	int a = sc.nextInt();
	 
	//判断
	if(a > n) {
		System.out.println("对不起,猜大了!");
	}
	else if(a < n){
		System.out.println("对不起,猜小了!");
	}
	else {
		System.out.println("恭喜你,猜对了!");
		flag = false;
	}
	}
}
}

�0�2

Lesson8(基本数据类型详解_)

1.基本数据类型详解_整数

(1)byte是在Java程序中最小的数据单元,8bite�0�2 �0�2 �0�2-128~127之间

(2)int�0�2 �0�2整数�0�2 �0�232bit�0�2 4byte�0�2 �0�2 �0�2-21亿~21亿之间

(3)short�0�2 短整数�0�2 16bit�0�2 2byte�0�2 �0�2 �0�2 �0�2-32768~32767之间

(4)long�0�2 �0�2长整数�0�2 �0�2 64bit�0�2 8byte�0�2 �0�2�0�2

public class Test1 {
public static void main(String[] args) {
	byte score = 90;
	System.out.println("小学数学:"+score);
	
	short gaokao_score = 387;
	System.out.println("高考分数:"+gaokao_score);
	
	int people_num = 1300000000;//13亿
	System.out.println("我国人口有:"+people_num);
	
	long people_world = 6000000000L;//60亿    长整数一般数字最后用L结尾
	System.out.println("全国人口有:"+people_world);
}
}

注意:long长整数类型�0�2 �0�2 一般数字最后用L结尾

2.基本数据类型详解_小数

(1)double 64bit 8byte�0�2 双精度小数,精度高,准确性高

(2)float�0�2 32bit�0�2 �0�24byte�0�2 �0�2单精度小数

public class Test2 {
public static void main(String[] args) {
	float a = 0.1234567890123456f;
	System.out.println(a);//输出0.12345679    最多保留小数点后8位
	
	double b = 0.1234567890123456789;
	System.out.println(b);//输出0.12345678901234568   最多保留小数点后17位
}
}

注意:(1)float类型�0�2 一般数字最后用f结尾

�0�2 �0�2 �0�2 �0�2 �0�2 �0�2(2)float类型�0�2 最多保留小数点后8位

�0�2 �0�2 �0�2 �0�2 �0�2 �0�2(3)double类型�0�2 最多保留小数点后17位

3.基本数据类型详解_字符

字符:单一的文字符号

char�0�2 �0�2 16bit�0�2 �0�2unicode标准(万国码)

char类型可以存放数字,存放的数字实际上是字符

public class Test3 {
public static void main(String[] args) {
	char a = '爱';//必须是单一字符,必须用单引号引起来
	System.out.println(a);
	
	char b = 20210;
	System.out.println(b);

}
}

注意:char类型中�0�2 �0�2必须是单一字符,必须用单引号引起来。

4.基本数据类型详解_boolean

boolean

取值范围:true�0�2 �0�2false

8bit�0�2 �0�21byte

5.基本数据类型小结

整数:

1.byte�0�2 �0�2 字节�0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 8bit

2.short�0�2 �0�2短整数�0�2 �0�2 2byte�0�2 �0�2 16bit

3.int�0�2 �0�2 �0�2 �0�2整数�0�2 �0�2 �0�2 �0�24byte�0�2 �0�2 �0�232bit

4.long�0�2 �0�2长整数�0�2 �0�2 8byte�0�2 �0�2 �0�264bit

小数:

1.float�0�2 �0�2 �0�2 �0�2 单精度小数�0�2 �0�2 4byte�0�2 �0�2 32bit

2.double�0�2 �0�2 双精度小数�0�2 �0�28byte�0�2 �0�2 �0�264bit

字符:

char单一文字符号�0�2 �0�2 �0�22byte�0�2 �0�216bit

必须用单引号括起来

布尔:

boolean�0�2 在计算机中�0�2 1byte�0�2 8bit

true�0�2 �0�2false

6.基本数据类型转换

(类似于:大杯子小杯子装水)

int�0�2 �0�2 �0�2 �0�24byte�0�2 �0�2 32bit

long�0�2 �0�2 8byte�0�2 �0�2 64bit

顺序:数据量的大小

byte->short,char->int->long->float->double

小数据类型->大数据类型:安全的,直接转化

大数据类型->小数据类型:不一定安全,可能会出现溢出,必须强转

(转换之后的数据类型) 变量

public class Test4 {
public static void main(String[] args) {
	int a = 10;
	long b = a;//安全的
	System.out.println(b);
	
	long c = 10000000000000L;
	int d = (int) c;
	System.out.println(d);//如果程序产生溢出,程序就不可控了,则结果毫无意义
	
}
}

7.基本数据类型之间的运算

1.相同数据类型之间:

相同数据类型之间运算,结果一定是该数据类型

int�0�2 +�0�2 int�0�2 =�0�2 int

int a = 3;
int b = 6;
System.out.println(a/b);//还是int型

2.不同数据类型之间:
int + long = long

首先把小的数据类型自动转换成大的数据类型,然后再进行运算,得到的结果一定是大的数据类型

int a = 43;
long b = 20;
long c = a + b;//若定义成int类型,会报错
System.out.println(c);

3.特殊的byte,short,char

在计算的时候,首先会转换成int类型再进行运算,这样是安全的

byte + byte = int

结果至少是 int

byte a = 10;
byte b = 10;
int c = a + b;//若定义成byte类型,则容易超过byte范围,报错
System.out.println(c);
short s1 = 1;
//short s2 = s1 + 1;//程序会报错:数据类型不匹配
short s2 =(short)(s1 + 1);//强制转换
System.out.println(s2);

�0�2

Lesson9(_break和_continue)

while(条件){

�0�2

}

�0�2

for(;条件;){

�0�2

}

除了改变while,for循环里的条件以外,还有有其他方式可以让循环停止吗?

—>break�0�2 �0�2 �0�2�0�2

—>continue

�0�2

break :

终止,终止一个循环的执行

continue:

中断,停止当前本次循环,继续执行下一循环

�0�2break �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2

public class lesson9 {
public static void main(String[] args) {
	for(int i=1;i<=20;i++){
		if(i==10) {
			break;//彻底终止循环
		}
		System.out.println(i);
	}//
	
}
}

continue

public class lesson9 {
public static void main(String[] args) {
	for(int i=1;i<=20;i++){
		if(i==10) {
			continue;//打印时跳过i=10,其他照常打印
		}
		System.out.println(i);
	}//
	
}
}

�0�2

Lesson10(_数组)

数组:具有相同数据类型的集合

java中数组:

类型[ ] 数组名 = new 类型[大小];

类型[ ] 数组名 = {数据,数据,数据....}

类型[ ] 数组名 = new 类型[ ]{数据,数据,数据.....}

怎样用数组

数组必须配合数组的小标使用

数组的小标从0开始

�0�2

如何查看数组中所有的数据:

�0�2 �0�2 �0�2 �0�2 �0�2 �0�2 数组的遍历

length表示数组的长度

   for(int i=0;i<arr5.length;i++) {//arr5.length表示数组中有多少个数据   —>数组的长度
     	System.out.print(arr5[i]);
 }
public class lesson10 {
public static void main(String[] args) {
	int[] arr1 = new int[5];
	
	int[] arr2 = {33,23,42,66,87};
	
	int[] arr3 = new int[] {33,23,42,66,87};
	
	int[] arr4 = {45,87,90,42};
	
	System.out.println(arr4[1]);//通过下标获取第2位置的数字  —>87
	
	arr4[1] = 88;//通过下标修改数组中的数据
	
	System.out.println(arr4[1]);//—>88
	
	
	int[] arr5 = {33,87,96,20,18};
	for(int i=0;i数组的长度
		System.out.print(arr5[i]);
	}
	
}
}

�0�2

Lesson11(_方法的概述)

方法:

1.打开电脑

2.打开B站

3.点开up猪视频儿

4.下次一定

�0�2

通俗:多次用到这个步骤,次数多了重复的步骤太多,又不能用循环(循环在程序存在时时会用到),而我们打开电脑不是只干这一件事,所以不适合用循环,而我们想要的是,想看的时候才去打开B站,我们把这一件事情拿出来整理成一套方案,只在需要的时候拿出来运行一下,这就是方法。

�0�2

方法:对功能或动作的封装,在需要的时候调用

�0�2

Lesson12(_方法的定义)

方法的定义:

public static void 方法名(){

�0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2方法体

}

方法的调用:

方法名();

�0�2

public static void 先照着写

方法体:这件事到底应该怎么做

注意:不可以在方法里定义方法

public class lesson12 {
	/*
	 * 定义一个方法“看”
	 * 只是定义方法,还没有调用
	 * 
	 */
	public static void kan() {
		System.out.println("1.打开电脑");
		System.out.println("2.打开B站");
		System.out.println("3.点开up猪视频儿");
		System.out.println("4.下次一定");
	}
	
//主方法,主函数,程序的入口
public static void main(String[] args) {
	System.out.println("我要看上B站看视频!");
	kan();//调用方法
	System.out.println("白嫖真香!!!!!!");
}
}

�0�2

Lesson13(_方法的返回值)

返回值:执行方法之后得到的结果

public�0�2 static�0�2 返回值类型�0�2 方法名(){

�0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2方法体

�0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 return�0�2 值;

}

注意:

  1. 返回值类型与返回值必须匹配
  2. 如果写了返回值类型就必须写返回值、
  3. 如果写了返回值就必须写返回值类型
  4. 没有返回值,返回值类型要写void,方法体里可以不写return或者return后面不跟返回值
  5. return 之后不可以再写代码了

以上5点都要遵守

public class lesson13 {
	public static String buy() {
		System.out.println("我要去买烟了!!");
		//需要用return进行返回值
		return "中华香烟";
	}

public static void main(String[] args) {
	//buy();//没有接收返回值
	//返回值返回给调用方法
	
	String yan = buy();//接收返回值
	System.out.println("得到的返回值是"+yan);
	
}
}

�0�2

Lesson14(_方法的参数)

参数:在方法执行的时候,给方法传递的信息

public static void 方法名(形参){

�0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 方法体

}

�0�2

方法名(实参);

形参:接收数据

实参:传递数据

单向传递:实参—>形参

注意:

  1. 在方法中可以有多个参数
  2. 参数的个数必须匹配
  3. 参数的数据类型必须匹配
public class lesson14 {
	public static void kan(String tools,int num) {
		System.out.println("1.打开"+tools);
		System.out.println("2.打开B站");
		System.out.println("3.点开up猪"+num+"视频儿");
		System.out.println("4.下次一定");
	}

	public static void main(String[] args) {
		//用手机打开一次B站,再用电脑打开一次B站
		kan("手机",1);
		kan("电脑",2);
		
	}	
}

�0�2

习题2(_方法练习)

1.写方法,给方法传递两个整数a,b,返回a和b中比较大的那个数

2.写方法,把传入的数组翻转并返回

(注意点:方法的参数,方法的返回值)

第一题:

public class Test5 {
	
public static int compare(int a,int b) {
	
	if(a > b) {
		return a;
	}
	
	else{
		return b;
	}
	
}


public static void main(String[] args) {
	
	//int c = compare(1,6);
	//System.out.println(c);
      System.out.println(compare(1,6));//变量c只用一次,没必要专门定义
	
}
	
	
}

还可以中间if语句换成三目表达式,三目运算符:�0�2x?y:z

if(a > b) {
�0�2�0�2 �0�2�0�2�0�2 �0�2return a;
�0�2�0�2 �0�2}
�0�2�0�2 �0�2
�0�2�0�2 �0�2else{
�0�2�0�2 �0�2�0�2�0�2 �0�2return b;
�0�2�0�2 �0�2}

改后:

int m = (a > b) ? a:b;

return m;

第二题:

public class Test6 {
public static int[] reverse(int[] arr) {
	//返回的是一个数组
	int[] ret = new int[arr.length];
	//0  1 2  3  4
	//22 5 78 16 9
	
	int index = 0;//ret数组的下标
    for(int i = arr.length - 1;i >= 0;i--) {//反着拿数据
    	ret[index] = arr[i];//正着往里装
    	index++;
    	
    }
	return ret;
}

	public static void main(String[] args) {
		int[] a = {22,5,78,16,9};
		
		int[] b = reverse(a);
		
		for(int i = 0;i < b.length;i++) {
			System.out.println(b[i]);
		}
		
		
	}

}

�0�2

Lesson15(_方法的重载)

重载:方法的名字相同,参数的个数或者类型不同

和返回值没有关系

在执行的时候,程序会自动根据你的参数去找对应的方法,执行

�0�2

重载的作用:让我们省去起名字的烦恼(做大型项目的时候,起名字是个问题)

public class lesson15 {
//吃
	
	public static void chi(String fan) {
		System.out.println("吃"+fan);
		
	}
	
	
	public static void chi(String fan,String cai) {
		System.out.println("吃"+fan);
		System.out.println("吃"+cai);
	}
	
	
	public static void main(String[] args) {
		chi("大米饭");
		chi("小米饭");
		chi("米饭","花菜");
	}
	
	
}

测试:计算a + b的和

public class Test7 {
	
public static void add(int a,int b) {
	
	System.out.println("这是int类型");
	System.out.println(a + b);
}


public static void add(double a,double b) {
	
	System.out.println("这是double类型");
	System.out.println(a + b);
}
	
public static void main(String[] args) {
	add(1,2);
	add(1.2,3.6);
}
	
//——>结果
/*这是int类型
*3
*这是double类型
*4.8
*/

}

�0�2

Lesson16(_面向对象概述)

本章要学的相对重要的知识点:

  1. 类与对象
  2. 构造方法
  3. 访问权限
  4. 继承
  5. 多态(最重要)
  6. 抽象与接口
  7. 内存分析

这几个知识点相对重要,其他未罗列的也重要

�0�2

Lesson17(_面向过程和面向对象)

面向对象:侧重的是过程

优点:想起来简单,写起来也简单

缺点:代码量大的时候,维护成本高,可维护性差

�0�2

面向对象:侧重的是对象。上帝视角:创建一个大象,告诉大象你要进冰箱( 具体怎么进不管!)

优点:可扩展性非常强,维护成本低

缺点:新手上手难

�0�2

Lesson18(_类与对象)

造车:

1.画图纸

(1)定义车的属性信息:color,speed,seat

(2)定义车的动作:跑

2.拿着图纸找工厂生产车

�0�2

面向对象的世界里:

类:就是图纸

属性:这一类事物拥有的共同属性

动作:这一类事物共同能执行的功能

对象:使用类创建的具体的某个东西

�0�2

对象能干什么?�0�2 完全取决于类是如何定义的

�0�2

写代码:

类要使用class来定义

属性:用成员变量来描述,直接写在类中的变量

动作:就是成员方法,不写static就是成员方法

public class Car {
//成员变量
	String color;//颜色
	int speed;//速度
	int seat = 5;//座位
	
	//成员方法
	public void run() {//——>动作:成员方法,不写static就是成员方法
		System.out.println("车能跑");	
	}
	
	public static void main(String[] args) {
		//int a = 10;//写在方法里的变量,称为局部变量
		
		//创建对象:——>  类 引用 = new 类();
		//int a = 10;
		
		//在面向对象的世界里,变量是没有市场的,这种变量称为引用
		//在java中数据类型分为两种:1.基本数据类型   2.引用数据类型——>String和我们创建的所有类
		
		
		Car c = new Car();//创建对象, 创建了一辆车,后面想用这辆车,就需要用c来访问
		
		
		//让车去跑
		
	    //对象或者引用.方法();
		c.run();//.表示调用“ . ” ——> “的”
		
		c.color = "绿色";
		c.speed = 120;
		//c.seat = 5;
		
		//c.pailiang = 1.5;//类中没有定义的内容不可使用
		
	      System.out.println(c.color);
		
		Car c2 = new Car();
		
		c2.color = "红色";
		c2.speed = 130;
		//c2.seat = 5;
		
		System.out.println(c2.color);
		System.out.println(c.seat);
		System.out.println(c2.seat);
	}

}

�0�2

Lesson19(_this关键字)

this:

(1)this当前类的对象

(2)this可以在方法内部获取到对象中的属性信息

(3)this可以区分成员变量和局部变量

�0�2

验证一下this关键字执行过程:

public class Car {

	String color;
	int speed;
	int seat = 5;
	
	public void run() {
		//默认会有一个this:当前正在执行这个方法的对象
		//想在run()方法里得到车的颜色,速度,但是不想用传参,此时可以用this关键字
		
		System.out.println(this);	
		System.out.println("车能跑");	
	}
	
	public static void main(String[] args) {
		
		Car c = new Car();
		
		c.color = "红色";
		c.speed = 120;
		
		c.run();//在调用方法的时候,java会自动把对象传递给方法,在方法中由this来接收对象
	
	    System.out.println(c);
		
	}

}

//结果如下:

/*Car@2ff4acd0
 *车能跑
 *Car@2ff4acd0
/



�0�2

this是随动的:

public class Car {

	String color;
	int speed;
	int seat = 5;
	
	public void run() {
		
		System.out.println(this.color);	
		System.out.println(this.speed);	
		System.out.println("车能跑");	
		
	}
	
	public static void main(String[] args) {
		
		Car c = new Car();
		
		c.color = "红色";
		c.speed = 120;
		c.run();
	
		
	    Car c2 = new Car();
	    
	    c2.color = "绿色";
	    c2.speed = 160;
	    c2.run();
	}

}
//结果
/*红色
120
车能跑
绿色
160
车能跑
 */

变量的查找顺序:找自己的方法内,如果没有,去this里面找:

public class Car {

	String color;
	int speed;
	int seat = 5;
	
	
	public void fly() {
		
	//System.out.println(this.color + "颜色的车会飞");	
	  System.out.println(color + "颜色的车会飞");//此时访问的也是成员变量
	  //变量的查找顺序:先找自己的方法内,如果没有,就去this里面找
		
	}
	
	public static void main(String[] args) {
		
		Car c = new Car();
		c.color = "绿色";
		
		c.fly();
		
	}

}
//结果:
/*
绿色颜色的车会飞
*/

�0�2

public class Car {

	String color;
	int speed;
	int seat = 5;
	
	
	public void fly(String color) {
		
	  System.out.println(color + "颜色的车会飞");
	  //变量的查找顺序:先找自己的方法内,如果没有,就去this里面找
		
	}
	
	public static void main(String[] args) {
		
		Car c = new Car();
		c.color = "绿色";
		
		c.fly("黑色");
		
	}

}
//结果:
/*
黑色颜色的车会飞
*/

this可以帮我们区分成员变量和局部变量:
�0�2

public class Car {

	String color;
	int speed;
	int seat = 5;
	
	
	public void fly(String color) {
		
	  System.out.println(this.color + "颜色的车飞" + color + "在颜色的云彩里");
	  //变量的查找顺序:先找自己的方法内,如果没有,就去this里面找
		
	}
	
	public static void main(String[] args) {
		
		Car c = new Car();
		c.color = "绿色";
		
		c.fly("黑色");
		
	}

}
//结果:
/*
 * 绿色颜色的车飞黑色在颜色的云彩里
 */

�0�2

Lesson20(_构造方法)

构造方法:

在创建对象的时候,自动调用的方法

public 类名(传参){

�0�2

}

注意:1.没有返回值这一项

�0�2 �0�2 �0�2 �0�2 �0�2 �0�22.在我们new的时候,自动调用构造方法

�0�2

最大的作用:在创建对象的时候,给对象设置属性信息

�0�2

java会自动的赠送给每一个类一个无参数的构造方法,如果你自己定义了构造方法,java就不赠送给你了

public class Car {

	String color;
	int speed;
	int seat = 5;
	
	//java会自动的赠送给每一个类一个无参数的构造方法
/*
*   public Car() {
* 
*   };
*/
	//如果你自己定义了构造方法,java就不赠送给你了
	//在创建对象的时候,自动调用构造方法
	public Car(String color,int speed) {
		
		this.color = color;
		this.speed = speed;
	}
	public void run() {
		System.out.println(color + "颜色的车在跑" );
		
	}	

	public static void main(String[] args) {
		
		Car c1 = new Car("绿色",120);//默认调用的是构造方法
		//c1.color = "绿色";
		//c1.speed = 120;
		
		
		Car c2 = new Car("红色",160);
		//c2.color = "红色";
		//c2.speed = 160;

        c1.run();
        c2.run();
        
		
	}

}

�0�2

Lesson21(_构造方法的重载)

构造方法也是方法,也可以进行重载

作用:可以有更多的方式去创建对象

�0�2

当几个构造方法里的代码一样的时候,避免重复,可以使用this,来访问其他的构造方法

this( );

习题3(面向对象_练习)

1.用面向对象的思想模拟<<海贼王>>中索隆上阵杀敌的技能:

public class Hero {
	
     String name;
     String skill_q;
     String skill_w;
     String skill_e;
     String skill_r;
	
	public Hero(String name) {
		
		this.name = name;
		
	}
	
	public Hero(String name,String skill_q,String skill_w,String skill_e, String skill_r) {
		
		this(name);//调用当前类中的其他构造方法
		this.skill_q = skill_q;
		this.skill_w = skill_w;
		this.skill_e = skill_e;
		this.skill_r = skill_r;
		System.out.println(this.name = name);
		System.out.println(this.skill_q = skill_q);
		System.out.println(this.skill_w = skill_w);
		System.out.println(this.skill_e = skill_e);
		System.out.println(this.skill_r = skill_r);
	}
	
	public void fight() {
		System.out.println(this.name+"在上阵杀敌!");
	}
	
	public static void main(String[] args) {
		Hero h = new Hero("索隆","鬼斩" ,"龙卷风","一刀流 居合“狮子歌歌”","三刀流奥义.三千世界");
		h.fight();
	}

}
//结果——>
/*索隆
鬼斩
龙卷风
一刀流 居合“狮子歌歌”
三刀流奥义.三千世界
索隆在上阵杀敌!
 */

�0�2

2.用面向对象的思维模拟植物大战僵尸:

(稍微复杂)包含:植物,僵尸,场景(客户端)

不一定所有代码都写在一个类里

�0�2

public class ZhiWu {

	String name;
	int hp;
	int attack;
	
	
	public ZhiWu(String name,int hp,int attack) {
		
		this.name = name;
		this.hp = hp;
		this.attack = attack;
		
	}
	
	//植物打僵尸
	public void fight(JiangShi js) {
		
		System.out.println(this.name + "在打" + js.name);
		//僵尸掉血
		js.hp -= this.attack;
		System.out.println("僵尸的血量剩余" + js.hp);
		
	}
	
}
public class JiangShi {

	String name;
	int hp;
	int attack;
	
    public JiangShi(String name,int hp,int attack) {
		
		this.name = name;
		this.hp = hp;
		this.attack = attack;
		
	}
	
	//僵尸吃植物
		public void eat(ZhiWu zw) {
			
			System.out.println(this.name + "在吃" + zw.name + "植物");
			//植物掉血
			zw.hp -= this.attack;
			System.out.println("植物的血量剩余" + zw.hp);
			
		}
	
}

�0�2

public class Client {

	public static void main(String[] args) {
		//创建植物和僵尸
	ZhiWu zw = new ZhiWu("豌豆",1000,5);	
		
	JiangShi js = new JiangShi("铁桶僵尸",800,20);	
		
	zw.fight(js);
	js.eat(zw);
	
	}
	
}

�0�2

Lesson22(_static静态)

static静态

�0�2

有多人就要改多少次,麻烦!

�0�2

静态的内容在内存中是保留一份的,并且各个对象之间进行共享

使用p1.country = "民国"------>不推荐这样使用静态方法

推荐使用类名去访问静态的内容Person.country = "民国";

特点:

  1. 数据共享
  2. 属于类,并不属于对象
  3. 优先于对象产生

�0�2

(延伸)

java中不太常用的语法:

通用构造器,静态构造器

执行顺序如图:

  1. 静态构造器
  2. 通用构造器
  3. 构造方法 ---> 创建对象

时间轴:

由于创建对象的过程是在静态内容加载完成之后进行的,所以在静态方法和静态块里不能使用this

静态方法优先于(成员)例子:

Lesson23(_包和导包)

包:本质上就是文件夹      在代码中需要写package  包名   例如:package  com.baidu.tieba;

导包:import  包+类      例如:

不需要导包:

  1. 在自己包里
  2. java.long包下的所有内容都不需要导包

String

System.out.println();

Lesson24(_访问权限)

public公共的,所有人都可以访问    (街上的公共厕所)

default包访问权限,在自己包内可以随意访问  (自己小区的停车位,只允许自己小区的车停)

private私有的

Lesson25(_getter和setter)

成员变量一般使用private来声明,保护成员变量不被胡乱赋值

setter主要给成员变量赋值,做一定的保护

getter主要从成员变量中获取数据

此时在TestPerson里无法打印出名字,因为此时Peson里的名字是私有的,那么如何在TestPerson里打印出名字呢??————>用getName

改后为

package com.baidu.tieba;

public class Person {
    private String name;
    private int age;
    
    //setter
    public void setName(String name) {
    	this.name = name;
    }
    
    //有效的保护成员变量不被胡乱赋值
    public void setAge(int age) {
    	if(age < 0 ) {
    		
    		this.age = 0;
    	}
    	else{
    		this.age = age;
    	}
    }
    
    //getter
    public String getName() { 
    	return this.name;
    }
    
    public int getAge() {
    	return this.age;
    }
    
    
    public void chi() {
    	System.out.println(this.name + "在吃东西");
    }

}
package com.baidu.tieba;

public class TestPerson {
public static void main(String[] args) {
	
	Person p = new Person();
//	p.name = "周润发";
//	p.age = -1;//语法没有问题,但是逻辑上有重大问题————>对成员变量进行保护,不让其他人随便访问修改
	
//	p.chi();
	
	p.setName("周润发");
	p.setAge(-1);
	
	System.out.println(p.getName());//是p.getName()有括号
	System.out.println(p.getAge());
}
}
//结果——>周润发

Lesson26(_继承)

继承:子类可以自动拥有父类中除了私有内容以外的其他所有内容

当出现x是一种y的时候,x就可以继承y

public class 类 extends 父类{

}

eg:黑熊怪是一种妖怪

代码:

package com.baidu.tieba;

public class HeiXiongGuai extends YaoGuai{

}
package com.baidu.tieba;

public class YaoGuai {

	private void pasi() {
		System.out.println("妖怪怕死");
	}
	public void chiRen() {
		System.out.println("妖怪吃人");
	}
}
package com.baidu.tieba;

public class Test {
public static void main(String[] args) {
	HeiXiongGuai hx = new HeiXiongGuai();
	hx.chiRen();
	hx.pasi();//会报错,因为私有内容不能被继承
}
}
//结果————>妖怪吃人

继承的作用:简化代码

子类对父类扩展

Lesson27(_super关键字)

super:表示父类中的内容

this:表示子类中的内容

super和this可以区分父类和子类中重名的内容

this.name中name变量查找顺序:先找自己类,自己类没有再找父类

若就是想看到父类中的名字,则写
        System.out.println(super.name);

由上图思考一个问题:在创建SunWuKong对象的时候,之间开辟空间name:孙大圣,那么父类的对象super何时创建的?在哪创建的?

————>创建对象的过程:先创建父类的对象,然后创建子类的对象

子类调用时隐含一个super()构造方法

public class SunWuKong extends Hero {
	
	String name = "孙大圣";
	
	public SunWuKong() {
		super();//还原程序,在子类构造方法的第一行默认调用父类的构造方法
		System.out.println("我是子类的构造方法");
	}
	public void chi(){
		//若就是想看到父类中的名字,则写
		System.out.println(super.name);
		//变量查找顺序:先找自己类,自己类没有再找父类
		System.out.println(this.name + "在吃桃子");
	}

public static void main(String[] args) {
	SunWuKong s = new SunWuKong();//创建对象的时候自动调用构造方法(该构造方法无参数,一直存在)
	s.chi();
}
}
/*结果——>
我是父类的构造方法
我是子类的构造方法
英雄
孙大圣在吃桃子
*/

总结:

  1. super可以获取到父类中的内容
  2. 可以调用父类中的构造方法,必须写在子类构造方法的第一行,如果父类的构造方法是无参的,可以不写(程序默认调用super();),如果父类有参数的构造,必须要写super(参数...);

Lesson28(_方法的重写)

重写:子类对父类中提供的方法进行重新定义

语法:子类和父类中方法的声明完全一致

重写又被称为方法的覆盖

下面开始方法的重写:

重写又被称为方法的覆盖

注意:重写时子类的方法必须和父类的方法完全一致

public class LiYuan {
		
	public void makeCountry() {
		
		System.out.println("李渊想建立自己的国家!!");
	}
	
}
public class LiShiMin extends LiYuan {
	
public void makeCountry() {
	    //半盖(半覆盖)
		super.makeCountry();//super可以在子类中调用父类中被重写的方法
		System.out.println("李世民也想建立自己的国家!!");
	}
	
public static void main(String[] args) {
	LiShiMin lsm = new LiShiMin();
	lsm.makeCountry();
}
}
/*李渊想建立自己的国家!!
 * 李世民也想建立自己的国家!!
 */

Lesson29(_多态)

多态:同一个对象拥有多种形态

多态作用:把不同的数据对象进行统一

小知识点:

  1. 把子类的对象赋值给父类的引用——>向上转型

缺点:会屏蔽掉子类特有的方法

    2. 把父类的对象赋值给子类的引用——>向下转型

缺点:可能有风险,java要求必须要写强制类型转换

(转换之后的数据类型)  变量

例如

自己心得:当使用多态表达类似重复实施行为时,向上转型;结合向下转型,再把屏蔽掉的特殊内容表达出来

Lesson30(_final关键字)

1.final修饰的变量不可以被改变

2.被final修饰的方法不可以被重写

3.被final修饰的类不可以被继承

1.final修饰的变量不可以被改变,如:

2.被final修饰的方法不可以被重写,如:

final总结:

被final修饰意味着不可变

Lesson31(_抽象)

抽象.

现实中的抽象:现实中不存在,想象不到的东西,比如抽象画作,让人联想不到事物,不易描述。

Java中的抽象:不容易描述的事情,比如定义一个动物的类,想描述动物吃东西,那么描述“吃素”好呢?还是“吃肉”好呢?不易描述。

抽象方法:使用abstract修饰,不可以有方法体,直接用分号 “ ;”结束即可

抽象类:如果一个类中有抽象方法,这个类必须是抽象类

特点

  1. 抽象类不可以创建对象
  2. 抽象类的子类必须重写父类中的抽象方法,否则子类必须也是抽象类

抽象类的子类必须重写父类中的抽象方法,否则子类必须也是抽象类,解释如下:

知识点:

  1. 通过抽象类可以强制地要求子类中必须有哪些方法
  2. 抽象类是用来被子类继承的
  3. 抽象类中可以有正常的方法

那么可能你会问了,抽象类不能创建对象,没有可以被执行的方法体,那抽象类有什么存在的意义呢?

——>抽象类存在的意义就是被子类继承,否则抽象类则毫无意义(基本准则),

体现了模板思想,部分实现,部分抽象

Lesson32(_接口)

接口.

  1. 接口实际上是一种特殊的抽象类
  2. 接口中所有的方法都是抽象方法(和抽象类对比记忆理解)
  3. 接口使用interface来声明

接口和类的作用区别:

类只能单继承,接口支持多实现

/*
 * 能继承接口的只能是接口
 * 接口和类之间是实现关系 ——> implements
 */
public interface Valuable {//接口使用interface来声明,已经不再是类了,只是和类很像,仅仅把class换成interface而已
	
    //接口中所有的方法都是抽象方法,所以可以省略abstract
	//接口中所有的方法都是公开的,公共的
	//即:下面这条语句可以直接省略掉public abstract,写成void getMoney();
	//public abstract void getMoney();//接口中所有的方法都是抽象方法,不可以有正常的方法
	
	void getMoney();
	
}
public interface Protectable {

	public void cang();
	
}
public class Animal {

	public void eat() {
		System.out.println("动物会吃");
	}
	
}
//类可以继承一个类,实现多个接口
public class Panda extends Animal implements Valuable,Protectable {

	@Override //——>重写(Alt+/)
	public void eat() {
		System.out.println("熊猫吃竹子");
	}
	
	
	@Override
	public void cang() {
		System.out.println("把熊猫藏山里");
		
	}
	
	
	@Override
	public void getMoney() {
		System.out.println("熊猫可以换钱");
		
	}
}
public class Test {
	public static void main(String[] args) {
		Panda p =new Panda();
		Animal ani = new Panda();//向上转型
		Valuable v = new Panda();//向上转型
		Protectable pro = new Panda();//向上转型
		
		p.eat();
		p.cang();
		p.getMoney();
		
		ani.eat();
		//ani.cang();//程序会报错,因为站在动物的角度只能吃
		//ani.getMoney();//也不行
		
		v.getMoney();
		
		pro.cang();
		
	}
}

接口具有多态性

接口可以把很多不相关的内容进行整合

(比如熊猫Panda和金子Gold都可以统一为值钱的东西Valuable)

(接口可以类似于插线板,电脑插头和手机插头都可以插在上面)

接口的特点:

  1. 接口中所有的方法都是抽象方法。都是公开的
  2. 接口中所有的变量都是全局静态变量(了解即可,解释如下图)

习题4(面向对象_练习2)

稍后更新

Lesson33(_成员变量初始值)

java中所有的变量,必须先声明后赋值才能使用

java中的成员变量,在创建对象的时候,都会给一次初始化的操作,都会给一个默认值。

基本数据类型默认值都是0,包括boolean类型——>false

引用数据类型,都是null(表示 空,什么都没有,仅仅是 占位)

总结:

  1. java中所有的变量,必须先声明后赋值才能使
  2. java中的成员变量,在创建对象的时候,都会给一次初始化的操作,都会给一个默认值。
  3. 基本数据类型默认值都是0,包括boolean类型——>fals;而引用数据类型,都是null(表示 空,什么都没有,仅仅是 占位)

Lesson34(_object)

  1. 在java中,万事万物,所有的东西皆是对象
  2. 在java中所有的类都要继承object
  3. object是一个类,是所有类的根
  4. 我们所写的类,即使不写继承关系,也会默认继承object

那么如果自己写一个方法来继承,是不是和object没关系了?

Lesson35(_equals和==)

==判断左右两端的数据是否相等

equals:object类提供的一个方法,用来判断左右两个对象是否相等(?????可判断的包括很多东西)

注意:

==默认判断的是两个对象的内存地址是否相同(不常用)

==一般用于两个对象数据做判断,很少用来判断两个对象(常用)

下图为图1

注意:

默认情况下,equals和==是一个意思,只不过,equals可以重写

public class Cat  {
	String name;
	String color;
	
	public Cat(String name,String color) {
		this.name = name;
		this.color = color;
	}
	
   public static void main(String[] args) {
	   
	Cat c1 = new Cat("小花","白色");
	Cat c2 = new Cat("小花","白色");
	
	System.out.println(c1 == c2);//false
	System.out.println(c1.equals(c2));
	//——>false  调用c1的equals方法,而equals方法是继承的object类
	//本质上都是默认判断地址是否一样
	
}
}

equals和==本质上都是默认判断地址是否一样——>        当我们不满意equals方法时  (只想判断两只猫是不是名字颜色一样,不判断是不是同一只猫)  ,可以重写equals方法

public class Cat  {
	String name;
	String color;
	
	public Cat(String name,String color) {
		this.name = name;
		this.color = color;
	}
	
	public boolean equals(Cat c) {//单纯的自己去写判断逻辑
		if(this.color == c.color) {
			return true;
		}
		else {
			return false;
		}
	}
	
	
   public static void main(String[] args) {
	   
	Cat c1 = new Cat("小花","白色");
	Cat c2 = new Cat("小花","白色");
	
	System.out.println(c1.equals(c2));
	//——>false  调用c1的equals方法,而equals方法是继承的object类
	//本质上都是默认判断地址是否一样——>当我们不满意equals方法时(只想判断两只猫是不是名字颜色一样,不判断是不是同一只猫),可以重写equals方法

}
}

对比图1

注意:

在java中,一般情况下,equals和==默认判断地址是否一样,但是字符串除外,因为java中规定字符串如果内容相同,则共用一块内存,这块内存有多人共用,不会单独分配内存,如下图:

注意:字符串的判断一定要用equals判断,因为equals可以判断内容是否相等

String str1 = new String("路飞");一句话中创建了两个对象,路飞是一个创建的字符串对象,new String创建一个内存,然后给str1;而String str2 = new String("路飞");中在上一次创建了字符串对象路飞后不再创建,但是需要单独开辟内存空间,如下图所示(注意和注释程序的对比理解):

小练习:模拟用户登录界面

import java.util.Scanner;

public class Test {
	
 public static void main(String[] args){
        String username = "admine";
        String userword = "123";
        
        Scanner sc = new Scanner(System.in);
        
        System.out.println("请输入账户名:");
        
        String upname = sc.nextLine();
        
        System.out.println("请输入密码:");
        
        String upword = sc.nextLine();
        
        //判断用户名和密码是否Ok
        if(username.equals(upname) && userword.equals(upword))
        {
        	System.out.println("登陆成功");
        }
        else {
        	System.out.println("登陆失败");
        }
	}
}

小总结:

  1. ==判断左右两端的数据是否相等
  2. equals:object类提供的一个方法,用来判断左右两个对象是否相等(?????可判断的包括很多东西)
  3. ==默认判断的是两个对象的内存地址是否相同(不常用),==一般用于两个对象数据做判断,很少用来判断两个对象(常用)
  4. equals和==本质上都是默认判断地址是否一样,只不过,equals可以重写, 当我们不满意equals方法时  (只想判断两只猫是不是名字颜色一样,不判断是不是同一只猫)  ,可以重写equals方法
  5. 在java中,一般情况下,equals和==默认判断地址是否一样,但是字符串除外,因为java中规定字符串如果内容相同,则共用一块内存
  6. 字符串的判断一定要用equals判断,因为equals可以判断内容是否相等。

Lesson36(_toString)

toString对一个字符串的表示

java官方推荐重写toString方法,因为原来的太丑了(包+类@内存地址)却不符合自己预期

想打印猫的信息,却出来这一串,则我们对Cat继承的object类不满意,需要重写:

package com.baidu.wangpan;

public class Cat {//类默认继承object
	
	String name;
	String color;
	
	public Cat(String name,String color) {
		this.name = name;
		this.color = color;
	}
	
	//子类对父类提供的方法不满意,需要重写
	@Override
		public String toString() {
			// TODO Auto-generated method stub
			return "我的猫叫" + this.name + "颜色是" + this.color;
		}
	
	
	public static void main(String[] args) {
		Cat c = new Cat("小花","白色");
			
		//直接打印c
		System.out.println(c);
		//默认打印对象,自动执行这个对象中的toString()方法
		System.out.println(c.toString());//toString()方法在object类里
		//默认的toString——> 包+类@内存地址
	}	
}

Lesson37(_instanceof关键字)

图片我们可以很容易地区分猫猫和狗狗,但是在java程序中怎么区分呢?(对比下列程序)

总结:instanceof判断xxxx是不是xxx类型的

Lesson38(_内存分析)

1.堆:主要存放对象

2.栈:局部变量.以及基本数据类型的变量

3.代码区:类和方法

4.数据区:常量池和静态变量

String str1 = "小花";

String str2 = "小花";

小花存放在常量池里,缓存—>不重复建立

图示:emmm......手写板后续补上

学到这很棒啦!!记得回顾总结Lesson16~38面向对象章节哟

Lesson39(_异常简介)

异常就是错误对象

包括编译时异常和运行时异常

Lesson40(_异常的分类)

异常的分类:

1.RuntimeExpection:运行时异常.一般不手动处理,出了问题再处理。

2.其他Expection:必须要经过手动处理才能运行。

3.Error:系统级异常(内存不够,溢出...)

类比(写程序 == 开车上山)

1.RuntimeExpection:上山路上有数不清的小石子,我们不可能把山上的石子都清理掉,啥时候把车胎扎爆了,啥时候处理。

2.其他Expection:上山路有路障,必须移走路障才能往上上山。

3.Error:上山途中,山塌了emm.....

Lesson41(_异常处理_try...catch)

尝试,执行,并捕获

try{

      尝试执行的代码

}catch(Expection e){

     处理异常的代码

}finally{

     最终的

}

解释:try{   }里放要运行的代码,如果有错误用catch捕获,并且最终执行finally;如果没错,就跳过catch,直接执行最终的finall

Lesson42(_异常处理_throws和throw)

抛异常:抛给自己的上一级

throws表示方法要准备抛出一个异常了

throw 表示向外抛出异常

(注意写法)

Lesson43(_自定义异常)

因为java提供的异常不够用,所以才有自定义异常

自定义的异常直接继承Exception或RuntimeException

public class Person {
    String name;
    String gender;
    
    public Person(String name,String gender) {
		this.name = name;
		this.gender = gender;
	}		
}
public class ZaoTangZi {

	public void man(Person p) throws GenderException {
		if(p.gender.equals("男")) {
			System.out.println("欢迎光临");
		}else {
			//需要抛出一个异常
			//throw new Exception();
			//这样写又不直观,不明白如何异常了,此时就需要我们自己定义一个异常
			//——>来了个女的
		    throw new GenderException("性别不对,这里是男澡堂子");
			
		}
	}
}
public class GenderException extends Exception {//自定义的异常必须继承Exception或RuntimeException
	
public GenderException(String msg) {
	super(msg);//调用父类的构造方法,Exception(msg);
	
}
}
public class Test {

	public static void main(String[] args) throws GenderException  {
		Person p1 = new Person("路飞","男");
		Person p2 = new Person("娜美","女");
		
		ZaoTangZi ztj = new ZaoTangZi();
		//ztj.man(p1);报错,因为此时程序需要异常处理,则需要在public static void main(String[] args)后面加上throws GenderException
		ztj.man(p2);
	}
}

Lesson44(_容器的概念)

容器:能装对象的对象

(生活中例如自己的书包,能装很多东西)

1.List集合  线性结构   可变长度

2.Set集合    非线性  去除重复

3.Map 映射    存储的时候,以key—value的形式存储数据,例如:名字—电话

在java中,所有集合的根:collection接口

Lesson45(_List)

1.ArrayList

2.LinkedList

List集合特点:数据可以重复

共同点:1.都是线性的,都可以根据下标索引数据

               2.数据是允许重复的

区别:

ArrayList类似于数组,数据的内存之间是连续的,只不过区别于数组的是ArrayList可以无限扩容

LinkedList和ArrayList用法差不多,不过数据的内存是有区别的,数据的内存之间可以不连续。一块区域自动化分成两部分,前一部分放数据,后一部分放下一个数据的指针

在容器应用中,ArratList应用的比较多,查寻效率比较高,而LinkedList需要从起始位置开始查询,浪费大量时间

然而,在删除节点,插入节点的时候,LinkedList应用比较多,只需要更改每个内存中指针数据的指向即可。

其实我们在实际代码应用中不会做出太多区分,只是内存分析上有差别,用法上差别不大,而在容器应用中,我们主要是往里放东西,所以删除不常用,主要应用ArrayList

对List常用的操作(增删改查)

add();//添加数据
remove();//删除数据
set(index,value);//修改数据
size();//列表的大小(例表中装了多少个元素)
get(index);//从列表中获取到index位数据
contains();//判断容器中是否有xxx东西

对List遍历操作

首先想想数组如何遍历

for(i = 0;i < arr.length;i++){
   System.out.println(arr[i]);
}

List遍历和数组遍历同理

for(i = 0;i < list.size();i++){

System.out.println(list.get(i));

}

好,那么我们来看看上述具体代码的实现过程:

import java.util.ArrayList;
import java.util.List;

public class TestList {
public static void main(String[] args) {
	List list = new ArrayList();
	
	//添加元素
	list.add("福满多");
	list.add("魔法士");
	list.add("康师傅");
	list.add("汤达人");
	
	System.out.println(list);//——>结果:[福满多, 魔法士, 康师傅, 汤达人]
	
	//删除元素
	list.remove("汤达人");
	System.out.println(list);//——>结果:[福满多, 魔法士, 康师傅]
	
//获取到某一位数据
//想拿一个变量接,则代码如下
//	Object obj = list.get(1);//不管获取的元素是数字还是字符串或其他,统一用Object类来接收
//	String s = (String) obj;//从Object——>String,向下转型,需要强转
//  System.out.println(s);//——>结果:魔法士
	
	
//	或者
//	String s = (String) list.get(1);
//	System.out.println(s);
	
	
	
	//获取到某一位数据
    //不想用变量接,也可以写成如下代码,更简洁,提倡!!!!
	System.out.println(list.get(1));//——>结果:魔法士
    
    
	//查看容器里是否有某一数据
	System.out.println(list.contains("康师傅"));//——>结果:true
	
	
	
	//List遍历
	//想用变量来接,代码如下
//		for(int i = 0;i < list.size();i++)
//		{
//			String s = (String) list.get(i);
//			System.out.print(list.get(i));//——>结果:福满多魔法士康师傅
//		}

	
	
	//List遍历
	//不想用变量来接,代码如下,更简洁,提倡!!!!
	for(int i = 0;i < list.size();i++)
	{
		System.out.println(list.get(i));//——>结果:福满多魔法士康师傅
	}
	
	//修改元素
	list.set(1, "趣多多");
	System.out.println(list);//结果:[福满多, 趣多多, 康师傅]
}
}

Lesson46(_Set)

1.HashSet      无序.乱的.不重复的

2.TreeSet       默认排序.不重复的

Set集合特点:数据是不重复的

共同点:1.都是非线性的,不能通过下标索引检索数据,即:没有get(i);操作

              2.数据都是不重复的

区别:HashSet是无序的

           TreeSet是默认排序的

对Set常用的操作

add();//添加数据
remove();//删除数据
size();//列表的大小(例表中装了多少个元素)
contains();//判断容器中是否有xxx东西

注意:没有get(i);操作

代码解释:HashSet是无序的,数据是不重复的

import java.util.HashSet;
import java.util.Set;

public class TestList {
public static void main(String[] args) {
	Set s = new HashSet();
	
	s.add("洛克王国");
	s.add("全民狙击");
	s.add("赛尔号");
	s.add("摩尔庄园");
	
	s.add("洛克王国");
	System.out.println(s);//结果——>[赛尔号, 洛克王国, 全民狙击, 摩尔庄园]

}
}

代码解释:TreeSet是默认排序的(与HashSet对比)

import java.util.HashSet;
import java.util.Set;

public class TestList {
public static void main(String[] args) {
	Set s = new HashSet();
	
	s.add(12);
	s.add(166);
	s.add(286);
	s.add(2);
	
	s.add(8);
	System.out.println(s);//结果——>[2, 166, 8, 12, 286]
}
}
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class TestList {
public static void main(String[] args) {
	Set s = new TreeSet();
	
	s.add(12);
	s.add(166);
	s.add(286);
	s.add(2);
	
	s.add(8);
	System.out.println(s);//结果——>[2, 8, 12, 166, 286]
}
}

好,那么我们来看看上述具体代码的实现过程:

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class TestList {
public static void main(String[] args) {
	Set s = new HashSet();
	
	s.add(12);
	s.add(166);
	s.add(286);
	s.add(2);
	
	s.add(8);
	System.out.println(s);
	
	//打印数据长度
	System.out.println(s.size());
	
	//删除数据
	s.remove(166);
	System.out.println(s);
	
	//查看是否包含某数据
	System.out.println(s.contains(8));
	
//结果:
//	[2, 166, 8, 12, 286]
//	5
//	[2, 8, 12, 286]
//	true

}
}

其实在代码中Set集合用的不多,要是用主要用HashSet

Lesson47(_Map)

名字—>电话

key —> value     (键-值对)

1.HashMap   不排序

2.TreeMap    排序

对Map的操作

put(key,value);//存储数据
remove(key);//删除数据
size();//Map存储了多少个键-值对
get();//查看key对应的value
containsKey();//查看数据是否包含  xxxx key这一项
containsValue();//查看数据是否包含  xxxx value这一项
keySet();//把Map中所有的键打包成set集合返回

注意:在Map集合中contains被分成两份,containsKey();和containsValue();

代码解释HashMap应用

import java.util.HashMap;
import java.util.Map;

public class TestList {
public static void main(String[] args) {
	Map map = new HashMap();

	map.put("jay","周杰伦");
	map.put("wf","汪峰");
	map.put("JJ","林俊杰");
	map.put("vae","许嵩");
	map.put("tz","陶喆");
    
	System.out.println(map);//结果:------->  {JJ=林俊杰, jay=周杰伦, tz=陶喆, vae=许嵩, wf=汪峰}
	
}
}

代码解释HashMap不排序

import java.util.HashMap;
import java.util.Map;

public class TestList {
public static void main(String[] args) {
	Map map = new HashMap();

	map.put(33,"周杰伦");
	map.put(22,"汪峰");
	map.put(66,"林俊杰");
	map.put(55,"许嵩");
	map.put(88,"陶喆");
    
	System.out.println(map);//结果:------->  {33=周杰伦, 66=林俊杰, 22=汪峰, 55=许嵩, 88=陶喆}
	
}
}

代码解释TreeMap排序(与HashMap对比)

import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;

public class TestList {
public static void main(String[] args) {
	Map map = new TreeMap();

	map.put(33,"周杰伦");
	map.put(22,"汪峰");
	map.put(66,"林俊杰");
	map.put(55,"许嵩");
	map.put(88,"陶喆");
    
	System.out.println(map);//结果:------->  {22=汪峰, 33=周杰伦, 55=许嵩, 66=林俊杰, 88=陶喆}

	
}
}

注意:TreeMap排序根据  key  来排序

好,那么我们来看看上述具体代码的实现过程:

import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;

public class TestList {
public static void main(String[] args) {
	Map map = new TreeMap();

	map.put(33,"周杰伦");
	map.put(22,"汪峰");
	map.put(66,"林俊杰");
	map.put(55,"许嵩");
	map.put(88,"陶喆");
    
	System.out.println(map);//结果:------->  {22=汪峰, 33=周杰伦, 55=许嵩, 66=林俊杰, 88=陶喆}

	//查看数据长度
	System.out.println(map.size());//结果:5
	
	
	//删除键对应的数据
	map.remove(88);
	System.out.println(map);//结果:{22=汪峰, 33=周杰伦, 55=许嵩, 66=林俊杰}
	
	
	//查看键key对应的值value
	System.out.println(map.get(55));//结果:许嵩
	
	
	//查看是否包含xxx键的数据
	System.out.println(map.containsKey(44));//结果:flase
	System.out.println(map.containsValue("周杰伦"));//结果:true
	
	
	//keySet把Map中所有的键打包成set集合返回
	System.out.println(map.keySet());//结果:[22, 33, 55, 66]

}
}

还有一点需要注意:如果出现相同的key,原来的数据会被顶掉,实例代码如下:

import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;

public class TestList {
public static void main(String[] args) {
	Map map = new TreeMap();

	map.put(33,"周杰伦");
	map.put(22,"汪峰");
	map.put(66,"林俊杰");
	map.put(55,"许嵩");
	map.put(88,"陶喆");
    
	map.put(33,"哎哟,不错呦!");
	System.out.println(map);//结果 :  --------> {22=汪峰, 33=哎哟,不错呦!, 55=许嵩, 66=林俊杰, 88=陶喆}
}
}

练习1(容器)

开发敏感词语过滤程序,提示用户输入评论内容,如果用户输入的内容中包含特殊的文字信息,则将用户输入的内容中的敏感词替换成等长度的*(苍老师就替换成***),如果用户输入的内容没有敏感词,则直接打印即可。

//敏感词如下
List li = new ArraryList();
li.add("武藤应");
li.add("波多野结衣");
li.add("仓木麻衣");
li.add("麻生希");

那么我们先抛去考虑用几个“*”代替含有敏感词,只考虑用固定的“*”代替敏感词的情况,后续再把“*”循环即可

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class TestList {
public static void main(String[] args) {
	//敏感词
	List li = new ArrayList();
	li.add("武藤应");
	li.add("波多野结衣");
	li.add("仓木麻衣");
	li.add("麻生希");
	
	//用户输入内容
	Scanner sc = new Scanner(System.in);
	System.out.println("请输入评论内容:");
	String content = sc.nextLine();

	for(int i = 0;i < li.size();i++) {
		String ci = (String) li.get(i);//强转,拿到敏感词
		if(content.contains(ci)) {//判断是否含有敏感词
			content = content.replace(ci, "****");
		}
	}
	System.out.println(content);
	//结果:请输入评论内容:
    //麻生希,你就是欺负我胖虎老实~
    //****,你就是欺负我胖虎老实~

}
}

是的,现在敏感词已经被“*”代替,那么如何用“*”个数代替敏感词个数呢?

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class TestList {
public static void main(String[] args) {
	//敏感词
	List li = new ArrayList();
	li.add("武藤应");
	li.add("波多野结衣");
	li.add("仓木麻衣");
	li.add("麻生希");
	
	//用户输入内容
	Scanner sc = new Scanner(System.in);
	System.out.println("请输入评论内容:");
	String content = sc.nextLine();

	for(int i = 0;i < li.size();i++) {
		String ci = (String) li.get(i);//强转,拿到敏感词
		if(content.contains(ci)) {//判断是否含有敏感词
			
			//字符串的拼接
			String s = "";
			for(int j = 0;j < ci.length();j++) {
				s += "*";
			}
			
			//替换敏感词
			content = content.replace(ci, s);
		}
	}
	System.out.println(content);
	//结果:请输入评论内容:
	//麻生希,你就是欺负我胖虎老实,我只喜欢小夫,你和波多野结衣就别来找我了~
	//***,你就是欺负我胖虎老实,我只喜欢小夫,你和*****就别来找我了~

}
}

Lesson48(_迭代器Iterator)

首先我们来思考一段代码:

import java.util.ArrayList;
import java.util.List;

public class Test {
	public static void main(String[] args) {
		List list = new ArrayList();
		
		list.add("路飞");
		list.add("索隆");
		list.add("山治");
		list.add("乌索普");
		list.add("布鲁克");
		
		System.out.println(list);
		
		for(int i = 0;i < list.size() ;i++) {
			String s = (String) list.get(i);
			System.out.println(s);
			
		}
	}
	
}
/*结果:
 * [路飞, 索隆, 山治, 乌索普, 布鲁克]
 * 路飞
 * 索隆
 * 山治
 * 乌索普
 * 布鲁克
 * 
 */

那么我们来思考,在ArrayList集合中,有get(i)通过下标来获取数据,那么在Set集合中,Set集合是非线性的,不能通过下标索引检索数据,该如何来遍历获取数据呢?

————————————>这时候就出来一种新的方式:迭代器

迭代器:一个一个的往外拿

核心:只会喊下一个

类比想象:在以往医生看病,一个进去一个出来,出去以后医生会喊下一个,医生不需要管下一个是谁,只管喊下一个,就行了

我们的迭代器就是这个意思,他会在Set集合里通过喊“下一个”的方式来遍历获取数据

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test {
	public static void main(String[] args) {
		List list = new ArrayList();
		
		list.add("路飞");
		list.add("索隆");
		list.add("山治");
		list.add("乌索普");
		list.add("布鲁克");
		
		//创建一个迭代器,(创建一个医生)
		Iterator it = list.iterator();
		
		String s0 = (String) it.next();//第一个
		System.out.println(s0);
		
		String s1 = (String) it.next();//下一个
		System.out.println(s1);
		
		String s2 = (String) it.next();//下一个
		System.out.println(s2);
		
		String s3 = (String) it.next();//下一个
		System.out.println(s3);
		
		String s4 = (String) it.next();//下一个
		System.out.println(s4);
		
//		String s5 = (String) it.next();//没有元素了,再叫下一个,没人了,会报错.
//		System.out.println(s5);
	}
	
}
/*结果:
 * 路飞
 * 索隆
 * 山治
 * 乌索普
 * 布鲁克
 * 
 */

注意:

医生只管喊下一个就够了,但是如果没人了,还继续喊,就会报错,这个时候医生继续喊( next(); )没人应就会很生气,怎么办呢?—————>这个时候有一种新的方法 hasNext();

Set集合中,有两种方法获取下一个数据

1.next();    不管有没有人,只管喊下一个

2.hasNext();   喊下一个之前在门口望望还有没有人,判断是否还有下一个

代码改进为

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test {
	public static void main(String[] args) {
		List list = new ArrayList();
		
		list.add("路飞");
		list.add("索隆");
		list.add("山治");
		list.add("乌索普");
		list.add("布鲁克");
		
		//创建一个迭代器,(创建一个医生)
		Iterator it = list.iterator();
		
		while(it.hasNext()) {//在门口看看还有没有下一个人
			String s = (String) it.next();
			System.out.println(s);
		}
	}
	
}
/*结果:
 * 路飞
 * 索隆
 * 山治
 * 乌索普
 * 布鲁克
 * 
 */

上述阐述,表明List集合适用于迭代器,那么Set集合,Map集合呢?也同样适用吗?

是的,我们就是由Set集合不知道如何获取数据才引出来迭代器Iterator的,那Set集合当然适用,不信你看下面代码:

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class Test {
	public static void main(String[] args) {
		
	Set set = new HashSet();
	set.add("路飞");
	set.add("索隆");
	set.add("山治");
	set.add("乌索普");
	set.add("布鲁克");
	
	Iterator it = set.iterator();
	
	while(it.hasNext()) {
		System.out.println(it.next());
	}
	
	}
	
}
/*结果:
 * 
 *山治
 *布鲁克
 *索隆
 *乌索普
 *路飞
 * 
 */

是的,Set集合适用迭代器Iterator,那么Map集合呢?请看下列代码:

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Test {
	public static void main(String[] args) {
	Map map = new HashMap();
	map.put("船长","路飞");
	map.put("剑士","索隆");
	map.put("厨师","山治");
	map.put("狙击王","乌索普");
	map.put("音乐家","布鲁克");
	
	System.out.println(map);
	//那么下面怎么调取数据呢?
	//我们想到了,键值对,可以通过key找到value
	
	Set set = map.keySet();//拿到所有的键key
	Iterator it = set.iterator();//拿到迭代器
	
	while(it.hasNext()) {
		String key = (String) it.next();//所有的key
		System.out.println(map.get(key));//通过key获取到value
	}
	}
	
}
/*
 * 结果:
 *{剑士=索隆, 狙击王=乌索普, 船长=路飞, 厨师=山治, 音乐家=布鲁克}
 *索隆
 *乌索普
 *路飞
 *山治
 *布鲁克
 *
 */

Lesson49(_泛型)

首先我们来想一个问题,我们家的碗,里面可以装东西,我们有盐有糖,咋办?都一股脑地放碗里吗?

肯定不是,我们会规定哪个碗固定放哪个佐料,这样才好取用,是的,这就引出了泛型

泛型

作用:规定容器内的数据类型

语法:容器<数据类型>                  类似于:碗<盐>

参考如下代码:

import java.util.ArrayList;
import java.util.List;

public class Test {
	public static void main(String[] args) {
    List<String> strlist = new ArrayList<String>();
    
    strlist.add("路飞");
    strlist.add("索隆");
    strlist.add("乌索普");
    strlist.add("山治");
    
    //strlist.add(123);//会报错,因为添加123的不是指定类型String型
    
    String s = strlist.get(1);//省略了强转
	System.out.println(s);//结果:索隆	
	}
}

当然,除了可以装特定的数据类型以外,还可以装特定的类,如下代码:

//Singer类
public class Singer {

	private int id;
	private String name;
	private double salary;
	private String song;
	
	public Singer(int id,String name,double salary,String song) {
		this.id = id;
		this.name = name;
		this.salary = salary;
		this.song = song;
		
	}
	
	public int getId() {
		
		return id;
	}
	
	public void setId(int id) {
		this.id = id;
	}
	
	public String getName() {
		
		return name;
	}
	
	public void setNmae(String name) {
		this.name = name;
	}
	
    public double getSalary() {
		
		return salary;
	}
	
    public void setSalary(double salary) {
		this.salary = salary;
	}
    
    public String getSong() {
		
		return song;
	} 
    
    public void setSong(String song) {
		this.song = song;
	}
}
//装特定的类Singer
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test {
	public static void main(String[] args) {
    List<Singer> list = new ArrayList<Singer>();
    
    list.add(new Singer(1,"许嵩",6.66,"《灰色头像》"));
    list.add(new Singer(2,"周杰伦",5.55,"《告白气球》"));
    list.add(new Singer(3,"徐良",4.44,"《后会无期》"));
    list.add(new Singer(4,"汪苏泷",3.33,"《那个男孩》"));
    
    Iterator<Singer> it = list.iterator();
    while(it.hasNext()) {
    	Singer s = it.next();
    	System.out.println(s.getName());
    	System.out.println(s.getSong());
    }
	}
}
/*结果:
 * 
 * 许嵩
 *《灰色头像》
 *周杰伦
 *《告白气球》
 *徐良
 *《后会无期》
 *汪苏泷
 *《那个男孩》
 * 
 */

是的,对于泛型的规范,List集合这样写List< >,Set集合也是如此Set< >,但是Map集合就有区别了,Map

//map————>  键值对,通过ket找到value
import java.util.HashMap;
import java.util.Map;
public class Test {
	public static void main(String[] args) {
    Map<String,String> map = new HashMap<String,String>();
    
    map.put("许嵩","《灰色头像》");
    map.put("徐良","《后会无期》");
    map.put("周杰伦","《告白气球》");
    map.put("汪苏泷","《那个男孩》");
    
    //map.put("周华健", 123);//会报错,不允许输入不是字符串的内容
    
    String s = map.get("许嵩");
    System.out.println(s);//结果:《灰色头像》
    
	}
}

Lesson50(_增强for)

首先我们来看一段实现数组遍历的代码

public class Test {
	public static void main(String[] args) {
    
		String []arr = {"hello","你好","萨瓦迪卡","哦哈哟"};
		for(int i = 0;i < arr.length;i++) {
			System.out.println(arr[i]);
		}
	
	}
}

是的,这种for循环的确可以实现数组的遍历 ,需要每次固定的输入for(  ; ; )内容,遍历也需要arr[ ]这样写,显得很繁琐麻烦,由此我们引出了增强for

增强for语法

for(类型 变量: 数组名或集合) {
            循环体
        }

改进上述代码

public class Test {
	public static void main(String[] args) {
    
//		String []arr = {"hello","你好","萨瓦迪卡","哦哈哟"};
//		for(int i = 0;i < arr.length;i++) {
//			System.out.println(arr[i]);
//		}
	
		//改进后
		String []arr = {"hello","你好","萨瓦迪卡","哦哈哟"};
		for(String s: arr) {
			System.out.println(s);
		}
	}
}
//

那么后面接集合的怎么写呢?

import java.util.ArrayList;
import java.util.List;

public class Test {
	public static void main(String[] args) {
    
		List list = new ArrayList();
		list.add(123);
		list.add(234);
		list.add(345);
		list.add(456);

		for(Object obj:list) {
			System.out.println(obj);
		}
	}
}

代码解释:由于我们没有指定装特定的数据,所以增强for里的数据类型用Object定义

当然,代码还可以再进行修改

import java.util.ArrayList;
import java.util.List;

public class Test {
	public static void main(String[] args) {
    
		List<Integer> list = new ArrayList<Integer>();
		list.add(123);
		list.add(234);
		list.add(345);
		list.add(456);

		for(Integer s:list) {
			System.out.println(s);
		}
	}
}

代码解释:由于我们看了输入的数据都是整型,所以我们完全可以定义它的类型是Integer,然后修改代码

总结:增强for

优点:循环的时候代码看起来更简洁

缺点:看不到拿的数据的索引

Lesson51(_Collections工具类)

Collections是一个类,里面有各种各样的工具,常用的有:

Collections.min(list);//求列表的最小值
Collections.max(list);//求列表的最大值
Collections.sort(list);//对列表排序
Collections.shuffle(list);//打乱列表顺序
Collections.addAll(list,数据......);//为列表添加数据

下面看代码的具体应用:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Test {
	public static void main(String[] args) {
    
		List<Integer> list = new ArrayList<Integer>();
		list.add(123);
		list.add(222);
		list.add(333);
		list.add(666);

		Integer min = Collections.min(list);
		System.out.println(min);
		
		Integer max = Collections.max(list);
		System.out.println(max);
		
		Collections.sort(list);//对列表进行排序 :[123, 222, 333, 666]
		System.out.println(list);
		
		Collections.shuffle(list);//打乱列表顺序————结果:每次都不一样
		System.out.println(list);
		
		Collections.addAll(list, 555,888,999,898);//Collections.addAll(列表名, 数据......);
		System.out.println(list);//结果:[666, 333, 222, 123, 555, 888, 999, 898]

	}
}

Collections.addAll(list, 555,888,999,898);//Collections.addAll(列表名, 数据......);
System.out.println(list);//结果:[666, 333, 222, 123, 555, 888, 999, 898]

通过这个代码,我们普及一个知识——>传入不定参数的方法

public class Test {
	
	 public static void chi(String...args) {
	    	for(String s:args) {
	    		System.out.println(s);
	    	}
	    }
	 
	public static void main(String[] args) {
		
    		chi("黄瓜","木瓜","甜瓜","菜瓜");	
	}
}

JAVA基础学到这基本上完成,后续此内容需要补充的会不定时滚动补充,也欢迎各位大佬留言指正。

下面开始进阶课程...

评论 19 您还未登录,请先 登录 后发表或查看评论
©️2022 CSDN 皮肤主题:大白 设计师:CSDN官方博客 返回首页

打赏作者

再吃一个橘子

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值