Java学习笔记（企业课）

最新推荐文章于 2024-07-24 23:34:03 发布
置顶 最新推荐文章于 2024-07-24 23:34:03 发布
阅读量418 收藏
点赞数 1
分类专栏： 计算机 数据库 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43760243/article/details/115332927
版权

文章目录

1.数据类型

在这里插入图片描述

2.java类的构成

成员变量+构造方法+成员方法
构造方法名与类名相同

常用方法

按alt+shift+s 可调用以下三种方法

都可以选择全部/部分属性来生成
Getter/Setter：生成私有属性的Getter/Setter方法
toString：打印类的属性值
Constructors using field：可直接生成带参的构造方法
在这里插入图片描述
光标移动到需要导包的代码处 按ctrl+shift+o然后回车选择 可快捷导包 并删除导入了无用包的语句

3.思想

封装

修饰符范围：public>protected>default>private
在这里插入图片描述

成员变量封装：将修饰符变成private 然后生成getter/setter方法 其他类通过getter/setter方法取值和设值

成员方法封装：将修饰符变成private 这样其他类就不能再使用该方法

构造方法封装：私有化构造方法,不能通过new的方式创建对象
可重写一个方法让外界访问来创建对象 并升级为静态方法 直接通过类名.方法名调用

其中还涉及到单例模式这一知识点
单例模式：一个类只允许创建一个实例对象，并提供访问其唯一的对象的方式。
目的：避免频繁创建和销毁系统全局使用的对象。
可以用饿汉和懒汉两种模式去实现 代码如下：

Student.Java：

package com.packageConstruct;
public class Student {
    private String name;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	//构造方法私有化
    private Student(){    	
    }
	//懒汉：需要才创建
    static Student student=null;//静态方法只能用静态变量
    public static Student createStudent(){
    	if(student == null){
    		student=new Student();
    		return student;
    	}
    	else return student;
    }
    
    //饿汉：先创建直接返回
    static Student stu=new Student();
    public static Student createStudent2(){
    		return stu;
    }
}

Main.java

public class Main {
   public static void main(String[] args) {	   
	//用饿汉模式
	Student stu=Student.createStudent();
	stu.setName("ah");
	Student stu2=Student.createStudent();
	stu.setName("ab");
	//虽然名字不同 但两个对象是同一个 所以name的值都为ab且stu和stu2的地址一样
	System.out.println(stu.getName()+" "+stu2.getName());
	System.out.println(stu+" "+stu2);
	
	//用懒汉模式
	Student st=Student.createStudent2();
	st.setName("ah");
	Student st2=Student.createStudent2();
	st.setName("ab");
	System.out.println(st.getName()+" "+st2.getName());
	System.out.println(st+" "+st2);
 }
}

static关键字：
添加static可将变量或者方法升级为静态 挂载在类上
挂载在类上的可以使用对象的变量和方法
对象的不能使用类上的变量和方法

继承

继承是为了解决成员变量以及成员方法的重复编写问题

单继承 一个类最多只能继承自一个父类 extends
多实现 一个类可以实现多个接口 逗号隔开接口名即可 implements

子类可以直接使用父类的属性和方法 也可以重写父类的方法
一个类继承一个接口 则需要实现接口中的方法 或者自己也成为一个抽象类

多态

一个父类可以有很多个不同的子类 表现出不同的模样 核心：父类引用实例化子类对象

不同的三种类：
普通类：
类中包含成员变量以及成员方法 (必须实现)
继承之后可直接获取父类的所有东西

抽象类：
抽象类中包含成员变量以及成员方法,并且允许不实现成员方法
如果父类中有抽象方法,则其子类必须实现,或者子类也成为一个抽象类

接口：
只包含抽象方法,以及静态最终变量(常量)

4.异常

在这里插入图片描述
发生异常会使程序运行中断
如果使用try catch将会发生异常的代码包起来之后,不会阻断程序的运行

try{

}catch(){

}finally{

}

try 将会发生异常的代码
catch 发生异常之后做的事情
finally 不管程序是否发生异常 都会执行

5.常用工具类的常用方法

String类

char charAt(int index)//返回char数组指定下标的字符
int indexOf(String str)//返回字符串所在位置的下标
String replace(oldStr,newStr)//返回旧字符替换成新字符串之后的字符串
String[ ] split(String regex)//按照指定字符去分割字符串 得到字符串数组 作为分割的字符会消失
String substring(int beginIndex, int endIndex)//截取指定索引处的子字符串并返回（左闭右开 即不包含左端点）

注意：String类型的数据比较字符串是否相等时需要使用equals()判断

Arrays（排序）

static void sort(int[ ] a) //直接使a数组变得有序
静态方法 直接通过Arrays.sort( )即可使用

Date及相关类

Date
Date date=new Date();等价于Date date=new Date(System.currentTimeMillis());

date.before(Date d1) 如果date的时间比d1早 返回true 反之false
date.after(Date d2) 如果date的时间比d2晚 返回true 反之false
如果两个时间一样 before和after都返回false

SimpleDateFormat
SimpleDateFormat sdf=new SimpleDateFormat(“格式”);//SimpleDateFormat类可用来将date对象按照格式去转化
yyyy-MM-dd HH:mm:ss 表示的格式为年-月-日 时:分:秒

format()方法将日期按照给定格式转为字符串 date->String
parse()方法 根据格式将时间的字符串转为date类型 String->Date

Calendar
Calendar calendar = new GregorianCalendar();

calendar.setTime(date);//calendar对象.setTime()方法 将日期注入到Calendar类
calendar.getTime();//calendar对象.getTime()方法 Calendar->Date
calendar.add(int field,int amount);calendar对象.add()方法可以对日期的年月日时分秒进行加减

  • field参数：
    * Calendar.YEAR 年
    * Calendar.MONTH 月
    * Calendar.DAY_OF_MONTH 日
    * Calendar.HOUR 时
    * Calendar.MINUTE 分
    * Calendar.SECOND 秒

综合实例：

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

public class DateSummary {
  public static void main(String[] args) throws ParseException {
	  //Date常用的就是before after方法 Date date=new Date()等价于Date date=new Date(System.currentTimeMillis())
	  Date date=new Date();
	  Date date2=new Date(System.currentTimeMillis()+10*1000);//相当于现在时间+10s后的时间
	  System.out.println(date);
	  System.out.println(date.before(date2));//现在时间比10s后时间要前 所以返回true
	  System.out.println(date.after(date2));
	  
	  //SimpleDateFormat类可用来将date对象按照格式去转化
	  SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	  //format()方法将日期按照给定格式转为字符串 date->String
	  String s=sdf.format(date);
	  System.out.println(s);
	  //parse()方法 根据格式将时间的字符串转为date类型  String->Date
	  Date d=sdf.parse(s);
	  System.out.println(d);
	  
	  Calendar calendar = new GregorianCalendar();
	  calendar.setTime(date);//calendar对象.setTime()方法 将日期注入到Calendar类
	  Date d2=calendar.getTime();//calendar对象.getTime()方法 Calendar->Date
	  System.out.println(d2);
	  calendar.add(Calendar.YEAR,1);//给年+1
	  calendar.add(Calendar.MONTH,-1);//给月-1
	  Date d3=calendar.getTime();
	  System.out.println(d3);
	  /* add(int field,int amount)
	   * field参数：
	   * Calendar.YEAR 年
	   * Calendar.MONTH	月
	   * Calendar.DAY_OF_MONTH 日
	   * Calendar.HOUR	时
	   * Calendar.MINUTE 分
	   * Calendar.SECOND 秒
	   * */
 }
}

List/Set/Map

List :存储相同类型的数据 有序
Set:存储相同类型的数据 无序 且元素不可重复
Map:存储有对应关系的一组数据 无序 需要有序可用LinkedHashMap

List常用方法：
List可存储同一类型数据 类似数组
list.iterator()获得迭代器指针 .hasNext( )作为判断条件 .next( )取值

  1. 定义：List<Integer> list=new ArrayList<Integer>();
  2. 增： list.add(1);//在数组末尾添加数据 ------------------------ list.add(1,3);//在下标为1的元素后插入元素3
  3. 删：list.remove(2);//删除下标为2的元素
  4. 改：list.set(0, 0);//将下标为0的元素值修改为0
  5. 单个查：list.get(1); //获取下标为1的元素值
  6. 迭代查：
    Iterator it = list.iterator();//list.iterator()获得迭代器指针 .hasNext( )作为判断条件 .next( )取值
    while(it.hasNext()){
    System.out.print(it.next()+" ");}

Set常用方法：
set无序 元素不可重复
set.iterator()获得迭代器指针 .hasNext( )作为判断条件 .next( )取值

  1. 定义：Set<Integer> set=new HashSet<Integer>();
  2. 增： set.add(1); //在集合末尾添加数据
  3. 删：set.remove(2); //删除元素值为2的元素 set只能指定元素去删除
  4. 迭代查：
    Iterator it=set.iterator();//set.iterator()获得迭代器指针 .hasNext( )作为判断条件 .next( )取值
    while(it.hasNext()){
    System.out.println(it.next());}
  5. 清空：set.clear(); //set.clear() 清空set集合

Map常用方法：
Map存储有对应关系的一组数据 key可以唯一确定一个（一组）value
通过map.keySet().iterator得到迭代器 .hasNext( )作为判断条件 .next( )得到key

  1. 定义：Map<Character,Integer> map=new HashMap<Character,Integer>();
  2. 增： map.put(key,value);
  3. 单个查：map.get(key); //得到对应的value;
  4. 迭代查：
    //Iterator的泛型和key的泛型保持一致 value自动与Map中value的类型匹配
    Iterator it=map.keySet().iterator();//通过map.keySet().iterator得到迭代器 .hasNext( )作为判断条件 .next( )得到key
    while(it.hasNext()){
    Character key=it.next();//迭代对象.next得到key
    Integer value=map.get(key);//map.get(key)得到value
    System.out.println(key+"\t"+value);}

List实例：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListTest {
  public static void main(String[] args) {
	List<Integer> list=new ArrayList<Integer>();
	list.add(1);//在数组末尾添加数据
	list.add(2);
	list.add(1,3);//在下标为1的元素后插入元素3
	System.out.println(list);
	list.remove(2);//删除下标为2的元素
	System.out.println(list);
	list.set(0, 0);//将下标为0的元素值修改为0
	System.out.println(list);
	Integer i=list.get(0);//得到下标为0的元素值
	Iterator it = list.iterator();//迭代输出数组里的值
	while(it.hasNext()){
		System.out.print(it.next()+" ");
	}
}
}

Set实例：

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

public class SetTest {
	//set是集合 有互异性 不能存放相同值
  public static void main(String[] args) {
	  Set<Integer> set=new HashSet<Integer>();
	//set.add(元素值)添加元素
	  set.add(1);
	  set.add(2);
	  set.add(3);
	  System.out.println(set);
	  //set.remove(元素值)删去固定元素
	  set.remove(1);//set只能指定特定元素值然后去删除 
	  System.out.println(set);
	  //set.iterator()生成迭代器
	  Iterator<Integer> it=set.iterator();
	  while(it.hasNext()){
		 System.out.println(it.next());
	  }
	  set.clear();//set.clear() 清空set集合
	  System.out.println(set);
	  System.out.println(set.isEmpty());//set.isEmpty()判断set集合是否为空
	  //set没有get方法 只能转成其他类型去get
 }
}

Map实例：

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
//统计字符串中每个字符出现的次数
public class MapTest {
   public static void main(String[] args) {
	String str1="aduhakjfihnioalkfmdszs";
	char[] str=str1.toCharArray();
	Map<Character,Integer> map=new HashMap<Character,Integer>();

	for(char c:str)
	{
		if(null == map.get(c)){
			map.put(c,1);
		}
		else{
			int sum=map.get(c);
			sum++;
			map.put(c,sum);
		}
	}
	//Iterator的泛型和key的泛型保持一致 value自动与Map中value的类型匹配
	Iterator<Character> it=map.keySet().iterator();//通过map.keySet().iterator得到迭代器
	while(it.hasNext()){
		Character key=it.next();//迭代对象.next得到key
		Integer value=map.get(key);//map.get(key)得到value
		System.out.println(key+"\t"+value);
	}
 }
}

Map+List实例：发牌

规则：52张扑克牌 每个人发三张并打印出来 玩家人数不固定

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

public class GoldenFlower {
  public static void main(String[] args) {
	//创建牌 洗牌  发牌 打印出每个人所拥有的牌
	  //创建牌
	 List<String> poker=new ArrayList<String>();
	 for(int i=1;i<14;i++){
		 String size=String.valueOf(i);
		 if(size.equals("1"))
			 size="A";
		 else if(size.equals("11"))
			 size="J";
		 else if(size.equals("12"))
			 size="Q";
		 else if(size.equals("13"))
			 size="K";
		 poker.add("黑桃"+size);
		 poker.add("红心"+size);
		 poker.add("方块"+size);
		 poker.add("梅花"+size);
	 }
	 System.out.println(poker);
	 //洗牌
	 for(int i=0;i<100;i++){
		 Random random=new Random();
		 int one=random.nextInt(52);
		 int two=random.nextInt(52);
		 String onePoker=poker.get(one);
		 String twoPoker=poker.get(two);
		 poker.set(one,twoPoker);
		 poker.set(two,onePoker);
	 }
	 System.out.println(poker);
	 //发牌
	 LinkedHashMap<String,List<String>> map=new LinkedHashMap<String,List<String>>();
	 int peopleNum = 15;
	 for(int i=0;i<peopleNum;i++)
		 map.put("赌王"+i,new ArrayList<String>());
	 System.out.println(map);
	 for(int i=0;i<peopleNum*3;i++)
	 {
		 //先取出这个人手里的牌 然后加上发的牌
		 List<String> pokerOwn=map.get("赌王"+i%peopleNum);
		 String pokerGiveOut=poker.get(i);//获取现在要发的牌
		 pokerOwn.add(pokerGiveOut);
	 }
	 Iterator<String> it=map.keySet().iterator();
	 while(it.hasNext()){
		String key=it.next();
		System.out.println(key);
		List<String> list=map.get(key);
		System.out.println(list);
	 }
 }
}

运行结果：
分别是创建牌结果、洗牌结果、创建每个人所拥有牌的Map结果、给每个人发三张牌之后结果
在这里插入图片描述

6.jdbc对数据库进行增删改查

1.下载mysql-connector-java.jar包
2.打开myeclipse 复制jar包到项目下 任何一个目录都可以 然后右击jar包 bulid path->add to bulid path 结果如下:
在这里插入图片描述
3.理论步骤：
在这里插入图片描述
注：PreparedStatement类中可以?来传参 Statement类只能执行静态sql语句 且PreparedStatement是预编译的 对于批量处理可以大大提高效率所以用PreparedStatement即可

4.常用代码
实际操作中前两句是固定的 所以一般被作成工具类 其他类直接调用即可

工具类代码：//这里有一个数据库名需要改

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class JdbcUtil{
	public static Connection getCon(){
		try {
			//1.加载mysql驱动
			Class.forName("com.mysql.jdbc.Driver");
			//2.获取数据库连接
			Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/数据库名?useUnicode=true&characterEncoding=utf-8", "root", "root");
			return con;
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		catch (SQLException e) {
			e.printStackTrace();
		}
		return null;
	} 
}

调用方法：
需要获取数据库的类中直接输入以下代码即可获得连接：

Connection con = JdbcUtil.getCon();

java操作数据库常用代码：

查询类：
步骤：
1.获取数据库连接 Connection con = JdbcUtil.getCon();
2.编写sql String sql = "select 列名1,列名2 from 表名 where name=?";
3.定义PreparedStatement和ResultSet对象分别为ps和res并设置为空：
4.ps向数据库发送sql语句 ps = con.prepareStatement(sql);
5.sql有参就用ps传参 ps.setString(参数序号, 参数值);
6.数据库查询的结果发给res 然后res.next()去迭代 res.getString( )或者res.getInt( )去获取值

查 代码：

        Connection con = JdbcUtil.getCon();
        //不要写select * 以防后期打印出结果却不知道对应哪个属性
		String sql = "select 列名1,列名2 from 表名 where name=?";
		PreparedStatement ps = null;
		ResultSet res = null;
		try {
			ps = con.prepareStatement(sql);
			ps.setString(1, name);//表示给sql的第一个参数赋值name
			res = ps.executeQuery();
			if(res.next()){//这里查询结果应该是一条数据用if 多条应该用while
				res.getString(1);//获得第一列的数据
				res.getString("name");//获得第二列的数据 第二列列名为name
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	  }

增删改类：
步骤：
1.获取数据库连接
2.编写sql
3.定义PreparedStatement对象ps并设置为空：
4.如果sql有参就传参 然后ps.execute()向数据库发送sql语句
5.没有异常则操作成功

增 代码：

		Connection con = JdbcUtil.getCon();
		String sql = "insert into 表名 (列名x,列名y) values(?,?)";
		PreparedStatement ps = null;
		try {
			ps = con.prepareStatement(sql);
			ps.setString(1,"想传的参数");
			ps.setString(2,"想传的参数");
			ps.execute();
		} catch (SQLException e) {
			e.printStackTrace();
		}

改 代码：

		Connection con = JdbcUtil.getCon();
		String sql = "update 表名 set 属性名=新属性值 where 条件;";
		PreparedStatement ps = null;
		try {
			ps = con.prepareStatement(sql);
			ps.setString(1,"想传的参数");//可有可无
			ps.execute();
		} catch (SQLException e) {
			e.printStackTrace();
		}

删 代码：（关联表删除要考虑中间异常 编写回滚语句）

原理：
因为在删除时可能会有相关联的表 需要先删除副表(两个表的关系表) 再删除主表
而可能删除完副表数据之后发生异常导致主表数据未能被删除 此时应该执行回滚操作 恢复到副表被删除前
所以代码需要先关闭数据库操作自动提交 主表也删除后再手动提交 代码如下：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class delete {
	public static void main(String[] args) throws SQLException {
		Connection con = JdbcUtil.getCon();
		PreparedStatement ps = null;
		try {
			con.setAutoCommit(false);//关闭自动提交
			String sql = "delete from 副表名 where 副表属性 = (select 主副表皆有属性 from 主表名 where 主表属性=?)";
			ps = con.prepareStatement(sql);
			ps.setString(1, "要删除属性的参数");
			ps.execute();
			
			//假设两条sql中间会发生异常
			
			sql = "delete from 主表名 where 属性=?";//删除主表
			ps = con.prepareStatement(sql);
			ps.setString(1, "要删除属性的参数");
			ps.execute();
			con.commit();//主表也删除成功 手动提交
		} catch (Exception e) {
			e.printStackTrace();
				con.rollback();//回滚操作
		} finally{
			ps.close();
			con.close();
		}	
	}
}

注：异常有些多 就直接主函数那里抛出SQLException了

7.综合实例 学生选课

点这里跳转

羽凌fairy
关注
专栏目录
java学习笔记-第一课
weis_2007的博客
07-25 819
Java 是什么Java 是一种高级编程语言，由 Sun Microsystems（现为 Oracle）开发。它是跨平台的，即“写一次，处处运行”（Write Once, Run Anywhere, WORA）。Java 广泛用于开发企业级应用、移动应用（Android）、Web 应用等。
java学习笔记-第十课
最新发布
weis_2007的博客
07-31 690
Spring 框架：一个开源的 Java 应用程序框架，提供了全面的基础设施支持，主要用于开发企业级应用程序。核心功能：依赖注入（DI）、面向切面编程（AOP）、数据访问框架（JDBC、JPA）、MVC Web 应用程序开发。：一个简化 Spring 应用程序开发的框架，提供了一种快速创建独立、生产级 Spring 应用的方式，开箱即用。：一种架构风格，常用于构建基于 HTTP 的 Web 服务。：符合 REST 架构风格的 API。
Java学习笔记（持续更新中）
m0_73384617的博客
01-08 1090
知识来源于B站“黑马程序员”Java课程，笔记整理自用，也希望能帮助到更多想学习Java的人，欢迎各位大佬批评指正。本文适合有一定C语言基础的读者阅读，与C语言有相同之处的内容会简述或略过，建议零基础的读者去听视频课。涉及到计算机系统相关知识的部分也不做详细解释，之后会出计算机系统的专篇，也可能会在此文中补充。
狂神说java java基础篇 学习笔记
weixin_45975667的博客
03-29 1954
狂神说java java基础篇学习笔记，包括了狂神基础视频的所有内容
Java学习笔记
weixin_44060031的博客
02-10 184
Java学习第一课 Day_01 近日报了中公的Java培训班，但是因为最近新型冠状病毒肆虐，没有办法前往北京中 公基地进行学习，所以学校给我们报了名的 学生安排了为期N久的线授课，进行Java基础的教授和培训。今天是开课第一天，写下我今日学习心得。 Java概述 1.定义：Java是一种面向对象、支持泛型编程也支持跨平台技术的一门高级编程语言。（简言之：Java是一门高级编程语言） ...
黑马java学习笔记1(阶段一 第一章1-1~1-4 08)
xiaozhuzhu__的博客
07-09 1272
黑马程序员Java学习路线：Java基础 → JavaWeb → 热门框架 → 苍穹外卖 → 服务框架 → 天机学堂 → 立可得→ 面试专题
黑马程序员笔记：小白必看——Java学习路线
Future_yzx的博客
07-24 595
Java面试宝典（含阿里、腾迅大厂java面试真题，java数据结构，java并发，jvm等java面试真题）以100+企业大厂真实高频Java面试真题为主干，辅以数据结构的可视化展示、算法的可视化展示，窥探底层的工具使用等等可视化手段，用直观、形象的方式展现复杂的知识内容，让学生更清晰、更容易地掌握这些Java面试题与Java知识点。同时在多通道的加持下，通过智能动态的通道评级、选举、降级、热插拔，增强了系统的健壮性，摆脱对单一通道的依赖，并且提供多种对接方式，满足企业内部的各种需求。
史上最强 Java 学习路线图！
热门推荐
沉默王二
04-24 28万+
网上看到一首诗：“代码尽头谁为峰，一见秃头道成空。编程修真路破折，一步一劫渡飞升。”感觉还挺有意境的。 第一部分：Java 基础篇 这个阶段就是编程入门，掌握 Java 这门编程语言的基本语法，为后面的修行之路打好基础。 包括的知识点有： 环境搭建——Intellij IDEA 一站式搞定 Java 基础语法 面向对象——封装、继承、多态 数组 字符串 集合框架 IO 反射 注解 网络编程 并发编程 这方面的资源我给大家梳理下： 1）针对 Intellij IDEA，GitHub 上有一份简体中文版教
java基础学习笔记
4年java开发的成长记录
02-28 1334
java基础学习笔记从0到入门
Java 学习笔记（二十一）
csdn_muxin的博客
01-15 778
正则表达式
Java基础尚硅谷宋红康学习笔记
05-29
9. **Spring框架**：Spring是Java企业级应用的主流框架，提供依赖注入、AOP、数据访问、Web应用等功能。 10. **Java并发编程**：包括线程池、锁机制（如synchronized、ReentrantLock）、并发容器（如...
2023年java学习笔记课后选择答案整理.doc
11-06
Java有三个主要的平台：Java Standard Edition (SE) 用于桌面应用，Java Enterprise Edition (EE) 针对服务器和大型企业应用，而Java Micro Edition (ME) 则设计用于嵌入式设备和移动应用。Android虽然使用了Java...
java学习笔记
07-30
【Java学习笔记】是针对Java编程语言的一份详尽的学习资料，主要由“圣思源”提供，旨在帮助初学者和进阶者深入理解和掌握Java技术。这份笔记可能包含了从基础语法到高级特性的全面讲解，结合了理论与实践，通过实例...
《IT学习资料》-java后端学习笔记.zip
04-02
6. **Java基础**：这部分可能涵盖了Java语言的基本语法、数据类型、控制结构、类与对象、异常处理等内容，是所有Java学习者的必修课。 7. **SQL优化**：SQL优化是数据库性能调优的重要环节，可能包括索引的使用、...
Navicat for MySQL 15安装及使用
qq_43760243的博客
04-03 6393
文章目录安装教程：使用方法：1.新建数据库连接2.打开连接3.查看数据库中的表4.双击表名可看到表中数据5.操作数据库6.导出数据库7.导入数据库 安装教程： 激活教程：这里 安装包及注册机：（64位是x64 32位是x86 注册机通用） 链接：https://pan.baidu.com/s/1v3ZRhYuYdDRS2YG0xq1KYg 提取码：85vh 使用方法： 1.新建数据库连接 左上角连接->mysql->输入连接名和mysql密码->确定 2.打开连接 右击新建的连接名-&g
jsp实验代码
qq_43760243的博客
12-17 2399
文章目录实验一 计算器1.简单的登录页面（login.jsp）2.登录检测页面（loginCheck.jsp）3.计算器页面(jsq.jsp)4.计算结果显示页面（count.jsp）实验二 时间显示实验三 javaBean实验四 留言板 实验一 计算器 内容：先登录并验证身份 验证成功提供计算器功能 账号：111 密码：123 1.简单的登录页面（login.jsp） <%@ page language="java" import="java.util.*" pageEncoding="
学生选课系统项目笔记
qq_43760243的博客
04-17 1989
数据库 表： userlist 存储管理员/学生/教师的登录账号和密码 adminlist/teacherlist/studentlist/courselist 存储管理员/教师/学生/课程的信息 sclist 存储选课记录 视图： 查看所有课程的视图：course_all 知识点：左连接而不是直接从两表查 这样有一个数据删除时不会直接少记录 只会缺值 select courselist.cno,cname,ctype,ccredit,cnum,courselist.tno,tname,tdept,b
java学习前的准备
qq_43760243的博客
02-12 1859
文章目录下载JDK并安装配置环境变量打开配置界面系统变量用户变量检测是否配置成功编译和运行java文件简单的java程序代码 下载JDK并安装 链接：https://pan.baidu.com/s/1snQ8Le9DyVd4eS-K_VQsIA 提取码：7g91 安装时记下安装目录 一般默认为C:\Program Files\JAVA\jdk1.8.0_201 配置环境变量 打开配置界面 右击我的...
"2023年Java学习笔记课后选择答案整理及考点梳理
2023年，Java学习笔记课后选择答案整理.doc文件提供了一些关于Java技术规格和语言特性的选择题，并通过选项的形式进行了答案整理。以下是对该文件中提出的问题的总结。 问题一：哪个组织负责监督审察Java相关技术...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值