学习java的基础总结

最新推荐文章于 2024-01-20 20:24:51 发布

wangshuo（24考研上岸版）

最新推荐文章于 2024-01-20 20:24:51 发布

阅读量1.3k

点赞数

文章标签： java

本文链接：https://blog.csdn.net/wangshuo2020/article/details/109561286

版权

java语言笔记（基础篇）

图片有点多，就没写

package 桌球01;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Toolkit;
import java.util.jar.JarFile;

import javax.swing.JFrame;

public class BallGame2 extends JFrame
{
	Image ballImage=Toolkit.getDefaultToolkit().getImage("E:/java语言/java语言（新）/跟着哔哩哔哩学习java/src/桌球/gai.jpg");
	Image deskImage=Toolkit.getDefaultToolkit().getImage("E:/java语言/java语言（新）/跟着哔哩哔哩学习java/src/桌球/iuu.jpg");
	
	double x=100;//小球坐标
	double y=100;
	
	double jiaodu=3.14/3;//60度
	
	
	//画窗口
	public void paint(Graphics g)
	{
		System.out.println("画窗口");
		g.drawImage(deskImage,0,0, null);
		g.drawImage(ballImage,(int)x,(int)y,null);
		
		
		x=x+10*Math.cos(jiaodu);
		y=y+10*Math.sin(jiaodu);
		
		if(y>300-41||y<41)
			jiaodu= -jiaodu;
		if(x>554-46||x<0)
			jiaodu=3.14-jiaodu;
			
		
		
	}
	
	
	
	
	
	//窗口加载
	void zhuomian()
	{
		setSize(554,300);
		setLocation(400, 400);
		setVisible(true);
		
		//重画窗口
		while(true)
		{
			repaint();//调paint
			try 
			{
				Thread.sleep(15);
			} 
			catch (InterruptedException e) 
			{
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
	}
	public static void main(String[] args) 
	{
		BallGame2 game=new BallGame2();
		game.zhuomian();
	
		
	}
	
}

file:///E:/java语言/java语言（新）/跟着哔哩哔哩学习java/src/桌球01/gai.jpg

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NzLm3Hl3-1604825393722)(E:\大学课程作业资料汇总\大二下学期\java\笔记\java基础篇\iuu.jpg)]

（1）基础概念

java传值是值传递==>值的副本，地址

面向过程：做事分几步

面向对象：分成几个部分，一部分一部分解决

对象：管理一类事物（一个事物所需要的不同类型数据及相关方法）的打包，一个子树（一个软件中有数据，有方法）

项目：多个对象的集合

抽象：归纳出类似点==>类

对象：类的实例

方法：用以定义类的或类的行为特征和功能实现

01-基础

1-变量

static ：静态变量，从属于类，在一个类中其他方法可以直接调用，类加载就有效，消失就失效

成员变量：从属于对象、类，对象、类创建就出现，消失就消失

局部变量：从属于语句块，从属于方法，方法或语句块消失，失效

package 构造方法;
//静态==>宏，属于类，所以类方法只能调用类变量，因为其他变量没有对象之前没有数
//在类中的方法可以直接调用类方法，因为类方法在类中始终有效，始终开辟线程
public class Example {

	int id;
	String nameString;
	static String name="静态变量==>宏变量";
	public Example()
	{
		
	}
	public Example(int id,String name)
	{
		super();//构造方法第一句总是他
		this.id=id;
		this.nameString=name;//this表示当前对象
	}
	public void paint()
	{
		paints();//可以直接使用静态方法，因为是类方法，在类里全有效，不用对象
		System.out.println("在方法中使用类方法输出类变量:"+name);//在一个类其他方法可以调用静态方法
		System.out.println("在方法中输出类变量:"+name);
	}
	public static void paints()
	{
		System.out.println(name);//静态方法里只能调用静态变量
		                        //不能使用this  因为static属于类
	}
	public static void main(String[] args) {
		Example u1=new Example();
		Example u2=new Example(101, "wang");
		u2.paint();
	}
}

静态变量==>宏变量
在方法中使用类方法输出类变量:静态变量==>宏变量
在方法中输出类变量:静态变量==>宏变量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CtyOY49D-1604825393725)(E:\大学课程作业资料汇总\大二下学期\java\笔记\java基础篇\1596958401773.png)]

2-常量

final ：全局常量

long 后加l或L

float 后加F

（1）任意精度运算

java.math包中：

BighInteger :精确整数运算

BigDecimal ：精确浮点运算

package 基础运算;
import java.math.BigDecimal;
//浮点数不精确，不用于比较
public class YunSuan1 {
	public static void main(String[] args) {
		BigDecimal a=BigDecimal.valueOf(1.0);
		a=a.subtract(BigDecimal.valueOf(0.1));//精确浮点运算比较
		System.out.println("1.0-0.1="+a);
		BigDecimal b=BigDecimal.valueOf(1.0/10.0);//用于比较
		System.out.println(b);
		System.out.println(1.0-0.1-0.1-0.1-0.1-0.1);//不精确，不用于比较
	}
}
1.0-0.1=0.9
0.1
0.5000000000000001

3-进制

0开头八进制

0x开头十六进制

0b开头二进制

        System.out.println(0x122);//十六进制
		System.out.println(0b0001011);//二进制
		System.out.println(0233);//八进制

290
11
155

4-字符

char x='a';//单引号

5-布尔

boolean f=true;
		if(f)
			System.out.println("1");
		if(!f)
			System.out.println("2");

6-字符串

String g="a";//双引号
		String w="c";
		System.out.println(g+w);
//ac

7-强制转换

double q=3.12;
		System.out.println((int)q);  //3

8-使用Scanner获得键盘输入

Scanner scanner=new Scanner(System.in);
System.out.println("输入");
String nameString=scanner.nextLine();
System.out.println(nameString);
System.out.println((int)(6*Math.random()));//输出[0,5]之间随机数
System.out.println(Math.pow(2, 2));//计算2的平方
输入
23334
23334

9-switch语句

       int i=(int)(1+12*Math.random());
		switch (i)
		{
		case 1:
			System.out.println("1");
			break;

		default:
			System.out.println("其他");
			break;
		}

10-停止语句

        //break退出整个循环
		//continue结束本次循环
		outer:for(int p=101;p<150;p++)
		{
			for(int j=2;j<p/2;j++)
			{
				if(p%j==0)
				   continue outer;//跳到外循环中
			}
			System.out.println(i+" ");
		}

11-内存分析

栈：方法执行的内部逻辑

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0nScrMbi-1604825393727)(E:\大学课程作业资料汇总\大二下学期\java\笔记\java基础篇\1596958530373.png)]

12-构造方法

package 构造方法;

public class Example {

	int id;
	String nameString;
	public Example()
	{
		
	}
	public Example(int id,String name)
	{
		super();//构造方法第一句总是他
		this.id=id;
		this.nameString=name;
	}
	public static void main(String[] args) {
		Example u1=new Example();
		Example u2=new Example(101, "wang");
	}
}

13-静态块

package 静态块04;

public class Example {
	int a;
	static String bString;
	static//先加载类再创建对象，因此，他比对象更早执行
	{
		bString="静态块，类初始化时执行";
		paint();                        
	}
	public static void paint()
	{
		System.out.println(bString);
	}
	public static void main(String[] args) {
		Example aExample=null;
	}

}

静态块，类初始化时执行

14-数组

（1）数组的声明、创建、遍历

package 基础运算02;
//数组的声明、创建、初始化、遍历
public class Shuzu {
	public static void main(String[] args) {
		//数组的声明
		int[] a;
		String b[];
		User[] c;
		//创建数组
		a=new int[3];
		b=new String[10];
		c=new User[2];
		//数组初始化
		for(int i=0;i<a.length;i++)
		{
			a[i]=i*2;
		}
		c[0]=new User(100, "a");
		c[1]=new User(101, "b");
		//遍历数组
		for(int i=0;i<c.length;i++)
		{
			System.out.println(c[i].getName());
		}
	}

}

class User
{
	private int id;
	private String name;
	public User(int id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
}
a
b

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LAmLb5OZ-1604825393729)(E:\大学课程作业资料汇总\大二下学期\java\笔记\java基础篇\1597220518110.png)]

①数组的三种初始化方式

i静态初始化

ⅱ动态初始化

ⅱi默认初始化

package 基础运算02;
//数组的三种初始化方式
public class Shuzu2 {
	public static void main(String[] args) 
	{
		//静态初始化
		int a[]= {1,2,3};
		User b[]= {
				    new User(1001,"a"),
				    new User(1002,"b"),
				    new User(1003,"c")
			      };
		//默认初始化
		int s[]=new int[3];
		//动态初始化（定义与分配空间分开）
		int h[]=new int[2];
		h[0]=1;
		h[1]=2;
	}

}

②数组的遍历

package 基础运算02;
//数组的遍历
public class Shuzu3 {
	public static void main(String[] args) {
		//for循环遍历
		int a[]=new int[4];
		for(int i=0;i<a.length;i++)
			a[i]=10*i;
		for(int i=0;i<a.length;i++)
			System.out.println(a[i]);
		//foreach循环：用于读取数组元素的值，不能修改元素的值
		for(int i:a)
			System.out.println(i);
	}

}

0
10
20
30
0
10
20
30

15-枚举

package 基础运算02;
//枚举类型
public class Meiju {
	public static void main(String[] args) {
		System.out.println(Season.星期一);
	}

}

enum Season
{
	星期一,星期二,星期三
}

星期一

02-包

（1）包<==>文件夹对类的管理域名倒着写

（2）解决类重名问题

（3）两个包可能有关系，也有可能是两个完全独立的包

（4）java常用包：

java.lang 不用导入，直接使用

java.awt 画窗口

java.net网络相关操作

java.io输入输出流

java.util实用工具

1-导入包和静态属性

package 包的使用;

import 基础运算02.YunSuan1;
import java.util.Date;//导入具体类
import java.sql.*;//导入所有类
import static java.lang.Math.PI;//导入类的静态属性
//import static java.lang.Math.PI.*;//导入类的所有静态属性

public class Test {
	public static void main(String[] args) {
		YunSuan1 userSuan1=new YunSuan1();
		userSuan1.main(null);
		
		java.util.Date date=new java.util.Date();//防止多个同名类
		System.out.println(PI);
		System.out.println(Math.PI);
		
	}

}

2-Object类

是所有java类的根基类，所有java对象都能用

u1==u2 判断对象（地址）是否相等

u1.equals(u2) 判断内容是否相等

public String toString() //重写Object中方法

to.toString() 返回字符串

package Object类使用;
//返回字符串、重写方法、==判断地址相等、equals（）判断内容是否相等
public class TestObject {
	public static void main(String[] args) {
		TestObject to=new TestObject();
		System.out.println(to.toString());//返回字符串
		
		Object object;
		
		User u1=new User(100, "王");
		User u2=new User(100, "里");
		System.out.println(u1==u2);//判断对象（地址）是否相等
		System.out.println(u1.equals(u2));//判断内容是否相等
		
		String str1=new String("1");
		String str2=new String("1");
		System.out.println(str1==str2);
		System.out.println(str1.equals(str2));
	}
	
	public String toString() //重写Object中方法
	{
		return "111111111";
	}
}

class User
{
	int id;
	String name;
	public User(int id, String name) 
	{
		super();
		this.id = id;
		this.name = name;
	}
	
	
	public boolean equals(Object obj) 
	{
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		User other = (User) obj;
		if (id != other.id)
			return false;
		if (name == null)
		{
			if (other.name != null)
				return false;
		} 
		else if (!name.equals(other.name))
			return false;
		return true;
	}
}

//验证封装
class p
{
	protected int s;//同一个包下课使用
	public void paint()
	{
		System.out.println(s);
	}
}


111111111
false
false
false
true

package Object类使用;
//构造方法第一句总是super
//super父类对象引用
//封装
public class TestObject2 {
	public static void main(String[] args) {
		Ven2 aVen2=new Ven2();
		aVen2.pain();
		
		p zhengP=new p();//验证protected同一个包下可调用
		zhengP.s=3;
		zhengP.paint();
	}
}

class Ven
{
	public Ven()
	{
		System.out.println("父类构造方法");
	}
	private String aString="父类";//封装
	public void pain()
	{
		System.out.println(aString);
	}
}

class Ven2 extends Ven
{
	public Ven2() 
	{
		//super();   //这里总是默认调用
		System.out.println("子类构造方法");
	}
	private String aString="子类";//封装
	public void pain()
	{
		super.pain();//父类对象引用
		System.out.println(aString);
	}
}

父类构造方法
子类构造方法
父类
子类
3

3-封装使用的细节

①一般使用private访问权限

②提供相应的get/set方法来访问相关属性，这些方法通常使用public修饰，用来提供对实行的赋值与读取操作（boolean变量的get方法是is开头）

③一些只用于蓓蕾的辅助方法使用private修饰，希望其他类调用的方法用public修饰

（1）快速生成输入输出函数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QFY07qGv-1604825393732)(E:\大学课程作业资料汇总\大二下学期\java\笔记\java基础篇\1597131495615.png)]]

Fengzhuang.java
package Object类使用和封装;

public class Fengzhuang {
	private int id;
	private String name;
	private int age;
	private boolean man;
	//输入输出函数
	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

	public boolean isMan() {
		return man;
	}

	public void setMan(boolean man) {
		this.man = man;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age)
	{
		if(age>=1&&age<=130)
			this.age=age;
		else {
			System.out.println("请输入正常的年龄");
		}
		
	}
	//一般函数,权限使用public
	public void paint()
	{
		System.out.println("一般的函数");
	}
}

FengzhuangCZ.java
package Object类使用和封装;

public class FengzhuangCZ {
	public static void main(String[] args) {
		Fengzhuang a=new Fengzhuang();
		a.setName("王");
		a.setAge(1);
		System.out.println(a.getName());
		System.out.println(a.getAge());
	}

}

王
1

4-多态

①多态是方法的多态

②多态存在的三个必要条件：

继承、方法重写、父类引用指向子类的对象

③父类指向子类对象，之后用父类调用子类重写方法，就实现了多态

（1）方法重写

子类重写父类方法，用自身行为替换父类行为

①方法名、形参列表相同

②返回值类型和声明异常类型，子类小于父类

③访问权限子类大于等于父类

package 方法重写;

public class Text
{
	public static void main(String[] args) {
		Venx aVenx=new Venx();
		aVenx.run();
		aVenx.stop();
	}

}

class Ven
{
	public void run()
	{
		System.out.println("父");
	}
	public void stop()
	{
		System.out.println("停止");
	}
}

class Venx extends Ven
{
	public void run()
	{
		System.out.println("子");
	}
	
}

子
停止

（2）多态与转型

package 方法重写;
//多态，强制向下转型，自动向上转型
public class Duotai 
{
	public static void main(String[] args) 
	{
		Ven a=new Ven();
		getVen(a);
		//多态，只能使用重写的方法
		Venx2 b=new Venx2();
		getVen(b);//父亲调用子方法
		getVen(new Venx());
		//自动向上转型
		Ven d=new Venx2();//这时认为是Ven型，不能调用Venx2特有方法
		//Venx2 d2=Venx2(Venx2)d;//强制向下转型
		//d2.paint();
		
		
		
	}
	
	static void getVen(Ven a)//静态的调用函数
	{
		a.run();
	}

}

class Venx2 extends Ven
{
	public void run()
	{
		System.out.println("子2");
	}
	public void paint()
	{
		System.out.println("Venx特有方法");
	}
}
父
子2
子

（3）final关键字

①修饰变量：此变量不可被更改，不可重新赋值

②修饰方法：此方法不可被子类重写，可以被重载

③修饰类：此类不可被继承。例：Math、String

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HmKHQVpn-1604825393732)(E:\大学课程作业资料汇总\大二下学期\java\笔记\java基础篇\1597217369960.png)]

5-飞机小游戏

package 飞机小游戏;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.Date;

import javax.swing.JFrame;//解决了图片闪烁问题
import javax.xml.crypto.Data;

import org.omg.CORBA.PRIVATE_MEMBER;
//窗口类
//飞机小游戏主窗口
public class MyGameFrame extends JFrame
{
	Image bgImage=GameUtil.getImage("images/bg.jpg");//地球
	Image pImage=GameUtil.getImage("images/plane.png");//飞机
	
	Plane plane=new Plane(pImage,250,250);//飞机对象
	//int pImageX=250;
	//int pImageY=250;
	//Shell shell=new Shell();//炮弹类
	Shell shells[]=new Shell[50];
	
	Explode bao;//爆炸对象
	Date startTime=new Date();//开始时间
	Date endTime;//结束时间
	int chixu;//游戏持续时间
	
	
	@Override
	public void paint(Graphics g) {//自动被调用，g相当于画笔
		Color color=g.getColor();//获取当前字体
		
		/*
		// 画图形
		super.paint(g);
		Color color=g.getColor();
		Font font=g.getFont();
		g.setColor(Color.BLUE);//画笔颜色
		g.drawLine(100, 100, 300, 300);//线
		g.drawRect(100, 100, 300, 300);//矩形
		g.drawOval(100,100, 300, 300);//团员
		g.fillRect(100, 100, 40, 40);//实心矩形
		
		g.drawImage(ball, 0, 0, null);//画图片
		g.setColor(Color.red);
		g.setFont(new Font("宋体",Font.BOLD,50));//字体
		g.drawString("我在画图形", 200, 200);//文字
		g.setColor(color);
		*/
		
		g.drawImage(bgImage, 0, 0, null);//画地球位置
		/*
		g.drawImage(pImage, pImageX, pImageY, null);//画飞机位置
		pImageX++;//飞机移动
		*/
		
		plane.drawSelf(g);//画飞机
		//shell.draw(g);//画炮弹
		for(int i=0;i<shells.length;i++)//画出所有炮弹
		{
			shells[i].draw(g);
			//飞机和炮弹的碰撞检测
			boolean peng=shells[i].getRect().intersects(plane.getRect());
			if(peng)
			{
				plane.live=false;//飞机消失
				if(bao==null)
				{
					//炮弹爆炸
				    bao=new Explode(plane.x, plane.y);//爆炸类
				    endTime=new Date();//结束时间
				    chixu=(int)((endTime.getTime()-startTime.getTime())/1000);//持续时间
				}
				
				
				bao.draw(g);
			}
			if(!plane.live)//计算时间，没有碰撞
			{
				g.setColor(Color.red);//字颜色颜色
				Font font=new Font("宋体", Font.BOLD, 50);
				g.setFont(font);//改字体
				g.drawString("持续时间是："+chixu+"秒", (int)plane.x, (int)plane.y);//画持续时间
	
			}
				
			
		}
		g.setColor(color);//回复原先字体
	}
	//反复的重画窗口,实现移动
	class PaintThread extends Thread
	{
		@Override
		public void run() {
			// TODO Auto-generated method stub
			super.run();
			while(true)
			{
				repaint();//重画
				
				try 
				{
					Thread.sleep(40);//停止时间
				}
				catch
				(InterruptedException e)
				{
					e.printStackTrace();
				}
			}
		}
	}
	
	//键盘监听的内部类
	class KeMonitor extends KeyAdapter
	{

		@Override
		public void keyReleased(KeyEvent e) {//抬起那个键
			super.keyTyped(e);
			//System.out.println("抬起"+e.getKeyCode());//获取抬起的那个键
			plane.minusDirection(e);
		}

		@Override
		public void keyPressed(KeyEvent e) {//按下那个键
			super.keyPressed(e);
			//System.out.println("按下"+e.getKeyCode());//获取按下的那个键
			plane.addDirection(e);
		}
	}
	
	//初始化窗口
	public void launchFrame()
	{
		this.setTitle("王硕作品");//创建
		this.setVisible(true);//显示
		this.setSize(Constant.GAME_WIDE, Constant.GAME_HEIGHT);//大小
		this.setLocation(300, 200);//位置
		this.addWindowListener(new WindowAdapter() 
		{
			@Override
			public void windowClosing(WindowEvent e) 
			{//关闭时候操作
				// TODO Auto-generated method stub
				System.exit(0);//结束虚拟
			}
		});
		new PaintThread().start();//启动线程
		addKeyListener(new KeMonitor());//给窗口添加键盘监听
		
		//初始化50个炮弹
		for(int i=0;i<shells.length;i++)
		{
			shells[i]=new Shell();
		}
		
		
		
	}
	
	
	//入口
	public static void main(String[] args) {
		MyGameFrame f=new MyGameFrame();
		f.launchFrame();
	}
	
	//双缓冲解决闪烁问题,在内存里先画一个图片
	private Image offScrImage=null;
	public void update(Graphics g)
	{
		if(offScrImage==null)
			offScrImage=this.createImage(Constant.GAME_WIDE, Constant.GAME_HEIGHT);
		Graphics gOffGraphics=offScrImage.getGraphics();
		paint(gOffGraphics);
		g.drawImage(offScrImage, 0, 0, null);
	}

}
package 飞机小游戏;

import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.KeyEvent;

//飞机类
public class Plane extends GameObject{
	boolean shang,xia,zuo,you;
	int speed=10;
	boolean live=true;
	public void drawSelf(Graphics g)
	{
		if(live)//判断碰撞
		{
			g.drawImage(img, (int)x, (int)y, null);
			if(zuo)
				x-=speed;//增加减少常量
			if(you)
				x+=speed;
			if(shang)
				y-=speed;
		    if(xia)
			    y+=speed;
		}
		else {
			
		}
		
	}
	
	public Plane(Image img,double x,double y)
	{
		this.img=img;
		this.x=x;
		this.y=y;
		this.speed=10;
		this.width=img.getWidth(null);
		this.height=img.getHeight(null);
		
	}
	
	//按下某个键，增加相应方向
	public void addDirection(KeyEvent e)
	{
		switch(e.getKeyCode())
		{
		case KeyEvent.VK_LEFT:
			zuo=true;
			break;
		case KeyEvent.VK_UP:
			shang=true;
			break;
		case KeyEvent.VK_RIGHT:
			you=true;
			break;
		case KeyEvent.VK_DOWN:
			xia=true;
			break;
		}
	}
	//按下某个键，取消相应方向
	public void minusDirection(KeyEvent e)
	{
		switch(e.getKeyCode())
		{
		case KeyEvent.VK_LEFT:
			zuo=false;
			break;
		case KeyEvent.VK_UP:
			shang=false;
			break;
		case KeyEvent.VK_RIGHT:
			you=false;
			break;
		case KeyEvent.VK_DOWN:
			xia=false;
			break;
		}
	}
	

}
package 飞机小游戏;

import java.awt.Color;
import java.awt.Graphics;

//炮弹类
public class Shell extends GameObject
{
	double dergree;//随机角度
	public Shell()
	{
		x=200;
		y=200;
		width=10;
		height=10;
		speed=2;//移动速度
		dergree=Math.random()*Math.PI;//随机角度[0~2pi]
	}
	public void draw(Graphics g)
	{
		Color color=g.getColor();
		g.setColor(Color.YELLOW);//点
		g.fillOval((int)x, (int)y, width, height);//实心点
		//沿任意角度去飞
		x+=speed*Math.cos(dergree);
		y+=speed*Math.sin(dergree);
		if(x<0||x>Constant.GAME_WIDE-width)
			dergree=Math.PI-dergree;
		if(y<30||y>Constant.GAME_HEIGHT-height)
			dergree=-dergree;
		
		g.setColor(color);
	}

}
package 飞机小游戏;
//工具类
//返回图像对象
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.net.URL;

import javax.imageio.ImageIO;

public class GameUtil {
	private GameUtil()
	{
		
	}
	//返回指定路径的图片对象
	public static Image getImage(String path)
	{
		BufferedImage bi=null;
		try 
		{
			URL url=GameUtil.class.getClassLoader().getResource(path);
			bi=ImageIO.read(url);
			
		} 
		catch (IOException e)
		{
			e.printStackTrace();
		}
		return bi;
	}

}
package 飞机小游戏;
//游戏物体的父类，解决物体的位置、边缘距离、图片、速度

import java.awt.Graphics;
import java.awt.Image;
import java.awt.Rectangle;

public class GameObject {
	Image img;
	double x,y;
	int speed;//增加减少常量
	int width,height;
	
	public void drawSelf(Graphics g)
	{
		g.drawImage(img, (int)x, (int)y, null);
	}

	public GameObject(Image img, double x, double y, int speed, int width, int height) {
		super();
		this.img = img;
		this.x = x;
		this.y = y;
		this.speed = speed;
		this.width = width;
		this.height = height;
	}

	public GameObject(Image img, double x, double y) {
		super();
		this.img = img;
		this.x = x;
		this.y = y;
	}

	public GameObject() {
		super();
	}

	//返回物体所在矩形，便于后续碰撞检测
	public Rectangle getRect()
	{
		return new Rectangle((int)x, (int)y,width,height);
	}

}
package 飞机小游戏;
//爆炸类

import java.awt.FontFormatException;
import java.awt.Graphics;
import java.awt.Image;

public class Explode {
	double x,y;
	static Image images[]=new Image[16];
	static 
	{
		for(int i=0;i<16;i++)//加载图形
			{
			  images[i]=GameUtil.getImage("images/explode/e"+(i+1)+".gif");
			  images[i].getWidth(null);
	        }
	}
	int count;
	public void draw(Graphics g)
	{
		if(count<=15)
		{
			g.drawImage(images[count], (int)x, (int)y, null);//画图形
			count++;
		}
	}
	public Explode(double x, double y) {
		super();
		this.x = x;
		this.y = y;
	}
	

}
package 飞机小游戏;
//常量类
public class Constant {
	public static final int GAME_WIDE=570;//宽
	public static final int GAME_HEIGHT=613;//高

}

03-类和方法

1-抽象类和方法

①abstract 抽象

②没有实现

③抽象方法必须被子类实现

④严格限制子类方法

⑤有抽象方法的类只能是抽象类

⑥抽象类不能实例化，既不能用new来实例，只能被子类调用

⑦抽象类只能用来继承

package 类和接口;
//抽象类和方法
//父类没有实现
//抽象类，为子类提供统一的规范和模板/、子类必须实现
public abstract class Chouxiang {
	abstract public void shout();
	public void run()
	{
		System.out.println("抽象类里的普通方法");
	}
	public static void main(String[] args) {
		Dox xDox=new Dox();
	}

}
class Dox extends Chouxiang
{

	@Override
	public void shout() {
		System.out.println("子类实现父类的抽象方法");
		
	}
	
}

2-接口及其实现

package 类和接口09;
//接口
//interface
//接口中所有方法都是抽象方法
//完全面向规范化,只定义规范，不定义实现，是一个模板
//只定义常量和抽象方法
interface Jie 
{
	/*public abstract*/void test();//默认
	/*public static fubal*/ int a=100;//默认
}
interface aJie
{
	void Help();
}
//子类实现接口
//implements
//必须实现接口方法
class MyClass implements Jie,aJie//实现多个接口//多继承接口
{

	@Override
	public void test() 
	{
		System.out.println("实现接口的方法");
		System.out.println("接口中定义的静态常量"+a);//接口中定义的静态常量
	}

	@Override
	public void Help()
	{
		System.out.println("另一个接口的实现方法");
		
	}
	
}
public class Jiekou
{
	public static void main(String[] args) {
		MyClass aClass=new MyClass();//正常接口实现
		aClass.test();
		aClass.Help();
		Jie aJie=new MyClass();
		aJie.test();//接口回调，只调用实现的方法
	}
}

实现接口的方法
接口中定义的静态常量100
另一个接口的实现方法
实现接口的方法
接口中定义的静态常量100

3-内部类

package 类和接口09;
//内部类
//成员内部类（非静态内部类、静态内部类）访问控制符随便修饰
//匿名内部类
//局部内部类
//
public class Neibulei {
	public static void main(String[] args) {
		//创建非静态内部类对象
		Outer.Inner inner=new Outer().new Inner();
		inner.show();
		//创建静态内部类对象
		Outer.Inner2 inner2=new Outer.Inner2();
		System.out.println(inner2.nameString);
	}

}


//生成两个类文件
//内部类对象依托于外部类对象
class Outer//外部类
{
	private int age=20;
	public void testOuter()
	{
		System.out.println("外部类的成员");
	}
	
	//非静态内部类
	//可以直接访问外部类的成员
	/*static*/class Inner//静态内部类//非静态内部类
	{
		int age=21;
		public void show()
		{
			System.out.println("非静态内部类访问外部类的成员变量"+Outer.this.age);
			testOuter();
			System.out.println("非静态内部类变量"+this.age);
		}
	}
	
	//静态内部类
	//相当于外部类的一个静态成员
	static class Inner2
	{
		String nameString="静态内部类";
	}
}

非静态内部类访问外部类的成员变量20
外部类的成员
非静态内部类变量21
静态内部类

package 类和接口09;

//匿名内部类
//适用于只使用一次的类，监视器里经常使用
public class Nimingneibulei
{
	public static void test(AA a)
	{
		System.out.println("外部类方法");
	}
	public static void main(String[] args) {
		Nimingneibulei.test(new AA()
			{
				public void aa() 
				{
					System.out.println("匿名内部类");
					
				}
			});
	
	}
	
	
}
interface AA
{
	void aa();
}

外部类方法

package 类和接口09;
//局部内部类
//在方法内部定义内部类
public class Jubuneibulei {
	//局部内部类位于的方法
	public void show()
	{
		//局部内部类
		//作用域仅限于该方法
		class Inner
		{
			public void fun()
			{
				System.out.println("局部内部类的方法");
			}
		}
		new Inner().fun();
		
	}
	public static void main(String[] args) {
		new Jubuneibulei().show();
	}

}

局部内部类的方法

4-String类

（1）创建与比较

①不可变字符序列

②位于java.lang包中，java默认导入java.lang包下所有的类

③没有内置字符串类型，提供预定义的类String，每个用双引号括起来的字符串都是String类的一个实例

④字符串常量放到常量池里，（直接赋值会放到常量池里）

public class Stringtext
{
    String a="asd";
    String b=new String("asd");
    String c="asd";
    System.out.println(b.equals(c));//比较内容
    System.out.println(a==b);//比较地址
}
true
false

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4VOfiOmB-1604825393734)(E:\大学课程作业资料汇总\大二下学期\java\笔记\java基础篇\1597555292547.png)]

（2）数组的拷贝、删除、扩容

package 类和接口09;
//数组的拷贝、删除、扩容
public class Stringkaobei {
	public static void main(String[] args) {
		//System.arraycopy(数组a, 数组a开始, 数组b, 数组b, 拷贝元素个数);//数组的拷贝
		String a[]= {"a","b","c","d","e"};
		String b[]=new String[10];
		System.arraycopy(a, 1, b, 5, 4);
		for(int i=0;i<b.length;i++)
		{
			System.out.print(b[i]+" ");
		}
		//数组删除元素==>本质数组拷贝==>a自己拷贝
		//数组扩容==>本质数组拷贝==>定义一个更大的数组，之后复制到新数组中
		
	}
}

null null null null null b c d e null

（3）Arrays工具类

①提供操作数组的各种方法

package 类和接口09;

import java.util.Arrays;

//数组的工具类
//打印数组（静态方法）、排序、二分查找数组
public class ArraysTest {
	public static void main(String[] args) {
		int a[]= {40,20,30};
		System.out.println(Arrays.toString(a));//静态方法打印数组
		Arrays.sort(a);//排序
		System.out.println(Arrays.toString(a));
		System.out.println(Arrays.binarySearch(a, 2));//二分查找
	}

}

[40, 20, 30]
[20, 30, 40]
-1

5-多维数组

（1）二维数组创建、初始化、存储表格

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pmIeGrC0-1604825393735)(E:\大学课程作业资料汇总\大二下学期\java\笔记\java基础篇\1597560637599.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wWVsriXs-1604825393736)(E:\大学课程作业资料汇总\大二下学期\java\笔记\java基础篇\1597560981407.png)]

package 类和接口09;

import java.util.Arrays;

//二维数组创建、初始化、存储表格
public class Shuzu2D {
	public static void main(String[] args) {
		Car car[]=new Car[3];
		int[][] a=new int [3][];
	    a[0]=new int[] {1,2,3};
	    a[1]=new int[] {10,20};
	    a[2]=new int[] {6};
		//静态化方式初始二维数组
        int b[][]= {
        		{1,2,3},
        		{4,5},
        		{1}
        };
        Object[] objecta= {1001,"a","2006-1-3"};
        Object[] objectb= {1001,"b","2006-1-3"};
        Object[] objectc= {1001,"c","2006-1-3"};
        Object[] taObjects=new Object[3][];
        
        taObjects[0]=objecta;
        taObjects[1]=objectb;
        taObjects[2]=objectc;
        for(Object object:taObjects)
        {
        	System.out.println(Arrays.toString(objecta));
        }
      
	}

}
class Car
{
	
}

[1001, a, 2006-1-3]
[1001, a, 2006-1-3]
[1001, a, 2006-1-3]

04-常用类

1-包装类及其转换

①包装类：将基本数据类型转化成对象，和八个基本数据类型对应的类

②位于java.lang包

基本数据类型	包装类
byte	Byte
boolean	Boolean
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dO9w3RyV-1604825393737)(E:\大学课程作业资料汇总\大二下学期\java\笔记\java基础篇\1597651290706.png)]

package 常用类10;
//包装类
public class BaoZhuanglei {
	public static void main(String[] args) {
		Integer a=new Integer(3);//继承自Number，将3转换成对象
		Integer b=Integer.valueOf(20);
		
		//把包装类转换成基本数据类型
		int c=b.intValue();
		double d=b.doubleValue();
		
		//把字符串转换成包装类对象
		Integer eInteger=new Integer("666");
		Integer fInteger=Integer.parseInt("77");
		
		//把包装类转换成字符串
		String string=fInteger.toString();
		
		//罕见的常量
		System.out.println("int类型的最大整数："+Integer.MAX_VALUE);
	}

}

int类型的最大整数：2147483647

2-自动装箱和拆箱、缓存

package 常用类10;
//自动装箱和拆箱
public class Zhuangxiang {
	public static void main(String[] args) {
		//自动装箱
		Integer a=234;//Integer a=Integer.valueOf(234);//变对象
		//自动拆箱
		int b=a;//int b=a.intValue()//变基本类型
		
		//缓存==>系统初始化时创建缓存数组
		//如果在数组中，直接取出
		//如果不在数组中，创建一个
	}

}

3-字符串String类

不可变字符序列，final修饰，只能赋值一次

（1）默认不可变字符串String的创建和可变字符串StringBuilder

package 常用类10;
//字符串，不可变数据类型、字符串复制
//StringBuilder可变字符串（线程不安全，效率高）
//StringBuffer  可变字符串(线程安全，效率低)
public class TestString {
	public static void main(String[] args) {
		String a1="123";
		String a2=a1.substring(0, 3);//复制到字符串a2
		System.out.println(a1);
		System.out.println(a2);
		//编译器优化，在编译时直接进行拼接
		String a3="hello"+"word";//helloword
		String a4="helloword";
		System.out.println(a3==a4);//true
		String a5="hello";
		String a6="word";
		//编译器不知道变量中储存什么，所以没办法进行优化
		String s=a5+a6;
		System.out.println(a4==s);//false
		
		//字符串比较时使用equals（）进行值比较
		System.out.println(a4.equals(s));
		
		//StringBuilder可变字符串
		StringBuilder sbBuilder=new StringBuilder("asdf");
		System.out.println(Integer.toHexString(sbBuilder.hashCode()));
		System.out.println(sbBuilder);
		
		sbBuilder.setCharAt(2, 'M');
		System.out.println(Integer.toHexString(sbBuilder.hashCode()));
		System.out.println(sbBuilder);
	}

}

123
123
true
false
true
5c29bfd
asdf
5c29bfd
asMf

（2）可变字符串StringBuilder常见方法及注意

package 常用类10;
//可变字符串常用方法
public class TextString2 {
	public static void main(String[] args) {
		
		//可变字符串常用方法
		
		StringBuilder sb=new StringBuilder();//可变字符序列
		for(int i=0;i<26;i++)
		{
			sb.append((char)('a'+i));
		}
		System.out.println(sb);
		
		sb.reverse();//倒叙
		System.out.println(sb);
		sb.setCharAt(2, '插');//替换
		System.out.println(sb);
		sb.insert(0, '插').insert(1, '插');//链式调用：插入，返回自己
		System.out.println(sb);
		sb.delete(20, 23);//删除区间
		System.out.println(sb);
		
		//字符序列化和不可变字符序列化陷阱
		
		/*
		String string="";
		for(int i=0;i<5000;i++)
		{
			string=string+i;//相当于产生了10000个对象，对象会被多次调用
			                //服务器会崩溃
		}
		*/
		//代替
		StringBuilder stringBuilder=new StringBuilder();//不会频繁产生额外对象
		for(int i=0;i<5000;i++)
		{
			stringBuilder.append(i);
		}
	}

}

abcdefghijklmnopqrstuvwxyz
zyxwvutsrqponmlkjihgfedcba
zy插wvutsrqponmlkjihgfedcba
插插zy插wvutsrqponmlkjihgfedcba
插插zy插wvutsrqponmlkjiedcba

4-Date时间类

（1）时间格式化类DateFormat和SimpleDateFormat时间格式化类计算的使用

①时间格式化字符表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bn2mYUxh-1604825393738)(E:\大学课程作业资料汇总\大二下学期\java\笔记\java基础篇\1597742886853.png)]

package 常用类10;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
//Date时间类、时间格式化类DateFormat和SimpleDateFormat
public class TextDate {
	public static void main(String[] args) throws ParseException {
		
		//Date时间类
		
		Date date=new Date();//当前电脑时间
		System.out.println(date);
		
		//时间格式化类DateFormat和SimpleDateFormat
		
		//时间==>字符串
		DateFormat df=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		System.out.println(df.format(date));//时间按照指定格式转成字符串
		
		//时间<==字符串
		DateFormat df2=new SimpleDateFormat("yyyy年MM月dd日 hh时mm分ss秒");
		Date date2=df2.parse("2020年05月10日 10时45分59秒");
		System.out.println(date2);
		
		//其他字符
		DateFormat df3=new SimpleDateFormat("D");//今年多少天
		String string=df3.format(new Date());
		System.out.println(string);
	
	}

}

Tue Aug 18 17:52:33 CST 2020
2020-08-18 05:52:33
Sun May 10 10:45:59 CST 2020
231

（2）Calendar日历类、GregorianCalendar日历计算的使用、日期对象<==>时间对象

①基本使用

package 常用类10;

import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

//Cslendar日历类
//GregorainCalendar日期类具体子类日历计算
//日期对象<==>时间对象
public class TestCalendar {
	public static void main(String[] args) {
		//日历类及其方法的使用
		
		Calendar calendar=new GregorianCalendar(2020,8,19,10,50);
		int year=calendar.get(Calendar.YEAR);//返回年、月等
		System.out.println(year);
		
		//设置日期
		Calendar calendar2=new GregorianCalendar();
		calendar2.set(Calendar.YEAR,2067);
		
		//日期计算
		Calendar calendar3=new GregorianCalendar();
		calendar3.add(Calendar.YEAR, -100);//往前多少年
		
		//日期对象<==>时间对象
		Date d4=calendar3.getTime();//日期对象转时间对象
		
		printCalendar(calendar);
	}
	
	public static void printCalendar(Calendar c)
	{
		//打印：1918年10月10日 11:23:45 周三
		int year=c.get(Calendar.YEAR);
		int month=c.get(Calendar.MONTH);
		int date=c.get(Calendar.DAY_OF_MONTH);
		int dayweek=c.get(Calendar.DAY_OF_WEEK)-1;
		String datweek2=dayweek==0?"日":dayweek+"";
		
		int hour=c.get(Calendar.HOUR);
		int minute=c.get(Calendar.MINUTE);
		int second=c.get(Calendar.SECOND);
		
		System.out.println(year+"年"+month+"月"+date+"日"+hour+"时"+minute+"分"+second+"秒"+"周"+datweek2);
	}

}

2020
2020年8月19日10时50分0秒周6

②可视化日历程序

package 常用类10;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Scanner;

//可视化日历程序
public class TestCalendar2 {
	public static void main(String[] args) throws ParseException {
		//时间类
		System.out.println("请输入日期（格式：2020-9-10）：");
		Scanner scanner=new Scanner(System.in);//获取键盘输入
		String string=scanner.nextLine();
		
		DateFormat df=new SimpleDateFormat("yyyy-MM-dd");
		Date date=df.parse(string);
		//日期类
		Calendar calendar=new GregorianCalendar();
		calendar.setTime(date);//时间转日期
		//打印
		int day=calendar.get(Calendar.DAY_OF_MONTH);//当前日期
		System.out.println("日\t一\t二\t三\t四\t五\t六");
		calendar.set(Calendar.DAY_OF_MONTH, 1);//将日设为1，第一天初始化
		//空格
		for(int i=0;i<calendar.get(Calendar.DAY_OF_WEEK)-1;i++)//获得指定日的星期
		{
			System.out.print("\t");
		}
		
		
		int days=calendar.getActualMaximum(Calendar.DATE);//最大天
		
		//打印日期换行
		for(int i=1;i<=days;i++)
		{
			if(day==calendar.get(Calendar.DAY_OF_MONTH))
			{
				System.out.print(calendar.get(Calendar.DAY_OF_MONTH)+"*\t");
			}
			else {
				System.out.print(calendar.get(Calendar.DAY_OF_MONTH)+"\t");//获取月份日期
			}
			
			if(calendar.get(Calendar.DAY_OF_WEEK)==Calendar.SATURDAY)//星期几  星期六
				System.out.println();//换行
			calendar.add(Calendar.DAY_OF_MONTH, 1);//将日设为1，第一天初始化
		}
	}

}

请输入日期（格式：2020-9-10）：
2020-8-19
日	一	二	三	四	五	六
						1	
2	3	4	5	6	7	8	
9	10	11	12	13	14	15	
16	17	18	19*	20	21	22	
23	24	25	26	27	28	29	
30	31

5-Math计算工具类和Random随机数类

package 常用类10;

import java.util.Random;

//Math工具类相关常用方法
//Random随机数类
public class TextMathRandom {
	public static void main(String[] args) {
		//Math工具类相关常用方法
		
		//取整相关操作
		System.out.println(Math.ceil(3.2));
		System.out.println(Math.floor(3.2));
		System.out.println(Math.round(3.2));
		System.out.println(Math.round(3.8));
		//绝对值、开放、a的n次幂等操作
		System.out.println(Math.abs(-45));
		System.out.println(Math.sqrt(64));
		System.out.println(Math.pow(5, 2));
		System.out.println(Math.pow(2, 5));
		//Math类中的常量
		System.out.println(Math.PI);
		System.out.println(Math.E);
		//随机数
		System.out.println(Math.random()+"\n");//[0,1]
		
		//Random随机数类
		Random rand=new Random();
		//随机生成[0,1）之间的double、int、float、boolean类型的数据
		System.out.println(rand.nextDouble());
		//随机生成[20,10)之间的int类型的数据
		System.out.println(20+rand.nextInt(10));
	}

}

4.0
3.0
3
4
45
8.0
25.0
32.0
3.141592653589793
2.718281828459045
0.8326619107969313

0.16335470013050146
23

6-File文件类

java.io.File类：文件和目录

①基本使用

package 常用类10;

import java.io.File;
import java.io.IOException;
import java.util.Date;

//File文件类的基本用法
public class TextFile {
	public static void main(String[] args) throws IOException {
		File file=new File("E:\\java语言\\java语言（新）\\跟着哔哩哔哩学习java\\bin\\常用类10\\Filecun\\b.txt");
		//改名
		file.renameTo(new File("E:\\java语言\\java语言（新）\\跟着哔哩哔哩学习java\\bin\\常用类10\\Filecun\\a.txt"));
		System.out.println(file);
		System.out.println(System.getProperty("user.dir"));//用户目录
		File file2=new File("gg.txt");//在默认当前项目下建文件
		file2.createNewFile();//按f5刷新
		
		System.out.println("File是否存在："+file2.exists());
		System.out.println("File是否是目录："+file2.isDirectory());
		System.out.println("File是否是文件："+file2.isFile());
		System.out.println("File最后西修改时间："+new Date(file2.lastModified()));
		System.out.println("File的大小："+file2.length());
		System.out.println("File的文件名："+file2.getName());
		System.out.println("File的目录路径："+file2.getPath());
	}

}

E:\java语言\java语言（新）\跟着哔哩哔哩学习java\bin\常用类10\Filecun\b.txt
E:\java语言\java语言（新）\跟着哔哩哔哩学习java
File是否存在：true
File是否是目录：false
File是否是文件：true
File最后西修改时间：Wed Aug 19 17:23:21 CST 2020
File的大小：0
File的文件名：gg.txt
File的目录路径：gg.txt

②基本方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LMPbn6UJ-1604825393739)(E:\大学课程作业资料汇总\大二下学期\java\笔记\java基础篇\1597831669454.png)]

package 常用类10;

import java.io.File;
import java.io.IOException;
import java.util.Date;

//File文件类的基本用法
public class TextFile {
	public static void main(String[] args) throws IOException {
		
		File file3=new File("e:/测试创建/测试/底层");
		boolean f2=file3.mkdir();//目录结构中有一个不存在，则不会创建整个目录树
		System.out.println(f2);//创建失败
		
		File file4=new File("e:/测试创建/测试/底层");
		boolean f3=file4.mkdirs();//目录结构中一个不存在也没关系，创建整个目录树
		System.out.println(f3);
		file4.delete();//删除文件或目录
	}

}

true

③循环打印目录

package 常用类10;

import java.io.File;

//递归打印目录树
public class TextFile2 {
	public static void main(String[] args) {
		File f=new File("E:\\java语言\\java语言（新）\\跟着哔哩哔哩学习java\\bin");
		printFile(f,0);
	}
	
	static void printFile(File file,int level)//递归打开文件
	{
		
		//输出层数
		for(int i=0;i<level;i++)
		{
			System.out.println("-");//显示几层
		}
		System.out.println(file.getName());
		if(file.isDirectory())//判断是否是目录
		{
			File files[]=file.listFiles();
			for(File temp:files)
			{
				printFile(temp,level+1);
			}
		}
	}

}

05-异常处理

1-异常分类简介

package 异常处理10;
//异常处理
//jre自动捕获异常
//位于java.long
//Erroe Exception
//ArithmeticException 运行性异常==>增加条件判断
//NullPointerException 空对象异常==>增加非空判断
//ClassCastException  引用数据强制转型错误==>增加继承判断
//ArrayIndexOutBoundsExcepyion 数组越界异常==>增加越界判断
//Nu,berFormatException 字符串转基本类型数据字符串格式不正确，数字格式异常==>正则表达式判断是否为数字
public class TestException {
	public static void main(String[] args) {
		/*
		 * Exception in thread "main" java.lang.ArithmeticException: / by zero
	at 异常处理10.TestExample.main(TestExample.java:5)//行数

		int a=1/0;
		System.out.println(a);
		//修改后
		int a=0;
		int b=1;
		if(a!=0)
			System.out.println(b/a);
		*/
		/*
		 * Exception in thread "main" java.lang.NullPointerException
	at 异常处理10.TestException.main(TestException.java:24)
	
		String string=null;
		string.length();
		//修改后
		 if(string!=null)
		 System.out.println(string.lrngth());
		 * 
		*/
		
		/*
		 * Exception in thread "main" java.lang.ClassCastException: 异常处理10.B cannot be cast to 异常处理10.C
	at 异常处理10.TestException.main(TestException.java:37)
	
		A a=new B();
		C c=(C)a;
		//修改后
		A a=new B();
		if(a instanceof B)
		{
		   C c=(C)a;
		}
		
		*/
		
		/*
		 * Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
	at 异常处理10.TestException.main(TestException.java:53)

		int a[]=new int[5];
		int b=5;
		System.err.println(a[b]);
		//修改后
		int a[]=new int[5];
		int b=5;
		if(b<a.length)
		   System.err.println(a[b]);
		*/
	}
}
	
	class A
	{
		
	}
	class B extends A
	{
		
	}
	class C extends A
	{
		
	}

2-异常处理捕获try-catch-finally捕获异常 throws抛出异常，调用者处理

package 异常处理11;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

//已检查异常：
//IOException SQLException 自定义异常
//CheckedException异常在编译时必须做出处理
//try-catch-finally捕获异常  throws抛出异常，调用者处理
public class TestCheckedException {
	public static void main(String[] args) throws IOException {
		/*
		try //抛出异常
		{
			
		} 
		catch (Exception e1) //接受异常，可有多个
		{
			
		}
		finally //异常执行完后一定执行，只有一个
		{
			
		}
		*/
		//try-catch-finally捕获异常
		FileReader reader=null;
		try {
			reader=new FileReader("E:\\java语言\\java语言（新）\\跟着哔哩哔哩学习java\\gg.txt");
			char c1=(char)reader.read();
			System.out.println(c1);
			
		} catch (FileNotFoundException e) {//FileReader异常捕获，子类异常在父类之前
			e.printStackTrace();//打印异常信息
		} catch (IOException e) {//read异常捕获
			e.printStackTrace();
		}finally {
			try {
				if(reader!=null)
					reader.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		//throws抛出异常，调用者处理,往上一层抛
		readMyFile();
		
		
		
	}
	public static void readMyFile() throws IOException
	{
		FileReader reader=null;
		reader=new FileReader("E:\\java语言\\java语言（新）\\跟着哔哩哔哩学习java\\gg.txt");
		char c1=(char)reader.read();
		System.out.println(c1);
		if(reader!=null)
			reader.close();
	}

}

你
你

3-自定义异常

package 异常处理11;
//自定义异常
//继承Exception必须在编译时处理
//继承RuntimeException编译时不进行处理，自定义异常类处理
//层层外抛，最后由最上层处理
public class TestException2 {
	public static void main(String[] args) {
		Person aPerson=new Person();
		//aPerson.setAge(1);
		
	}

}
class Person
{
	private int age;

	public int getAge() {
		return age;
	}

	public void setAge(int age) throws Exception {
		if(age<0)
			throw new lesException("年龄不能为负值");
		this.age = age;
	}	
}
/*
class lesException extends RuntimeException//编译时不处理
{
	public lesException()
	{
		
	}
	public lesException(String a)
	{
		super(a);
	}
}
*/
class lesException extends Exception//编译时处理
{
	public lesException()
	{
		
	}
	public lesException(String a)
	{
		super(a);
	}
}

06-容器数组

1-泛型

数据类型参数化，调用泛型时必须传入参数类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0OdQS5Ws-1604825393741)(E:\大学课程作业资料汇总\大二下学期\java\笔记\java基础篇\1598083565356.png)]

package 容器12;
//泛型
//数据类型参数化，调用泛型时必须传入参数类型
//带数据类型存储数据
public class TextFanxing {
	public static void main(String[] args) {
		Fanxing <String> aa=new Fanxing <String>();
		aa.set("字符", 0);
		
		String bString=aa.get(0);
		
		
	}

}
class Fanxing<E>//此时E就是上面定义时的String//自定义泛型
{
	Object object[]=new Object[5];
	public void set(E ob,int index)//E<==>String
	{
		object[index]=ob;
	}
	public E get(int index)
	{
		return (E)object[index];
	}
}

2-容器泛型

容器要贴标签，标签就是泛型

3-Collection接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oPUyDpHc-1604825393742)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\1598600214758.png)]

01-List接口

001-List接口的实现类ArrayList

（1）List接口的实现类ArrayList的常用方法

①ArrayList底层是用数组实现存储

②特点：查询效率高，增删效率低，线程不安全，一般使用它

③ArrayList可存放任意数量的对象==>定义一个更长的数组，然后拷贝过来，新的放在后面

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OdVCmIj7-1604825393743)(E:\大学课程作业资料汇总\大二下学期\java\笔记\java基础篇\1598164796346.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tshg4Mtw-1604825393744)(E:\大学课程作业资料汇总\大二下学期\java\笔记\java基础篇\1598164978399.png)]

package 容器12;

import java.util.ArrayList;
import java.util.Collection;

//Collection接口中方法
//ArrayList是实现类
public class TextList {
	public static void main(String[] args) {
		Collection<String> c=new ArrayList<String>();
		
		System.out.println(c.size());//返回元素
		System.out.println(c.isEmpty());//判断是否为空
		
		c.add("你好");//添加对象
		c.add("hello");
		System.out.println(c);
		
		System.out.println(c.contains("hello"));//判断是否包含
		
		c.remove("hello");//移除对象，不删除
		System.out.println(c);
		
		Object object[]=c.toArray();//转化成Object数组
		System.out.println(object);
		
		c.clear();//移除所有对象
		System.out.println(c);
	}

}

0
true
[你好, hello]
true
[你好]
[Ljava.lang.Object;@506c589e
[]

（2）多个ArrayList集之间的操作

①并集、交集、包含、含有、减

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B6IP6UcB-1604825393744)(E:\大学课程作业资料汇总\大二下学期\java\笔记\java基础篇\1598165765921.png)]

package 容器12;

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

//Collection接口中方法
//集合并
//相同的删掉
//集合交集
//是否包含
public class TextArrayList2 {
	public static void main(String[] args) {
		List<String> list1=new ArrayList<String>();
		list1.add("aa");
		list1.add("bb");
		list1.add("cc");
		
		List<String> list2=new ArrayList<String>();
		list2.add("aa");
		list2.add("bb");
		list2.add("ee");
		
		System.out.println("list1:"+list1);
		list1.addAll(list2);//把另一个集合里的元素都加进来
		System.out.println("list1："+list1);
		
		list1.removeAll(list2);//把相同的地方删掉
		System.out.println(list1);
		
		list1.retainAll(list2);//交集
		System.out.println(list1);
		System.out.println(list1.containsAll(list2));//list1是否包含list2
		
	}

}

list1:[aa, bb, cc]
list1：[aa, bb, cc, aa, bb, ee]
[cc]
[]

（4）List接口实现类ArrayList索引和顺序相关方法

①List有序、可重复容器

②每个元素都有索引标记，可根据索引精准访问元素

③允许加入重复元素

④List接口常用实现类：ArrayList（数组）、LinkedList（列表）、Vector（线程）

package 容器12;

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

//Collection的List的实现类ArrayList
//索引有关方法
public class TextArrayList3 {
	public static void main(String[] args) {
		List<String> list=new ArrayList<String>();
		list.add("A");
		list.add("B");
		list.add("C");
		
		System.out.println(list);
		
		list.add(1, "0");//在1处插入添加0
		System.out.println(list);
		
		list.remove(1);//删除1处对象
		System.out.println(list);
	    
		list.set(2, "11111");//在2处删除添加11111
		System.out.println(list);
		
		System.out.println(list.get(2));//返回2处对象
		
		list.add("W");
		list.add("Y");
		System.out.println(list.indexOf("W"));//返回索引位置
		
		System.out.println(list.lastIndexOf("A"));//返回最后出现位置的索引
		
	}
}

[A, B, C]
[A, 0, B, C]
[A, B, C]
[A, B, 11111]
11111
3
0

（5）手工实现ArrayList

①简单实现

package 容器12;
//手工实现ArrayList
public class SouGongArrayList {
	private Object elementData[];
	private int size;
	private static final int LENG=10;
	
	public SouGongArrayList()
	{
		elementData=new Object[LENG];
	}
	public SouGongArrayList(int leng)
	{
		elementData=new Object[leng];
	}
	public void add(Object object)
	{
		elementData[size++]=object;
	}
	public String toString()
	{	
		StringBuilder sb=new StringBuilder();
		sb.append("[");
		for(int i=0;i<size;i++)
			sb.append(elementData[i]+",");
		sb.append("]");
		sb.setCharAt(sb.length()-1,']');
		return sb.toString();
	}
	public static void main(String[] args) {
		SouGongArrayList s1=new SouGongArrayList(20);
		s1.add("aa");
		s1.toString();
		System.out.println(s1);
	}

}

[aa,]

②泛型

package 容器12;
//手工实现ArrayList
//泛型
public class SouGongArrayList2<E> {
	private Object elementData[];
	private int size;
	private static final int LENG=10;
	
	public SouGongArrayList2()
	{
		elementData=new Object[LENG];
	}
	public SouGongArrayList2(int leng)
	{
		elementData=new Object[leng];
	}
	public void add(E object)
	{
		elementData[size++]=object;
	}
	public String toString()
	{	
		StringBuilder sb=new StringBuilder();
		sb.append("[");
		for(int i=0;i<size;i++)
			sb.append(elementData[i]+",");
		sb.append("]");
		sb.setCharAt(sb.length()-1,']');
		return sb.toString();
	}
	public static void main(String[] args) {
		SouGongArrayList s1=new SouGongArrayList(20);
		s1.add("aa");
		s1.toString();
		System.out.println(s1);
	}

}

[aa,]

③数组扩容

package 容器12;
//手工实现ArrayList
//泛型
//扩容
public class SouGongArrayList3<E> {
	private Object elementData[];
	private int size;
	private static final int LENG=10;
	
	public SouGongArrayList3()
	{
		elementData=new Object[LENG];
	}
	public SouGongArrayList3(int leng)
	{
		elementData=new Object[leng];
	}
	public void add(E object)
	{
		//扩容
		if(size==elementData.length)
		{
			//怎么扩容
			Object newArray[]=new Object[elementData.length+(elementData.length>>1)];//10+10/2
			System.arraycopy(elementData, 0, newArray, 0, elementData.length);//拷贝
			elementData=newArray;//引用赋值
		}
		elementData[size++]=object;
	}
	public String toString()
	{	
		StringBuilder sb=new StringBuilder();
		sb.append("[");
		for(int i=0;i<size;i++)
			sb.append(elementData[i]+",");
		sb.append("]");
		sb.setCharAt(sb.length()-1,']');
		return sb.toString();
	}
	
	
	public static void main(String[] args) {
		SouGongArrayList3 s1=new SouGongArrayList3(20);
		for(int i=0;i<40;i++)
		{
			s1.add("你"+i);
		}
		System.out.println(s1);
	}

}

④set、get、数组边界检查、删除

package 容器12;
//手工实现ArrayList
//泛型
//扩容
//set和get方法
//数组边界的检查
//删除
public class SouGongArrayList4<E> {
	private Object elementData[];
	private int size;
	private static final int LENG=10;
	
	public SouGongArrayList4()
	{
		elementData=new Object[LENG];
	}
	public SouGongArrayList4(int leng)
	{
		if(leng<0)
		{
			throw new RuntimeException("容器的容量不能是负数");
		}
		else if(leng==0)
		{
			elementData=new Object[LENG];
		}
		else 
		{
			elementData=new Object[leng];
		}
		
	}
	
	public void add(E object)
	{
		//扩容
		if(size==elementData.length)
		{
			//怎么扩容
			Object newArray[]=new Object[elementData.length+(elementData.length>>1)];//10+10/2
			System.arraycopy(elementData, 0, newArray, 0, elementData.length);//拷贝
			elementData=newArray;//引用赋值
		}
		elementData[size++]=object;
	}
	//返回数组
	public E get(int index)
	{
		PaoChu(index);//索引合法判断
		return (E) elementData[index];
	}
	//返回长度
	public int size()
	{
		return size;
	}
	//判断是否为空
	public boolean isEmoty()
	{
		return size==0?true:false;
	}
	//插入对象，索引
	public void set(E element,int index)
	{
		PaoChu(index);//判断索引是否合法
		elementData[index]=element;
	}
	public void PaoChu(int index)
	{
		//索引合法判断[0.size)
				if(index<0||index>size-1)
				{
					//不合法
					throw new RuntimeException("索引不合法"+index);//抛出异常
				}
	}
	//删除元素
	public void remove(E element)
	{
		//element和数组从头到尾比较，获得第一个比较为true的返回
		for(int i=0;i<size;i++)
		{
			if(element.equals(get(i)))//比较操作
			{
				//将该元素从此处移除
				remove(i);
			}
		}
	}
	//移除元素方法
	public void remove(int index)
	{
		//
		if((elementData.length-index-1)>0)
		{
			System.arraycopy(elementData, index+1, elementData, index, elementData.length-index-1);
			elementData[size-1]=null;
			size--;
		}
		else {
			elementData[size-1]=null;
			size--;
		}
	}
	public String toString()
	{	
		StringBuilder sb=new StringBuilder();
		sb.append("[");
		for(int i=0;i<size;i++)
			sb.append(elementData[i]+",");
		sb.append("]");
		sb.setCharAt(sb.length()-1,']');
		return sb.toString();
	}
	
	
	
	
	
	public static void main(String[] args) 
	{
		SouGongArrayList4 s1=new SouGongArrayList4(20);
		for(int i=0;i<40;i++)
		{
			s1.add("你"+i);
		}
	    //s1.set("111", -1);
		s1.remove(3);
		s1.remove("你4");
	    //System.out.println(s1.get(10));
		System.out.println(s1);
	}

}

（6）手工实现LinkedList底层双向链表

①用双向链表存储

②查询效率低，增删效率高，线程不安全

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RW5itsVu-1604825393746)(E:\大学课程作业资料汇总\大二下学期\java\笔记\java基础篇\1598253570651.png)]

①get、add、toString

package 容器12;
//手工实现LinkedList双向链表存储
//get、add、toString
public class SouGongLinkedList1 {
	private Node first;
	private Node last;
	private int size;
	
	public Object get(int index)
	{
		if(index<0||index>size-1)
		{
			throw new RuntimeException("索引数字不合法"+index);
		}
		Node temp=null;
		if(index<(size>>1))// >> /2
		{//从前往后找
			temp=first;
			for(int i=0;i<index;i++)
		    {
			   temp=temp.next;
		    }
		}
		else {//从后往前找
			temp=last;
			for(int i=size-1;i>index;i--)
			{
				temp=temp.previous;
			}
		}
		
		return temp.elements;
	}
	public void add(Object object)
	{
		Node node=new Node(object);//节点创建
		if(first==null)
		{
			node.previous=null;
			node.next=null;
			
			first=node;
			last=node;
		}
		else {
			node.previous=last;//上一个
			node.next=null;//下一个
			
			last.next=node;
			last=node;
		}
		size++;
	}
	public String toString()
	{
		StringBuilder sb=new StringBuilder("[");
		Node temp=first;
		while(temp!=null)
		{
			sb.append(temp.elements+",");
			temp=temp.next;
		}
		sb.setCharAt(sb.length()-1, ']');
		return sb.toString();
	}
	
	
	
	public static void main(String[] args) {
		SouGongLinkedList1 list=new SouGongLinkedList1();
		
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		list.add("e");
		
		
		System.out.println(list.toString());
		System.out.println(list.get(4));
	}
}

[a,b,c,d,e]
e

②remove、add、泛型

package 容器12;
//手工实现LinkedList双向链表存储
//get、add、toString
//remove删除
//插入节点add
//泛型
public class SouGongLinkedList2<E> {
	private Node first;
	private Node last;
	private int size;
	private void PanDuan(int index)//判断索引合法
	{
		if(index<0||index>size-1)
		{
			throw new RuntimeException("索引数字不合法"+index);
		}
	}
	public E get(int index)
	{
		PanDuan(index);
		
		Node temp=getNode(index);
		return temp!=null?(E)temp.elements:null;
	}
	private Node getNode(int index)
	{
		//返回索引
		Node temp=null;
		if(index<(size>>1))// >> /2
		{//从前往后找
			temp=first;
			for(int i=0;i<index;i++)
		    {
			   temp=temp.next;
		    }
		}
		else {//从后往前找
			temp=last;
			for(int i=size-1;i>index;i--)
			{
				temp=temp.previous;
			}
		}
		return temp;
	}
	public void add(E object)
	{
		Node node=new Node(object);//节点创建
		if(first==null)
		{
			node.previous=null;
			node.next=null;
			
			first=node;
			last=node;
		}
		else {
			node.previous=last;//上一个
			node.next=null;//下一个
			
			last.next=node;
			last=node;
		}
		size++;
	}
	//删除元素
	public void remove(int index)
	{
		PanDuan(index);
		Node temp=getNode(index);//获得节点
		if(temp!=null)
		{
			Node up=temp.previous;
			Node down=temp.next;
			if(up!=null)
			{
				up.next=down;
			}
			if(down!=null)
			{
				down.previous=up;
			}
			//被删除的元素的是第一个元素时
			if(index==0)
			{
				first=down;
			}
			//被删除的元素是最后一个元素时
			if(index==size-1)
			{
				last=up;
			}
			size--;
		}
	}
	//插入节点
	public void add(int index,E object)
	{
		PanDuan(index);
		Node newNode=new Node(object);
		Node temp=getNode(index);
		if(temp!=null)
		{
			Node up=temp.previous;
			up.next=newNode;
			newNode.previous=up;
			newNode.next=temp;
			temp.previous=newNode;
		}
	}
	public String toString()
	{
		StringBuilder sb=new StringBuilder("[");
		Node temp=first;
		while(temp!=null)
		{
			sb.append(temp.elements+",");
			temp=temp.next;
		}
		sb.setCharAt(sb.length()-1, ']');
		return sb.toString();
	}
	
	
	
	public static void main(String[] args) {
		SouGongLinkedList2<String> list=new SouGongLinkedList2<String>();
		
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		list.add("e");
		
		list.add(3,"1");
		System.out.println(list.toString());
		System.out.println(list.get(4));
		list.remove(0);
		System.out.println(list.toString());
	}
}


[a,b,c,1,d,e]
e
[b,c,1,d,e]

002-List实现类Vector向量

①用数组实现

②线程安全，效率低

public synchronized int indexof(Object o,int index)
{
       //锁的检查，多线程使用
}

package 容器12;

import java.util.List;
import java.util.Vector;

//底层数组实现，向量，线程安全
//不常用
public class TextVector {
	public static void main(String[] args) {
		List<String> aList=new Vector<String>();
	}

}

02-Set接口

①无序不可重复，重复不可加入

001-Set接口的实现类HashSet

①底层HashMap简化版

（1）HashSet简单使用

package 容器12;

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

//无序不可重复
//直接继承了Collection
public class TextHashSet {
	public static void main(String[] args) {
		Set<String> set=new HashSet<String>();
		
		set.add("aa");
		set.add("bb");
		set.add("cc");
		System.out.println(set);
		set.remove("bb");
		System.out.println(set);
		
	}

}

[aa, bb, cc]
[aa, cc]

（2）手工实现HashSet

package 容器12;
//无序不可重复
//底层HashMap哈希表简化版（就是一个Map）

import java.util.HashMap;

public class SouGongHashSet {
	HashMap map;
	
	private static final Object PER=new Object();
	
	public SouGongHashSet()
	{
		map=new HashMap();
	}
	
	
	public void add(Object o)
	{
		map.put(o, PER);
	}
	public int size()
	{
		return map.size();
	}
	
	@Override
	public String toString() 
	{
		StringBuilder sb=new StringBuilder();
		sb.append("[");
		for(Object key:map.keySet())
		{
			sb.append(key+",");
		}
		sb.setCharAt(sb.length()-1, ']');
		return sb.toString();
	}
	
	public static void main(String[] args) {
		SouGongHashSet set=new SouGongHashSet();
		set.add("aa");
		set.add("bb");
		set.add("cc");
		System.out.println(set);
	}

}


[aa,bb,cc]

002-Set接口的实现类TreeSet

①底层是TreeMap

（1）TreeSet的简单使用

package 容器12;

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

//TreeSet底层是简化版TreeMap（红黑二叉树）
public class TextTreeSet {
	public static void main(String[] args) {
		Set<Integer> set=new TreeSet<Integer>();
		
		set.add(100);
		set.add(200);
		set.add(30);
		
		//排序
		for(Integer ms:set)
		{
			System.out.println(ms);
		}
		
		Set<Emp2> set2=new TreeSet<Emp2>();
		set2.add(new Emp2(100, "li", 3000));
		set2.add(new Emp2(200, "zhao", 4000));
		set2.add(new Emp2(600, "wang", 9000));
		set2.add(new Emp2(300, "zhang", 5000));
		
		for(Emp2 aEmp2:set2)
		{
			System.out.println(aEmp2);
		}
	}

}


//TreeMap
class Emp2 implements Comparable<Emp2>
{
	int id;
	String name;
	double salary;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	public Emp2(int id, String name, double salary) {
		super();
		this.id = id;
		this.name = name;
		this.salary = salary;
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "id:"+id+",name"+name+",salary"+salary;
	}
 
public int compareTo(Emp2 o) {
	//负数：小于  0：等于  正数：大于
  	if(this.salary<o.salary)
  		return 1;
  	else if(this.salary<o.salary)
  		return -1;
  	else {
			if(this.id>o.id)
				return 1;
			else if (this.id<o.id) 
				return -1;
			else 
				return 0;
		}
}

}


30
100
200
id:100,nameli,salary3000.0
id:200,namezhao,salary4000.0
id:600,namewang,salary9000.0
id:300,namezhang,salary5000.0

4-Map接口

①键值对存储，通过键来标识，键不重复

②Map接口的实现类有：HashMap、TreeMap、Properties

（1）Map常用方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Yt1pAUkG-1604825393747)(E:\大学课程作业资料汇总\大二下学期\java\笔记\java基础篇\1598342797038.png)]

001-Map接口的实现类HashMap

哈希表，数组+链表

①HashMap常用方法

package 容器12;

import java.util.HashMap;
import java.util.Map;
//键不重复（重复新覆盖旧）（用equals判断）
//Map接口
//键值对存储
public class TestMap {
	public static void main(String[] args) {
		Map<Integer, String> aMap=new HashMap<Integer, String>();
		aMap.put(1, "one");
		aMap.put(2, "two");
		aMap.put(3, "three");
		System.out.println(aMap.get(1));//获取键值对
		System.out.println(aMap.size());//获取长度
		System.out.println(aMap.isEmpty());//判断是否为空
		System.out.println(aMap.containsKey(1));//是否包含1键
		System.out.println(aMap.containsValue("two"));//是否包含two值
		
		Map<Integer, String> bMap=new HashMap<Integer, String>();
		bMap.put(4, "四");
		bMap.put(5, "五");
		
		aMap.putAll(bMap);//拼接
		System.out.println(aMap);
	
		
		
		Employee e1=new Employee(1001, "王", 50000);
		Employee e2=new Employee(1002, "李", 40000);
		Employee e3=new Employee(1003, "赵", 30000);
		Map<Integer, Employee> map=new HashMap<Integer, Employee>();
		map.put(1001, e1);
		map.put(1002, e2);
		map.put(1003, e3);
		Employee employee=map.get(1001);
		System.out.println(employee);
	}

}

class Employee
{
	private int id;
	private String nameString;
	private double salary;
	public Employee(int id, String nameString, double salary) {
		super();
		this.id = id;
		this.nameString = nameString;
		this.salary = salary;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getNameString() {
		return nameString;
	}
	public void setNameString(String nameString) {
		this.nameString = nameString;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	public String toString()
	{
		return "id:"+id+"name:"+nameString+"salary:"+salary;
	}
	
}

one
3
false
true
true
{1=one, 2=two, 3=three, 4=四, 5=五}
id:1001name:王salary:50000.0

②HashMap底层原理

1、HashMap底层实现采用哈希表

2、数组+链表

③手工实现HashMap

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t42vGdiL-1604825393748)(E:\大学课程作业资料汇总\大二下学期\java\笔记\java基础篇\1598511548400.png)]

package 容器12;
//用于SouGongHashMap
//泛型
public class Node2<K,V> {
	int hash;
	K key;
	V value;
	Node2 next;

}

package 容器12;
//手工实现HashMap（哈希存储）
//数组+链表
//put方法增加键值对并解决重复问题、链表生成
//get方法，根据键对象查找
//泛型
import 容器12.Node2;

public class SouGongHashMap1<K,V> {
	Node2 table[];//位桶数组
	int size;
	public SouGongHashMap1()
	{
		table=new Node2[16];//长度是2的整数次幂
	}
	public void put(K key,V value)
	{
		//定义了新的节点对象
	    Node2 newNode2=new Node2();
		newNode2.hash=myHash(key.hashCode(), table.length);
		newNode2.key=key;
		newNode2.value=value;
		newNode2.next=null;
		
		
		//在对应位置存数据
		Node2 temp=table[newNode2.hash];//位桶的对应位置
		
		Node2 iterLast=null;//正在遍历的最后一个元素
		
		boolean keyRepeat=false;
		if(temp==null)
		{
			//此处数据为空，直接将新节点放进去
			table[newNode2.hash]=newNode2;
			size++;
		}
		else
		{
			//不为空，遍历列表，查看有无相同值
			while(temp!=null)
			{
				//判断key，如果重复就覆盖
				if(temp.key.equals(key))
				{
					//重复了
					temp.value=value;//只覆盖value
					keyRepeat=true;
					break;
				}
				else 
				{
					//key不重复,遍历下一个
					iterLast=temp;
				    temp=temp.next;
				}
				
			}
			if(!keyRepeat)
			{
				iterLast.next=newNode2;//链表尾加元素
				keyRepeat=false;
				size++;
			}
			
		}
		
		
	}
	@Override
	public String toString() 
	{
		StringBuilder sb=new StringBuilder("{");
		
		for(int i=0;i<table.length;i++)
		{
			Node2 temp=table[i];
			while(temp!=null)
			{
				sb.append(temp.key+":"+temp.value+",");
				temp=temp.next;
			}
		}
		sb.setCharAt(sb.length()-1, '}');
		return sb.toString();
	}
	public K get(K key)
	{
		int hash=myHash(key.hashCode(), table.length);
		Object value=null;
		
		if(table[hash]!=null)
		{
			Node2 temp=table[hash];
			while(temp!=null)
			{
				if(temp.key.equals(key))
				{
					//如果相等，就找到的键值对，返回响应的value
					value=(V)temp.value;
					break;
				}
				else
				{
					temp=temp.next;
				}
			}
		}
		return (K) value;
	}
	public static int myHash(int v,int length)
	{
		//返回哈希值，数据在数组中的（位桶）存储位置
		return v&(length-1);//取模运算，效率低
	}
	
	public static void main(String[] args) {
		SouGongHashMap1<Integer,String> m=new SouGongHashMap1<Integer,String>();
		m.put(1001, "aa");
		m.put(1002, "bb");
		m.put(1003, "cc");
		m.put(1001, "dd");
		System.out.println(m.get(1002));
		System.out.println(m.toString());
	}

}

002-Map接口的实现类TreeMap

①用红黑二叉树的典型实现

②线程不安全，效率高，允许key或value为null

③排序时用

package 容器12;

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

//底层用红黑二叉树实现
//TreeMap排序用
public class TextTreeMap {
	public static void main(String[] args) {
		Map<Integer, String> trMap=new TreeMap<Integer, String>();
		trMap.put(1001, "aa");
		trMap.put(1002, "bb");
		trMap.put(1003, "cc");
		
		
		Map<Emp, String> teMap=new TreeMap<Emp, String>();
		teMap.put(new Emp(100, "zhang", 1000000), "打印张");
		teMap.put(new Emp(200, "li", 5000000), "打印张");
		teMap.put(new Emp(300, "wang", 9000000), "打印张");
		//按照key增加的方式排序
		for(Emp key:teMap.keySet())
		{
			System.out.println(key+"----"+teMap.get(key));
		}
		
		
		
	}

}
//TreeMap
class Emp implements Comparable<Emp>
{
	int id;
	String name;
	double salary;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	public Emp(int id, String name, double salary) {
		super();
		this.id = id;
		this.name = name;
		this.salary = salary;
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "id:"+id+",name"+name+",salary"+salary;
	}
    @Override
    public int compareTo(Emp o) {
    	//负数：小于  0：等于  正数：大于
    	if(this.salary<o.salary)
    		return 1;
    	else if(this.salary<o.salary)
    		return -1;
    	else {
			if(this.id>o.id)
				return 1;
			else if (this.id<o.id) 
				return -1;
			else 
				return 0;
		}
    }
}


id:100,namezhang,salary1000000.0----null
id:200,nameli,salary5000000.0----打印张
id:300,namewang,salary9000000.0----打印张

003-Map接口的实现类HashTable

①经常使用，线程安全，效率低不允许key或value为null

②二叉树实现

5-迭代器遍历容器元素（List/Set/Map）

（1）Iterator迭代器

package 容器12;

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

//迭代器遍历容器（List/Set/Map）
public class TextIterator {
	public static void main(String[] args) {
		textIteratorList();//遍历List
		textIteratorSet();//遍历Set
		textIteratorMap();//遍历Map
		textIteratorMap2();
		
	}
	
	//遍历List(数组)
	public static void textIteratorList()
	{
		List<String> list=new ArrayList<String>();
		list.add("aa");
		list.add("bb");
		list.add("cc");
		
		for(Iterator<String> iter=list.iterator();iter.hasNext();)
		{
			String temp=iter.next();//到下一个
			System.out.println(temp);
		}
		
		
	}
	
	//遍历Set（简化的哈希表）
	public static void textIteratorSet()
	{
		List<String> set=new ArrayList<String>();
		set.add("aa");
		set.add("bb");
		set.add("cc");
		
		for(Iterator<String> iter=set.iterator();iter.hasNext();)
		{
			String temp=iter.next();//到下一个
			System.out.println(temp);
		}
	}
	
	//遍历Map1（哈希表）
	public static void textIteratorMap()
	{
		Map<Integer, String> map=new HashMap<Integer, String>();
		map.put(1001,"aa");
		map.put(1002,"bb");
		map.put(1003,"cc");
	    
		Set<java.util.Map.Entry<Integer, String>> ss=map.entrySet();
		
		for(Iterator<java.util.Map.Entry<Integer, String>> iter=ss.iterator();iter.hasNext();)
		{
			java.util.Map.Entry<Integer,String> temp=iter.next();
			System.out.println(temp.getKey()+temp.getValue());
		}
		
	}
	
	//遍历Map2
	public static void textIteratorMap2()
	{
		Map<Integer, String> map2=new HashMap<Integer, String>();
		map2.put(1001,"aa");
		map2.put(1002,"bb");
		map2.put(1003,"cc");
		Set<Integer> keSet=map2.keySet();
		for(Iterator<Integer> iter=keSet.iterator();iter.hasNext();)
		{
			Integer get=iter.next();
			System.out.println(keSet+"----"+map2.get(get));
		}
	}

}


aa
bb
cc
aa
bb
cc
1001aa
1002bb
1003cc
[1001, 1002, 1003]----aa
[1001, 1002, 1003]----bb
[1001, 1002, 1003]----cc

（2）遍历容器方法汇总

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LIDtev6G-1604825393749)(E:\大学课程作业资料汇总\大二下学期\java\笔记\java基础篇\1598606521591.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yciYQbBm-1604825393750)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\1598606792209.png)]

6-Collections工具类

①在java.util.Collections中对Set、List、Map的方法

package 容器12;

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

//Collections工具类（辅助类）
//Collection是接口
public class TextCollections {
	public static void main(String[] args) {
		List<String> list=new ArrayList<String>();
		for(int i=0;i<10;i++)
		{
			list.add("gao"+i);
		}
		System.out.println(list);
		
		Collections.shuffle(list);//随机排列list中内容
		System.out.println(list);
		
		Collections.reverse(list);//逆序排列
		System.out.println(list);
		
		Collections.sort(list);//按递增排序，自定义类使用Comparable接口
		System.out.println(list);
		
		System.out.println(Collections.binarySearch(list, "gao:1"));//二分法查找
	}

}

7-容器存储表格数据

package 容器12;

import java.awt.event.KeyAdapter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

//表格数据存储（几种容器一起使用）
//ORM思想
public class TextBiaoge {
	public static void main(String[] args) {
		Map<String, Object> roow1=new HashMap<String, Object>();
		
		roow1.put("ID", 1001);
		roow1.put("姓名", "张三");
		roow1.put("薪水", 20000);
		roow1.put("入职日期", "2020-1-1");
		
		Map<String, Object> roow2=new HashMap<String, Object>();
		
		roow2.put("ID", 1002);
		roow2.put("姓名", "李四");
		roow2.put("薪水", 30000);
		roow2.put("入职日期", "2020-4-5");
		
        Map<String, Object> roow3=new HashMap<String, Object>();
		
		roow2.put("ID", 1003);
		roow2.put("姓名", "刘武");
		roow2.put("薪水", 40000);
		roow2.put("入职日期", "2020-6-9");
		
		List<Map<String, Object>> table1=new ArrayList<Map<String,Object>>();
		table1.add(roow1);
		table1.add(roow2);
		table1.add(roow3);
		
		for(Map<String,Object> row:table1)
		{
			Set<String> keySet=row.keySet();
			for(String key:keySet)
			{
				System.out.print(key+":"+row.get(key)+"\t");
			}
			System.out.println();
		}
		
		//
		User user1=new User(1001, "张三", 2000, "2020-1-2");
		User user2=new User(1002, "李四", 3000, "2020-3-2");
		User user3=new User(1003, "刘武", 4000, "2020-5-2");
		
		List<User> list=new ArrayList<User>();
		list.add(user1);
		list.add(user2);
		list.add(user3);
		for(User ui:list)
		{
			System.out.println(ui);
		}
		
		//
		Map<Integer, User> map=new HashMap<Integer, User>();
		map.put(1001, user1);
		map.put(1002, user2);
		map.put(1003, user3);
		
		Set<Integer> keIntegers=map.keySet();
		for(Integer ke:keIntegers)
		{
			System.out.println(ke+"----"+map.get(ke));
		}

}
}
class User
{
	private int id;
	private String name;
	private double salary;
	private String hiredate;
	
	//一个完整的javabean要有输入输出方法和空的构造器
	public User(int id, String name, double salary, String hiredate) {
		super();
		this.id = id;
		this.name = name;
		this.salary = salary;
		this.hiredate = hiredate;
	}
	public User()
	{
		
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	public String getHiredate() {
		return hiredate;
	}
	public void setHiredate(String hiredate) {
		this.hiredate = hiredate;
	}
	@Override
	public String toString() {
		return "id:"+id+",name"+name+",salary"+salary+",hiredate"+hiredate;
	}
	
}


姓名:张三	薪水:20000	ID:1001	入职日期:2020-1-1	
姓名:刘武	薪水:40000	ID:1003	入职日期:2020-6-9	

id:1001,name张三,salary2000.0,hiredate2020-1-2
id:1002,name李四,salary3000.0,hiredate2020-3-2
id:1003,name刘武,salary4000.0,hiredate2020-5-2
1001----id:1001,name张三,salary2000.0,hiredate2020-1-2
1002----id:1002,name李四,salary3000.0,hiredate2020-3-2
1003----id:1003,name刘武,salary4000.0,hiredate2020-5-2

wangshuo（24考研上岸版）

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
学习java的基础总结

java语言笔记（基础篇）图片有点多，就没写package 桌球01;import java.awt.Graphics;import java.awt.Image;import java.awt.Toolkit;import java.util.jar.JarFile;import javax.swing.JFrame;public class BallGame2 extends JFrame{ Image ballImage=Toolkit.getDefaultToolkit().
复制链接

扫一扫