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();//调painttry {Thread.sleep(15);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}public static void main(String[] args) {BallGame2 game=new BallGame2();game.zhuomian();}}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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("请输入正常的年龄");}}//一般函数,权限使用publicpublic 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;//游戏持续时间@Overridepublic 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{@Overridepublic void run() {// TODO Auto-generated method stubsuper.run();while(true){repaint();//重画try {Thread.sleep(40);//停止时间}catch(InterruptedException e){e.printStackTrace();}}}}//键盘监听的内部类class KeMonitor extends KeyAdapter{@Overridepublic void keyReleased(KeyEvent e) {//抬起那个键super.keyTyped(e);//System.out.println("抬起"+e.getKeyCode());//获取抬起的那个键plane.minusDirection(e);}@Overridepublic 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() {@Overridepublic void windowClosing(WindowEvent e) {//关闭时候操作// TODO Auto-generated method stubSystem.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
{@Overridepublic 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//实现多个接口//多继承接口
{@Overridepublic void test() {System.out.println("实现接口的方法");System.out.println("接口中定义的静态常量"+a);//接口中定义的静态常量}@Overridepublic 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);//复制到字符串a2System.out.println(a1);System.out.println(a2);//编译器优化，在编译时直接进行拼接String a3="hello"+"word";//hellowordString a4="helloword";System.out.println(a3==a4);//trueString 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.83266191079693130.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 zeroat 异常处理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.NullPointerExceptionat 异常处理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.Cat 异常处理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: 5at 异常处理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 blocke.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处插入添加0System.out.println(list);list.remove(1);//删除1处对象System.out.println(list);list.set(2, "11111");//在2处删除添加11111System.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/2System.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/2System.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();}@Overridepublic 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;}@Overridepublic String toString() {// TODO Auto-generated method stubreturn "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;//只覆盖valuekeyRepeat=true;break;}else {//key不重复,遍历下一个iterLast=temp;temp=temp.next;}}if(!keyRepeat){iterLast.next=newNode2;//链表尾加元素keyRepeat=false;size++;}}}@Overridepublic 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)){//如果相等，就找到的键值对，返回响应的valuevalue=(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;}@Overridepublic String toString() {// TODO Auto-generated method stubreturn "id:"+id+",name"+name+",salary"+salary;}@Overridepublic 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();//遍历ListtextIteratorSet();//遍历SettextIteratorMap();//遍历MaptextIteratorMap2();}//遍历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());}}//遍历Map2public 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;}@Overridepublic 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

学习java的基础总结相关推荐

Java零基础学习Java编程语言基础知…
很多Java编程初学者在刚接触Java语言程序的时候,不知道该学习掌握哪些必要的基础知识.下面就说说Java零基础学习Java编程语言基础知识的几个要点.希望能够对Java编程基础入门学习的新手有帮助 ...
Java学习-Java语言基础
Java学习-Java语言基础 1.Java符号集 1.1Java标识符 1.2关键字 1.3分割符和注释 2.java 数据类型 2.1整型 2.1.1整型常量 2.1.2整型变量 ...
学习JAVA的基础和知识点总结
JA学习JAVA基础和知识点总结 JAVA如何安装jdk? (JDK=jdk+jre) 1.下载对应于自己电脑配置的 jdk(如64位或者32位): 2.点击安装 3.安装路径自己可以选择(如D:ja ...
五、吃掉Java基本数据类型，学习Java的基础
@Author:Runsen @Date:2020/5/20 Java是一个强类型语言,Java中的数据必须明确数据类型.在Java中的数据类型包括基本数据类型和引用数据类型两种. 我是天天看菜鸟和W ...
【转】Java学习---Java Web基础面试题整理
[原文]https://www.toutiao.com/i6592359948632457731/ 1.什么是Servlet? 可以从两个方面去看Servlet: a.API:有一个接口servlet ...
java入门慕路径,Java入门基础知识总结学习教程大全【必看经典】
类型的表达式,是循环条件,表达式3是党执行了一遍循环之后,修改控制循环的变量值. ??? for语句的执行过程是这样的:首先计算表达式1,完成必要的初始化工作:然后判断表达式2的值,如果表达式的值为t ...
【J2ME 2D 游戏开发系列】◣HIMI游戏开发启蒙教程◢JAVA零基础学习J2ME游戏开发全过程!...
本站文章均为李华明Himi 原创,转载务必在明显处注明: 转载自[黑米GameDev街区] 原文链接: http://www.himigame.com/j2me-2/774.html Himi从写 ...
java学习需要英文基础吗,详细说明
零基础大学生怎么学习Java?零基础大学生怎么学习Java?很多大学生在快毕业的时候,非常迷茫自己的未来职业规划和发展,不知道如何选择.希望有人可以可以帮助自己少这就和我们学习的语文和英语一样,汉语 ...
java编程学习方法_在线学习Java编程的最佳方法
java编程学习方法 1.简介 Java是使用最广泛的编程语言之一. 根据Github的最新报告 ,Java被列为仅次于JavaScript的第二大最常用的编程语言. 掌握Java的人有很多话题. 好 ...