一、基础语法
1.数据类型
2.类型转换
（1）自动类型转换
（2）强制类型转换（有可能会数据丢失）
3.运算符（普通运算符类似数学中的运算符）
条件运算符
运算符优先级
3.数组
1、 声明数组
语法： 数据类型[ ] 数组名；
或者 数据类型 数组名[ ]；
其中，数组名可以是任意合法的变量名，如：
2、 分配空间
简单地说，就是指定数组中最多可存储多少个元素
语法： 数组名 = new 数据类型 [ 数组长度 ];
其中，数组长度就是数组中能存放元素的个数，如：
话说，我们也可以将上面的两个步骤合并，在声明数组的同时为它分配空间，如：
3、 赋值
分配空间后就可以向数组中放数据了，数组中元素都是通过下标来访问的，例如向 scores 数组中存放学生成绩
4、 处理数组中数据
我们可以对赋值后的数组进行操作和处理，如获取并输出数组中元素的值
在 Java 中还提供了另外一种直接创建数组的方式，它将声明数组、分配空间和赋值合并完成，如
它等价于：
4.foreach语法
二、类与对象
1.static
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。
程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行构造方法。由于静态初始化块只在类加载时执行一次。
2.内部类
内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。
内部类的主要作用如下：
1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据
3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便
内部类可分为以下几种：
- 成员内部类
- 静态内部类
- 方法内部类
- 匿名内部类
HelloWorld hello = new HelloWorld();
// 创建内部类对象
Inner i = hello.new Inner();
创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();
3.字符串
String 对象创建后则不能被修改，是不可变的，所谓的修改其实是创建了新的对象，所指向的内存空间不同。如下所示：
String 类的常用方法：
StringBuffer 是线程安全的，而 StringBuilder 则没有实现线程安全功能，所以性能略高。
StringBuilder 类提供了很多方法来操作字符串：
在程序开发中，我们经常需要在基本数据类型和字符串之间进行转换。
其中，基本类型转换为字符串有三种方法：
1. 使用包装类的 toString() 方法
2. 使用String类的 valueOf() 方法
3. 用一个空字符串加上基本类型，得到的就是基本类型数据对应的字符串
再来看，将字符串转换成基本类型有两种方法：
1. 调用包装类的 parseXxx 静态方法
2. 调用包装类的 valueOf() 方法转换为基本类型的包装类，会自动拆箱
使用 parse() 方法将文本转换为日期
使用 format() 方法将日期转换为指定格式的文本
常用的方法：
二、集合框架
ListTest
package testCollection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Iterator;
public class ListTest {
public List coursesToSelect;
public ListTest() {
this.coursesToSelect = new ArrayList();
}
/*往List中添加元素*/
public void Add() {
Course cr1 = new Course("1","数据结构");
coursesToSelect.add(cr1);
Course temp =(Course)(coursesToSelect.get(0));
System.out.println("添加了课程:" + temp.id + ":" + temp.name);
Course cr2 = new Course("2","C语言");
coursesToSelect.add(0, cr2);
Course temp1 =(Course)(coursesToSelect.get(0));
System.out.println("添加了课程:" + temp1.id + ":" + temp1.name);
//以下会产生数组越界异常
// Course cr3 = new Course("3","C++");
// coursesToSelect.add(3, cr3);
Course[] course = {new Course("3","离散数学"),new Course("4","汇编语言")};
coursesToSelect.addAll(Arrays.asList(course));
Course temp3 =(Course)coursesToSelect.get(2);
System.out.println("添加了课程:" + temp3.id + ":" + temp3.name);
Course temp4 =(Course)coursesToSelect.get(3);
System.out.println("添加了课程:" + temp4.id + ":" + temp4.name);
Course[] course1 = {new Course("5","机器学习"),new Course("6","计算机网络")};
coursesToSelect.addAll(2,Arrays.asList(course1));
Course temp5 =(Course)coursesToSelect.get(2);
System.out.println("添加了课程:" + temp5.id + ":" + temp5.name);
Course temp6 =(Course)coursesToSelect.get(3);
System.out.println("添加了课程:" + temp6.id + ":" + temp6.name);
}
/**
* 取出List中的元素*/
public void testGet() {
int size = coursesToSelect.size();
for (int i=0;i<size;i++) {
Course cr = (Course)coursesToSelect.get(i);
System.out.println("课程：" + cr.id + ":" + cr.name);
}
}
/**
* 通过迭代器遍历List
*/
public void testIterator(){
Iterator it = coursesToSelect.iterator();
System.out.println("有如下课程待选(通过迭代器访问):");
while (it.hasNext()) {
Course cr = (Course)it.next();
System.out.println("课程：" + cr.id + ":" + cr.name);
}
}
/**
* 通过for each方法访问集合元素
* @param args
*/
public void testForEach() {
System.out.println("有如下课程待选(通过for each访问):");
for (Object obj:coursesToSelect) {
Course cr = (Course)obj;
System.out.println("课程：" + cr.id + ":" + cr.name);
}
}
/**
* 课程修改
* @param args
*/
public void testModify() {
coursesToSelect.set(4, new Course("7","毛概"));
testForEach();
}
/**
* 课程删除
* @param args
*/
public void testRemove() {
Course cr = (Course)coursesToSelect.get(4);
System.out.println("我是课程:" + cr.id + ":" + cr.name + " 我即将被删除");
coursesToSelect.remove(cr);//也可以把cr换成索引位置4，不过要考虑越界问题。
System.out.println("成功删除");
testForEach();
}
public void testRemoveAll() {
System.out.println("即将删除4和5位置上的课程");
Course[] courses = {(Course)coursesToSelect.get(4),(Course)coursesToSelect.get(5)};
coursesToSelect.removeAll(Arrays.asList(courses));
System.out.println("成功删除");
testForEach();
}
public static void main(String[] args) {
ListTest lt = new ListTest();
lt.Add();
lt.testGet();
lt.testIterator();
lt.testForEach();
lt.testModify();
lt.testRemove();
}
}
SetTest
package testCollection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
public class SetTest {
public List<Course> coursesToSelect;
public SetTest() {
coursesToSelect = new ArrayList<Course>();
}
/**
* 往List中添加元素
* */
public void Add() {
Course cr1 = new Course("1","数据结构");
coursesToSelect.add(cr1);
Course temp =(Course)(coursesToSelect.get(0));
//System.out.println("添加了课程:" + temp.id + ":" + temp.name);
Course cr2 = new Course("2","C语言");
coursesToSelect.add(0, cr2);
Course temp1 =(Course)(coursesToSelect.get(0));
//System.out.println("添加了课程:" + temp1.id + ":" + temp1.name);
//以下会产生数组越界异常
//Course cr3 = new Course("3","C++");
//coursesToSelect.add(3, cr3);
Course[] course = {new Course("3","离散数学"),new Course("4","汇编语言")};
coursesToSelect.addAll(Arrays.asList(course));
Course temp3 =(Course)coursesToSelect.get(2);
//System.out.println("添加了课程:" + temp3.id + ":" + temp3.name);
Course temp4 =(Course)coursesToSelect.get(3);
//System.out.println("添加了课程:" + temp4.id + ":" + temp4.name);
Course[] course1 = {new Course("5","机器学习"),new Course("6","计算机网络")};
coursesToSelect.addAll(2,Arrays.asList(course1));
Course temp5 =(Course)coursesToSelect.get(2);
//System.out.println("添加了课程:" + temp5.id + ":" + temp5.name);
Course temp6 =(Course)coursesToSelect.get(3);
//System.out.println("添加了课程:" + temp6.id + ":" + temp6.name);
}
/**
* 通过for each方法访问集合元素
* @param args
*/
public void testForEach() {
System.out.println("有如下课程待选(通过for each访问):");
for (Object obj:coursesToSelect) {
Course cr = (Course)obj;
System.out.println("课程：" + cr.id + ":" + cr.name);
}
}
/**
* 测试List的contains方法
*/
public void testListContains() {
Course course = coursesToSelect.get(0);
System.out.println("取得课程:" + course.name);
System.out.println("备选课程中是否包含课程:" + course.name + "," + coursesToSelect.contains(course));
}
public static void main(String[] args) {
// TODO Auto-generated method stub
SetTest st = new SetTest();
st.Add();
st.testForEach();
Student stu = new Student("1","小明");
System.out.println("欢迎学生: " + stu.name + "来选课");
Scanner sc = new Scanner(System.in);
for (int i=0;i<3;i++) {
System.out.println("请输入课程ID:");
String courseId = sc.next();
for (Course cr:st.coursesToSelect) {
if (cr.id.equals(courseId)) {
stu.courses.add(cr);
}
}
}
for (Course cr:st.coursesToSelect) {
System.out.println("学生已选课程：" + cr.id + ":" + cr.name);
}
}
}
MapTest
package testCollection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
public class MapTest {
public Map<String, Student> students;
/**
* 在构造器中初始化students
* @param args
*/
public MapTest() {
this.students = new HashMap<String, Student>();
}
/**
* 测试添加：输入学生ID，判断是否被占用，
* 若没有则输入学生姓名，创建新的学生对象，添加到students属性中去
* @param args
*/
public void testPut() {
Scanner sc = new Scanner(System.in);
int i = 0;
while (i < 3) {
System.out.println("请输入学生ID:");
String ID = sc.next();
Student st = students.get(ID);
if (st == null) {
System.out.println("请输入学生姓名：");
String name = sc.next();
Student newStudent = new Student(ID,name);
students.put(ID,newStudent);
System.out.println("成功添加学生: " + students.get(ID).name);
i++;
}else {
System.out.println("该ID已被占用");
continue;
}
}
}
/**
* 测试MAp的keyset方法
* @param args
*/
public void testKeySet() {
//通过keySet方法返回Map中的key的集合
Set<String> keySet = students.keySet();
//取得students的容量
System.out.println("总共有" + students.size() + "个学生");
//遍历keySet,取得每一个key,在调用get方法,取得每一个键的value
for (String stuID:keySet) {
Student st = students.get(stuID);
if (st != null) {
System.out.println("学生:" + st.name);
}
}
}
/**
* 测试删除
* @param args
*/
public void testRemove() {
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请输入要删除的学生ID:");
String ID = sc.next();
Student st = students.get(ID);
if (st == null) {
System.out.println("该ID不存在");
continue;
}
students.remove(ID);
System.out.println("成功删除学生:" + st.name);
break;
}
}
/**
* 通过entrySet返回所有键值对的集合
* @param args
*/
public void testEntrySet() {
Set<Entry<String, Student>> entrySet = students.entrySet();
for (Entry<String, Student> entry:entrySet) {
System.out.println("取得键:" + entry.getKey());
System.out.println("对应值为:" + entry.getValue().name);
}
}
/**
* 测试修改
* @param args
*/
public void testModify() {
System.out.println("请输入要修改的学生ID:");
Scanner sc = new Scanner(System.in);
while (true) {
String Id = sc.next();
Student st = students.get(Id);
if (st == null) {
System.out.println("该ID不存在，请重新输入");
continue;
}
System.out.println("该学生当前姓名为:" + st.name);
System.out.println("请输入新的学生姓名");
String name = sc.next();
Student newStudent = new Student(Id, name);
students.put(Id, newStudent);
System.out.println("修改成功");
break;
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
MapTest mt = new MapTest();
mt.testPut();
mt.testKeySet();
mt.testModify();
mt.testEntrySet();
mt.testRemove();
mt.testEntrySet();
}
}
CollectionTest
package testCollection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
public class CollectionsTest {
/**
* 对Integer类型的泛型进行排序
* @param args
*/
public void testSort1() {
List<Integer> intList = new ArrayList<Integer>();
Random random = new Random();
Integer k;
for (int i=0;i<10;i++) {
do {
k=random.nextInt(100);
}while(intList.contains(k));
intList.add(k);
System.out.println("成功添加整数:" + k);
}
System.out.println("--------排序前----------");
for (Integer integer:intList) {
System.out.println("元素:" + integer);
}
Collections.sort(intList);
System.out.println("---------排序后------------");
for (Integer integer:intList) {
System.out.println("元素:" + integer);
}
}
/**
* 对String类型排序
* @param args
*/
public void testSort2() {
List<String> strList = new ArrayList<String>();
strList.add("Microsoft");
strList.add("Iphone");
strList.add("Lenovo");
System.out.println("--------排序前----------");
for (String string:strList) {
System.out.println("元素:" + string);
}
Collections.sort(strList);
System.out.println("---------排序后------------");
for (String string:strList) {
System.out.println("元素:" + string);
}
}
/**
* 对Student类排序
* @param args
*/
public void testSort3() {
List<Student> stuList = new ArrayList<Student>();
Random random = new Random();
stuList.add(new Student(random.nextInt(1000)+"","xiaoming"));
stuList.add(new Student(random.nextInt(1000)+"","xiaohong"));
stuList.add(new Student(random.nextInt(1000)+"","xiaoqiang"));
System.out.println("--------排序前----------");
for (Student stu:stuList) {
System.out.println("学号:" + stu.id + " " + "姓名:" + stu.name);
}
Collections.sort(stuList);
System.out.println("--------排序后----------");
for (Student stu:stuList) {
System.out.println("学号:" + stu.id + " " + "姓名:" + stu.name);
}
Collections.sort(stuList, new StudentComparator());
System.out.println("按照姓名排序后:");
for (Student stu:stuList) {
System.out.println("学号:" + stu.id + " " + "姓名:" + stu.name);
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
CollectionsTest ct = new CollectionsTest();
//ct.testSort1();
//ct.testSort2();
ct.testSort3();
}
}
JDBCTest
package test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class testJDBC {
public static void main(String[] args) {
try {
Class.forName("com.mysql.cj.jdbc.Driver");
System.out.println("成功加载JDBC驱动!");
}catch(ClassNotFoundException e){
System.out.println("没有找到JDBC驱动");
e.printStackTrace();
}
String sql = "jdbc:mysql://localhost:3306/test?serverTimezone=UTC&useSSL=false";
Connection con;
try {
con = (Connection)DriverManager.getConnection(sql, "root", "123456");
Statement st = con.createStatement();
System.out.println("成功连接到数据库！");
ResultSet rs = st.executeQuery("select * from user");
System.out.println(rs.toString());
while (rs.next()) {
System.out.println(rs.getString("name"));
}
st.close();
con.close();
}catch(SQLException e) {
System.out.println("连接数据库失败！");
e.printStackTrace();
}
}
}
ServletTest
package servlet;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* Servlet implementation class NewServlet
*/
@WebServlet(name = "NewServlet", urlPatterns = { "/my" })
public class NewServlet extends HttpServlet {
private transient ServletConfig servletConfig;
public void init(ServletConfig servletConfig) throws ServletException {
this.servletConfig = servletConfig;
}
public ServletConfig getServletConfig() {
return servletConfig;
}
public String getServletInfo() {
return "My Servlet";
}
public void service(ServletRequest request,ServletResponse response) throws ServletException,IOException{
String servletName = servletConfig.getServletName();
response.setContentType("text/html");
PrintWriter writer = response.getWriter();
writer.print("<html> <head> </head>" + "<body> Hello from " + servletName + "</body></html>");
}
public void destroy() {
System.out.println("销毁了");
}
}
9489
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
