Java笔记

Java笔记

---

前言

没来得及整理的一些琐碎的知识

---

提示：以下是本篇文章正文内容，下面案例可供参考

size()是获取泛型集合的长度
length是获取数组的长度
length()是获取字符串的长度。
类是public的，那么文件名要和类名一致。不是public类的可以不一致（建议一致）。

一个java的源程序中可以包含多个类，但只能有一个public的类

类的命名规则：大驼峰 每个单词的首字母大写 HelloWorld Test Student

方法命名规则：从第二个单词开始首字母大写（多个单词情况下）。

关键字命名规则：都是小写。public class static void

classpath
. 当前路径
… 上一级路径
\ 磁盘根部

java.exe程序需要用来解析 字节码 文件

方法中参数的传递，是按值传递，将值复制一份，进行传递。

相对路径：相对于当前路径
绝对路径：从磁盘根部开始

修饰符 class 类名{
类体
}

输出System.out.println();

修饰符： public 缺省（不写）
// 单行注释
/* / 多行注释
/* */ 文档注释

标识符： 包 类 方法 参数 变量 不能数字开头 不能有空格 不能是关键字

包：都小写
类和接口： 每个单词首字母都大写
常量：全部大写
变量和方法: 除第一个单词外其他单词首字母大写
关键字：都小写

字符常量：用单引号括起来的单个字符
字符串常量（String）：用双引号括起来的字符串

布尔常量（boolean）： true（真） false（假）

null 常量：只有一个值 null 表示对象的引用为空。

数据类型：两大类：
基本数据类型：数值：整数（byte127 short32768 int long）
浮点（小数）(float double)
字符 char
布尔 boolean
引用数据类型：类 接口 数组 枚举

强制类型转换：例子：int a=(byte)b;

整形相加会自动转换int类型需要强制转换。

变量的作用域：在那个花括号中声明的，就在那个花括号中起作用

类变量（成员变量）：在类中，方法外声明的变量不赋值，有默认值。

局部变量：在方法中，要赋值后才能使用。

运算符：
算术运算符：如果除发中，除数和被除数都是整数那么商也是除数（当中有一个是小数商就得到小数）。

3500/1000*1000=3000；

%取余（模） 5%3=2

Scanner sc=new Scanner(System.in);//输入
int num=sc.nextInt();//接受/保存
System.out.println(num)输出
import java.util.Scanner;包

switch(a) case “+”/1: break；

System.out.println(“请输入运算符！”);
String p =sc.next();/（7.0以前：char c =fh.charAt(0)）
while(条件)（条件成立则继续进行）
{
循环体；
}

do{
循环体
}while（条件）至少执行一次循环。

for(；；)

break：结束循环，默认结束本身循环（内循环），可以加标号，指定结束循环。

continue: 结束本次循环，接着进行下一次循环。

包：为了对类进行分类管理；

包的定义：必须是源代码中第一条语句。（除注释外）。
package cn.com.hbsi

javac -d . helloworld.java

方法：
方法定义在类中。
修饰符 返回值类型 方法名（参数类型 参数名1，，，，）{
}

返回值类型：有值 类型
无值 void

public static void Helloword(int x,int y){
}

数组名字.length是数组长度。

静态初始化数组：声明数组同时赋值：
String[] strs = new String[]{“aa”,“bb”,};
String[] strs = {“aa”,“bb”,};

int [] x=new int [n];

数组的复制：
自己编写代码：
int [] 新数组 = Arrays.copyOf(原数组，新数组长度)需要包：{import java.util.*;}

可以部分复制数组：
System.arraycopy(原数组，原数组的起始位置，目标数组，目标数组起始位，长度；)

	数组输出：
	for(int t: x)
	System.out.print(t+"\t");
	System.out.println();
	for(int temp: z)
		System.out.print(temp+"\t");

import java.util.Random;随机数包；
int x=new Random().nextInt(50);

递归方法：一个方法在其方法体内调用自身。

遍历某文件夹下的所有文件，包含子文件夹中的文件

做递归时，一定要有出口，必须在某个时刻，方法的返回值是正确的，这是，可以不再调用自身
递归
this关键字可以直接访问成员变量

private(私有化);set\get;

定义类，系统会自动产生一个无参构造

this:1.区分成员变量和局部变量，当成员变量和局部变量重名是，用
this来访问成员变量 this.成员变量
2.通过this关键字调用成员方法
3.一个构造方法调用自身类中的另一个构造方法时，要使用this关键字
构造方法之间的互相调用，而且this语句只能放在构造方法中

Datawrap dw= new Datawrap();
dw.a=10;
dw.b=5;
changeAB(dw);
System.out.print(+dw.a)

静态变量 (static)修饰

static 修饰的成员变量，静态变量，是所有对象共有属性
不需要创建对象，就可以直接访问静态变量

类名.静态变量
对象名.静态变量
类名.方法

静态方法只能访问静态变量

静态代码块

代码块
{
//初始化语句
}

当创建java对象时，系统总是先调用该类中定义的初始化代码

public class 类{
//成员变量
//成员方法
//构造方法
//代码块
}

静态代码块。
在加载类的时候就会执行静态初始化块，静态初始化块，只执行一次。

在内部类中调用外部类中的成员变量
外部类名。this。
outer.this.num

继承：
父类（超类，基类）
子类（派生类）

class A{}
class B extends A{}
class C extends B{}

多个类也可以继承同一个父类；

可以多层继承

子类重写（override）父类方法：方法名相同 参数列表相同 返回值相同
访问权限要大于覆盖方法 子类方法声明抛出的异常比父类方法声明抛出的异常更小或者相等；

三同一小一大

重载（overload）：在同一个类当中 方法名字相同 参数列表不同（参数个数，顺序 类型）
与返回值无关系

在子类中调用父类被覆盖了的方法，可以使用super关键字
super.成员方法（）

super.成员变量

子类不会获得构造方法*（无法继承构造方法） 但是可以调用父类的构造方法 ；

子类构造的第一行代码使用super显示调用父类的构造，系统根据super调用时传入的参数
调用用父类对应的构造
子类构造的第一行代码使用this显示调用本类的另一个构造，根据传入的参数调用本类对应的
构造子类构造宏没有super，也没有this，系统会自动调用父类的无参构造

类被final关键字修饰后不能被继承

方法被final关键字修饰后 这个类的子类不能重写该方法；

final 可以修饰变量（成员变量和局部变量）是常量，只能赋值一次
final 修饰局部变量：可以声明的同时赋值，也可以不在声明的同时赋值 但是也只能赋值一次
成员变量：静态
实例 声明 普通初始化块 构造方法 不能在一般成员方法中赋值

[访问修饰符] abstract 方法返回值类型 方法名（参数）

包含了抽象方法的类，一定要定义为抽象类

[访问修饰符] class 类名{
[访问修饰符] abstract 方法返回值类型 方法名（参数）;
}
抽象类作用： 为了被子类继承，子类去实现父类中所有的抽象方法。
如果没有实现，那么这个子类需要定义为抽象类 不能实力化对象

抽象类可以包含属性，方法（普通方法和抽象方法），构造方法，初始化块，内部类

final和abstract不可同时使用
abstract不可以修饰构造方法
private和abstract不能同时使用

时间
开始时间：long start = System.currentTimeMillis();
执行代码；
结束时间：long end =System.currentTime Millis();
System.out.println(end-start);

接口（interface）：理解为一种特殊的抽象类，只包含常量和抽象方法
接口也可以理解为一组规范，一组协议

implements//实现！！！

实现接口：
class 类名 implements 接口名 {
接口方法
}

接口可以多继承，一个接口可以有多个直接的父接口

interface 接口名 extends 接口1，接口2…

class 类 implements 接口1,接口2{
}

class 类名 extends 父类 implements 接口1，接口2…{
}

多态：可以理解为事物存在的多种形态。

体现：父类的引用指向了自己的子类对象。
父类引用也可以接收自己的子类对象。

前提： 继承 有重写

好处：提高程序扩展性

class Animal{
}

class Cat extends Animal{}

class Dog extends Animal{}

Cat c = new Cat();
Dog d = new Dog();

Animal a =new Cat();
通过父类的引用调用的方法必须是父类中有的方法
（（cat）a）.catchMouse();
成员方法编译看左边（父类）执行看右边（子类）
成员变量编译与执行都看左边（父类）

对象 instanceof 类（接口）：
用来判断对象是否是指定类型，如果是结果为true。

不能通过父类的引用调用子类特有的方法。如果有调用，需要进行类型转换，向下转型

person p = new Student（）；
Student st = （Student）p；向下转型

Object类

equals(obj):
判断两个对象是否能

异常：程序运行时出现的异常情况
Exception(异常类)

异常处理机制

try{
//有可能产生异常的代码块
}catch(Exception e){

}

try块中如果发生异常，就会产生一个异常对象，在这个异常对象中包括异常的相关信息
然后将这个异常对象抛出，由catch捕获，处理。
catch块要判断这种异常对象能否处理。

catch块 可以是多个但捕获的异常类型要有特殊到一般。
finally块在try…catch{System.exit(0)}情况下无法执行
try不能单独存在
try…catch
try…finally
try…catch…finally
getMessage();
printStackTrace() ;
throw new RuntimeException(“异常”);人为产生的异常

修饰符 返回值类型 方法名（参数。。。）throws Exception{
}

throws:在方法的声明上使用，throws 后跟的是异常类型，
作用声明方法有可能产生异常，方法调用者去处理。

throw：在方法内使用，throw后跟的是异常对象，作用人工抛出一个异常对象

for(int i=0;i<x.length;i++) {
if(x[i]>=0||x[i]<=100) {
try {
throw new RuntimeException(“异常”);
}
protected：可以被同一包下的其他类访问或者其它包中的子类访问

追加：append(“asdc”)，
插入：insert(2,“asd”)
删除：delete(2,5)
替换：replace(1,3,“qq”)

Thread.sleep(3000)//休眠3秒
process.destroy();//杀死进程
Math.floor();返回小于参数的最大整数；
Math.ceil();返回大于参数的最小整数；
Math.round();返回long类型 四舍五入
currentTimemillis()；当前时间

Calendar c =Calendar.getInstance();
Calendar 时间类.
Integer num =new Integer(20)

JOptionPane.showInputDialog弹出窗口输入！

parseInt转化为整形 int
Integer.parseInt
mySortArray();对int类型进行排列；

nextInt(100) 0-100随机数。

List: 有序 元素可以重复
set 无序 不可重复
ArrayLIst：底层结构是数组

遍历方式：
get（index）
foreach；
迭代器；Iterator；
Iterator it = li.iterator();//获取迭代器
while(it.hasNext()) {//判断是否有下一个元素
Object o =it.next();//获取 li 中的值
System.out.println(o);
LinkedList集合

HashSet set =new HashSet();9

public String toString() {
return id+name;
泛型：
ArrayList<参数化类型>list = new ArrayList<参数化类型>();

FlowLayout 流式布局管理器(FlowLayout)是最简单的布局管理器。
BorderLayout 边界布局管理器 EAST SOUTH WEST NORTH CENTWER
GridLayout 网格布局管理器（行数,列数,水平距离,垂直距离-)

Frame f = new Frame(“窗体”);
JFrame
public class b_061 extends JFrame

xx.setSize(,)//设置大小
xx.setLocation(,)//位置
xx.setVisible(true)//设置可见性
xx.setBounds(, , , );//位置大小;
this.setTitle("—");//设置窗口名字;
this.pack();自定义大小

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);结束进程

事件处理机制：
当按下按钮，产生一个事件，也就是产生了一个这个事件类型的对象，并将这事件对象交给在事件源上
注册了的监听器对象进行处理

e.getSource()==b1;获取数据源;

JDialog 默认非模态

ButtonGroup 按钮组

j1.addActionListener(new ActionListener(){//为j1添加监听器

xxxx.isSelected()//xxx被选中时

super(“弹出菜单”)；

JMenuItem 菜单项
JMenu菜单
JMenuBar菜单栏/条
JPopupMenu 弹出菜单
JTable 表格
(菜单)xxx.addSeparator//添加分割条;
xxx.addRow(xxx);//增加一行;
xxx.setViewportView(xx);//将xx添加到xxx中;

xx.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_ALWAYS);//水平滚动条一直显示
xx.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);//垂直滚动条一直显示

j1.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Q,KeyEvent.CTRL_MASK));
//为j1添加快捷键 Ctrl+q

*************************J D B C *******************
1.加载驱动
在项目下创建一个lib文件夹，将驱动拷贝到文件夹下，然后将驱动添加到path路径中
Class.forName(“com.mysql.jdbc.Driver”)//注册数据库连接
Mysql URL地址写法：jdbc:mysql://localhost:3306/数据库名字
ResultSet rs = st.executeQuery(“select 字段名 from 表名”);
Connection con = DriverManager.getConnection(“jdbc:mysql://localhost:3306/数据库名”,“root”,“1234”);//建立数据库连接

1. ResultSet executeQuery(String sql); 执行SQL查询，并返回ResultSet 对象。
   2.int executeUpdate(String sql); 可执行增，删，改，返回执行受到影响的行数。

文本、图片、音频、视频都是2进制形式存在的

FileInputStream 字节输入流
FileOutputStream 字节输出流

BUfferedInputStream 字节缓冲流输入
BufferedOutputStream 字节缓冲流输出 内部定义8192字节

FileReader 字符输入流
FileWriter 字符输出流
flush();刷新
BufferedReader字符缓冲输入流
BufferedWriter字符缓冲流输出
newLine();输出一个换行字符
InputStreamReader 转换
toUpperCase() 转换为大写
// 输出文件的绝对路径
System.out.println(file.getAbsolutePath());

files是一个文件数组，[File file:files]的意思是每次循环都将数组中的文件对象赋给file这个变量，然后再在循环体中对这个变量进行操作。它相当于如下转换形式：
File file;
for(int i=0;i<files.length;i++){
file = files[i];
……
}

进程：正在运行的程序

线程：进程中的一条执行线索

每个进程中至少一个线程，单线程程序

也可以有多个线程，多线程程序

两种实现多线程方式：

1.继承Thread类，重写（覆盖）run（）；
2.实现Runnable接口，并重写该接口的run()方法；

Thread.currentThread().getName()几号窗口

线程的生命周期：
新建状态：new a a= new a(); new Thread(a,“1号”)
就绪状态：start()(启动进程)等待cup所有权 a.start();
运行状态：执行run()方法
死亡状态：执行完run()方法，或者出现exception(异常) error（结束）。
阻塞状态：sleep join wait

.setPriority(Thread.MIN_PRIORITY);优先级为1
.setPriority(Thread.MAX_PRIORITY);优先级为10
yield方法是用于线程让步
.join 方法来实现线程插队
.sleep(?)进程休眠？毫秒

synchronized()同步代码块

Schema与DTD的区别。
Schema本身也是XML文档，DTD定义跟XML没有什么关系；
Schema文档结构性强，各元素之间的嵌套关系非常直观。
DTD只能指定元素含有文本，不能定义元素文本的具体类型
DTD无法利用XML的命名空间，Schema很好满足命名空间。

xml是一种语言它的内容都是由标签组成的一般用来存储配置信息