java学习笔记

操作

	f:跳转盘符		printf("%#X",m)	,可以将m转换成十六进制输出
	dir 查看当前目录
	del 加文件可以删除（del *.class表示删除class后缀的文件）
	SET CLASSPATH=f:\java设置默认加载路径（一般默认设置为.当前目录）
	public class Hello {
		public static void main(String[] args) {
			System.out.println("Hello World!");
		}
	}	(Hello World程序代码)
	System.out.println("Hello World!");  表示换行
	System.out.print("Hello World!");    表示不换行
	javac Hello.java  编译
	编译后为class文件 Hello.class
	java Hello        执行
.声明为public class Hello的话，类名称必须与文件名相同，生成的class文件为Hello.class
	如果使用class声明，class HelloABC ，类名称为HelloABC的话，生成的class文件为HelloABC，类名称可以与文件名不同
	public static void main(String args[]){}     类似c语言中void main（）
	注释用//（单行注释）     /*   */（多行注释）     /*    **/（文档注释）

数据类型

基本数据类型:是进行内容的操作，而不是内存的操作；
	数值型:
		整型:byte、short、int、long    默认值:0
		浮点型:float、double		默认值:0.0
	字符型:char				默认值:'\u0000'
	布尔型:boolean				默认值:false
引用数据类型:在数据交互之中会占用内存的的空间指向；
  		氛围:数据、类、接口；			默认值:null
任何变量的使用要先声明，再赋值
long l1 = 88888888L;	//必须加L
int 不用，java整数默认是int
float = 12.3f;			//必须加f
double 不用，java小数默认是double
byte，short，char之间不会互相转换，计算时先转换为int型
boolean 不能和其他任何类型进行互相转换

计算时容量小的数据类型自动转换成容量大的数据类型，按以下顺序
byte,short,char->int->long->float->double	
大向小转换要加上强制转换符

计算

&&短路与 与 & 的区别（||短路或 与 或 | 同理）
例:boolean f = (i>3)&&((i+5-4)>5)
					|后面的不在计算
	而&会全部计算
“+”两侧只要有一个值字符串，自动将其他转换为字符串进行连接
println	当进行打印是无论任何类型，都自动转换成字符串

break continue

	break 执行到break直接跳出循环
continue 执行到continue跳过本轮循环中continue后面的语句，开始下一次循环

switch

switch（只能装int型）//也可以装可以自动转换成int的类型，如char，short

一些关系

	继承关系:xx是一种xx，两者则是继承关系，前者由后者继承
	聚合关系:		聚集关系:有可能与别的重（如队长是球队的一部分）
（xx是xx的一部分）	组合关系:彼此密不可分（如脑袋是人的一部分）

类规则

必须定义类，才能有对象；先定义方法，才能调用；

命名规则

业界约定俗成的规矩:类名称每个单词首字母必须大写
				方法和变量名首字母小写，除此外其他单词首字母大写
				运用驼峰标识，即每个单词首字母大写

访问控制符

private	私有的，如private int a（位于classA）	
		加了private后便不能在别的类中通过A.a的方式来调用a
public	公有的，可以在外部直接调用
protected	保护的，也可以在外部直接调用
在一个类内部，不管什么访问控制符都可以调用，访问控制符是对外部有效的，对类内部无效

构造函数

构造函数在生成一个对象时，自动调用，构造函数不能写任何返回值
会自动识别有无参数的构造函数自动调用，
构造函数可以写不止一个，可以写一个有参的和一个无参的
但是当写了一个有参的构造函数时，java便不会自动生成无参的构造函数

函数的重载

函数通过不同的形参做类似的事情，叫做函数的重载:
	java功能相同的函数可以同名
	static int add(int a,int b)
	static int add(int a,int b,int c)
	static double add(double a,double b)

boolean类型用%b来输出

this指针:

this指向当前正在调用该方法（函数）的对象
this代表当前时刻正在创建的对象
System.out.printf("i = %d\n",this.i);
在每个非static方法中都隐含一个this指针

静态static:

static将变量放进了数据区，多个对象共用一个static属性，即数据会共用
	用了static，没有对象仍然可以通过类名访问类内的属性和方法
	static属性和方法可以通过类名方式访问，也可以通过类对象名进行访问
	只有非private的成员才可以通过类名方式访问
	非static方法可以访问静态成员（包括属性与方法），因为非static有了方法必定有对象，那么便可以访问静态成员
	静态static的方法不能访问非static的成员，因为有可能没有对象

继承extends:

	一个新类从已有的类那里获得其已有的属性和方法
	新类叫做子类（派生类），已有的类叫父类（也叫基类）
	父类的私有成员（属性与方法）不能被子类继承
	通过子类对象名只能访问从父类继承过来的非私有private成员
	私有的物理上已经被继承过来的，只不过不能去访问它，所以继承必须慎重，否则会浪费内存
	“B是一个A吗？”，如果是则让B做A的子类。（例:汽车轮子不是汽车的子类）
	继承:从一般到特殊；从抽象到具体；泛化；
	java只支持单继承，不允许多重继承（即一个类不能有多个父类），可以有多层继承
	子类不能继承父类的构造方法，但可以在子类的构造方法中使用super调用父类的构造方法
子类可以继承父类的所有成员变量和成员方法

super

通过super访问父类的构造方法，例:super(i,j)
super调用父类的构造方法时，必须放在子类的构造方法里面，并且为第一条语句
super放在子类的构造方法里面时，必须调用的是父类的构造函数
super不写会默认调用无参的构造函数，默认执行super();
一个构造函数中不能写多个super语句，例super();super(i);不能执行两次
通过super.f()，在子类重写的方法中使用，可以访问被覆盖的父类方法

重写父类的方法注意事项

重写父类的方法时，子类访问控制符的权限必须>=父类的权限
重写方法必须与被重写方法具有相同的方法名称、参数列表与返回值类型 
子类中不允许出现与重写方法同名同参但不同返回值的方法

多态:

一个父类的引用类型变量既可以指向父类对象也可以指向子类对象，它可以根据当前时刻指向的不同，自动调用不同对象的方法，这就是多态
把子类的引用赋给父类的引用，父类就可以调用子类的方法	
aa = bb; 把bb当做aa来看待，子类可以当做父类看待，而父类不可以当做子类来看待
	在栈内 把bb发送给aa，则aa指向堆内bb的所指向的子类
	父类的引用只能调用子类从父类继承过来的成员，而不能调用子类所特有的成员
	父类引用永远不可能直接赋给子类引用，
	除非父类引用本身就指向一个子类对象时，才可以通过强制转换实现
	例aa = bb; bb = (B)aa;
	  A aa2 = new B();bb = (B)aa2;

抽象类:

abstract public void f();没有方法体的方法叫做抽象方法,要以abstract开头，以 ; 结尾
含有抽象方法的类，必须是抽象类；抽象类不一定有抽象方法
A aa;可以定义一个抽象类的引用，但不可以定义一个抽象类的对象
aa = bb;可以利用多态实现抽象类对子类的引用

final

final可以修饰整个类，也可以修饰类中的成员
	fina修饰类表示类不能被继承
	final修饰属性表示这个变量是个常变量，必须赋一个值,而且只能赋一个值
	final修饰方法表示这个方法可以被子类继承，但不能被子类重写

interface接口

接口就是抽象方法与常量值的结合，从本质上讲，接口是一种特殊的抽象类
一个接口可以继承多个接口 interface It3 extends It1,It2
接口中定义的方法必须是abstract public 的
接口中定义的属性必须是public static final的
因此这些修饰符可以部分或全部省略
class A implements It	类可以通过implements来实现接口，引用成员
class A extends B implements It1	继承类的同时实现接口，extends必须放在implements的前面
It it = new A();	接口可以定义一个接口引用类型的变量，并将它指向实现接口的对象，达到多态的目的
如果一个类只实现了一个接口的部分方法，则该类必须声明为抽象类
java所有可以完成自我复制的类都必须实现java.lang.Colneable接口，是空的接口，只是为了起一个标志作用

打包package:

	package语句必须是第一条语句，例:package zhangsan.lisi
		表示将所有类放入zhangsan.lisi的包里了，并且类的名字变成了zhangsan.lisi.TestPackage
		要把class文件放入zhangsan文件夹下的lisi文件夹中，并且文件夹要自己建
		编译使用javac -d . TestPackage.java
		-d表示自动建立包目录		.  表示在当前目录下建立包层
		运行时寻找的是zhangsan.lisi.TestPackage	，如果不在最顶层是找不到的，或者将最顶层目录加入classpath中
		同一个包内，非私有成员都可以被另一个类访问（同一个文件夹内，默认在一个无名的包内）
不同包:只有公有的类的公有成员才可以被另一个包中的类访问	

import

导入另一个包，便可以不用包全名，否则要写zhangsan.lisi.A aa = new zhangsan.lisi.A();
import zhangsan.lisi.*;导入所有的类
import zhangsan.lisi.A;只导入zhangsan.lisi的A这个类，导入特例的类
导入的另一个包的类中的protected型成员可以在继承的子类内部使用，而不能在外部使用

归档工具jar（打包命令）:

jar cvf T.jar *				*	代表打包所有文件
		先把要打包的包放进一个新建的文件夹中，保证该文件夹下只有需要打包的东西
		直接导入jar包中的类是时，需要将jar文件的路径设置为classpath，编译才能通过

异常处理

	try {
		aa.divide(6,0);					
	} catch (ArithmeticException e) {
		 System.out.println("除零错误，除数不能为0");
	}
try中放入可能出错的代码，捕捉到出错之后，执行catch中的代码
异常execption是运行时出现的错误，而编译时出现的错误叫error
如果不知道什么异常，可以直接写Execption
放在try里的语句，java认为都是有可能运行不成功的
除了RuntimeException的子类异常都必须要捕获，否则会编译出错
throw new ArithmeticException();	throw用来抛出异常	
普通类要想被抛出，需要extends Throwable，才能写throw new A();（抛出类）
抛出异常 :	一般都写  extends Exception	继承Exception子类才能被catch，
	public void f() throws Exception {	//throws表示不对此异常进行处理，交给调用此方法的对象来处理（表示函数f可能会抛出异常）
		throw new Exception();	//模拟抛出一个异常对象
	} 	
	//异常语法
	try {		//可能出现异常的语句
	}	
	catch() {	//捕获异常
	}
	catch() {
	}
	finally {	//无论是否抛出异常必须执行的语句
	}

java.lang

放在java.lang包里的类不需要导入，其他都要
Scanner sc = new Scanner(System.in);	System.in表示键盘
需要导入java.util.Scanner包
e.printStackTrace();	打印出错误信息的具体路径

try/catch 与 throws

如果void f() throws A {} 那么强烈建议在调用f时对A异常进行处理
如果方法内部已经对A异常进行了处理，那么就不要再写throws A了

catch:

先catch子类异常再catch父类异常
重写方法抛出异常的范围不能大于被重写方法的异常范围

Object类

每个类都默认继承了Object类，toString()返回该对象的字符串表示
	可以直接调用其方法			hashCode()返回该对象的哈希码值
	System.out.printf("%s\n",d);	不写默认调用toString()方法，返回的是类的名字和该对象的哈希码所组成的一个字符串

equals

			aa1.equals(aa2)如果aa1与aa2指向的是同一块内存对象就返回true，
								指向的不是同一块内存对象就返回false
								（即使这两块内存的内容完全一样，也返回false）
				通过重写从Object继承的方法equals，使得（两块内存的内容如果完全一样，则返回true）	
					详见:F:\java\TestStringEquals_2.java		
通过多态实现:	A aa3 = (A)obj;	

String st1 = new String("china");	new出来的放在堆中
String st2 = "china";				字符常量是放在data segment中
	在堆中new出的两个同内容的对象占两块内存
	data segment中同样的字符串是占一块内存的

String类常用方法

public char charAt(int index)	返回字符串中第index个字符
public int length()				返回字符串的长度
public int indexOf(String str)	返回字符串中出现str的第一个位置
public int indexOf(String str,int fromIndex)
								返回字符串中从fromIndex开始出现str的第一个位置
public boolean equalsIgnoreCase(String another)
								比较字符串与another是否一样
public String replace(char oldChar,char newChar)
								在字符串中用newChar字符替换所有的oldChar字符
public boolean startsWith(String prefix)
								判断字符串是否以prefix开头
public boolean endsWith(String suffix)
								判断字符串是否以suffix结尾
public String toUpperCase()		返回一个字符串为该字符串的大写形式				public String toUpperCase()		返回一个字符串为该字符串的大写形式									
public String toLowerCase()		返回一个字符串为该字符串的小写形式									
public String substring(int beginIndex)
								返回该字符串从beginIndex开始到结尾的子字符串						
public String substring(int beginIndex，int endIndex)
								返回该字符串从beginIndex开始到endIndex结尾的子字符串													
public String trim()			去掉字符串左边和右边空格
public static String valueOf(int i)		（形参不只是int i）
								将i转换为String型，static的，可以直接使用类名访问，String.valueOf()
public static int parseInt(String s)
								将字符串s转换为int型，同样可以直接使用类名访问，Integer.parseInt(str);

String类的对象有一旦创建就不可更改，如果需要经常修改建议使用StringBuffer
对于改变字符串本身的函数，String类中是没有的，在StringBuffer类中才有大量修改字符串的方法	
StringBuffer sb = new StringBuffer();			新建一个空的字符串；对于该类的使用
StringBuffer sb = new StringBuffer("zhangsan");	new对象时直接加入字符串
sb.append("123");				往Buffer中添加字符串
sb.insert(3, "--");				往字符串中插入数据
sb.delete(2,6);					删除特定位置的字符
sb.reverse();					将字符串倒转	

数组

int[] arr1 = new int[] {0,1,2};		新建一维数组
	引用类型的数组一般存在两级的指向关系	
	int[][] xx = new int[2][3];			等长二维数组
	int[][] xx = {{1,2,3},{4,5],{6}};	不等长数组										
	System.arraycopy(a,0,b,1,2)			数组的拷贝（将a数组中的第0位的开始长度为2位的元素，覆盖掉b数组中从第0位开始的长度为2位的元素）
	Arrays.sort(arr1)					数组的排序
					需要导入java.util.*包
	for(int e : arr1)		在循环中把arr1数组中的每个元素取出来赋给e

线程Thread

aa.start()	启动一个线程，并自动调用aa中的run方法，aa需要继承extends Thread
线程是一个程序里的不同执行路径
执行一个线程，实际就是执行该线程run中的代码	
一个Thread对象能且只能代表一个线程
一个Thread对象不能调用两次start()方法	
执行aa.start()只代表启动了一个线程，并不代表aa线程会立马被执行
创建新进程的两种方法:（无论是哪种方法都不能throws任何异常）
	extends Thread			aa.start()
	implements Runnable		Thread t = new Thread(aa);t.start();
public final void setName(String name)	设置当前线程的名字
public static Thread currentThread()	返回对当前正在执行的线程对象的引用
public final String getName()			返回当前线程的名字

isAlive()		判断线程是否还为终止，就绪、运行和阻塞都是还活着	
getPriority()	获取线程的优先级数值（1-10，默认5，优先级值越大越高）
setPriority()	设置线程的优先级数值
Thread.sleep()	将当前线程指定睡眠多少ms（会抛出InterruptedException异常，要进行捕捉，要run内部进行处理）
join()			调用某线程的该方法，将当前线程与该线程“合并”，即等待该线程结束，再恢复当前线程的运行，也要捕捉InterruptedException异常			
					暂停当前正在执行的线程，直到t.join()所对应的线程终止之后当前线程才能获得继续执行的机会					
yield()			让出cpu，当前进程进入就绪状态，等待调度
wait()			当前对象进入对象的wait pool				this.wait();  将执行wait的线程进入阻塞状态，让出CPU的控制权
notify()		唤醒对象的wait pool中的一个线程			this.notify();只能叫醒wait的线程，是叫醒其他线程的，使其从阻塞状态进入就绪状态，为而不是叫醒自己的wait
notifyAll()		唤醒对象的wait pool中的所有线程				
						
synchronized(对象名aa)	可以new一个String充当对象，一个线程正在操作某资源时，将不允许其他线程操作该资源，即一次只允许一个线程处理该资源
public synchronized void run()	也可以这样写，表示把方法里所有代码给同步	
尽量用实现Runnable接口的方式来开启线程，如果用继承Thread的方式，一定要将定义的属性(tickets)和String都加上static

生产消费的具体例程:F:\java\TestPC.java

Event

事件，Event； Event source； Event Handler； Event Listener
			  事件	  事件源		 事件处理方法	 事件监听器
		详见:f:\java\TestButton.java
					 TestGridLayout.java
					 TestBorderLayout.java
					 TestGUI.java

@Override

@Override	加了这个在函数上一行，表示在重写父类方法，如果写错了方法名会报错，如果不加的话，写错了函数名就不会报错，而是新写一个方法

str = int + “”;将int转字符串

内部类与匿名类

内部类:内部类中的方法可以直接访问外部类中的所有成员
		外部类的方法不可以直接访问内部类的成员
匿名类:匿名类是内部类的一种极端表现形式
		匿名类可以访问外部类的所有成员和包裹本匿名类方法中的final类型的局部变量		

生成可执行jar文件:

在文件夹下新建一个1.txt文件
 在txt文件中输入Main-Class: TestCalculate	注意":"后面要加个空格，并且要写几个回车，不然会失败
  在dos窗口输入jar cvfm Calculate.jar 1.txt *.class	注意txt后面的空格			

流

java中路径中的\用\\或/来代替，例如D:\\java\\****
有一个类专门用来将当前程序与其他设备（内存、本地硬盘、其他计算机等等）进行相互数据传输的类叫流（FileReader）			
Reader，Writer，InputStream，OutputStream	四个抽象流，前两个是字符流，后两个是字节流，一个字符等于两个字节
凡是以Stream结尾的都是字节流，InputStream中常用的方法 read()	字节流不能读正常读汉字
							  OutputStream中常用的方法write()	
FileInputStream		FileOutputStream	FileReader	FileWriter	四个抽象类的常用子类
例:FileInputStream fr = new FileInputStream("F:\\51原理图.jpg");	括号里是需要读取的文件
字符流只能处理文本，而字节流能处理音乐、视频等很多东西
close()关闭流
fw.flush();	刷新该流的缓冲，写完之后一定要刷新，所有的输出流先flush再close									  
节点流:也叫原始流	
处理流:也叫包裹流		

缓冲流就是默认带有缓冲区的输入输出流，缓冲流本身是处理流（包裹流），所以要先定义节点流（原始流）
BufferedReader(Reader in)			BufferedWriter(Writer out)
BufferedInputStream(InputStream in)	BufferedOutputStream(OutputStream out)
四个常用缓冲流的构造方法，每个后面都可以加上缓冲区的大小，一般不写，例:BufferedReader(Reader in，int size)								
例:BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\51原理图.jpg")) ;
bos.write(buf,0,len);	将一个字节类型的数组从指定位置(off)开始的len个字节写入到输出流							

数据流:DataInputStream	DataOutputStream	这两个都是包裹流，需要依附于InputStream OutputStream 

把一个long类型的数据写入byte数组中,然后再从byte数组中读取出这个long类型的数据:
		详见:F:\java\TestByteArrayOutputStream.java
			  F:\java\TestData.java		
			  
转换流		InputStreamReader	作用是把InputStream转换为Reader
			OutputStreamWriter	作用是把OutputStream转换为Writer
			例:将键盘输入的字符组成字符串直接赋给String对象，F:\java\TestString_1.java
					
br.readLine()会丢弃回车符而不会返回回车符，所以要加上newLine()来自己添加回车符

Print流，只有输出没有输入，PrintWriter输出字符  PrintStream输出字节
			例:F:\java\TestSys.java

对象序列化

		ObjectOutputStream	ObjectInputStream
如果要把某一个对象序列化，则必须要实现Serializable接口（标记接口:这接口是空的，只是起一个标识的作用）

重写hashCode()与equals()

例:F:\java\TestHash.java	

	public boolean equals(Object obj) {
		如果this与obj的内容是一模一样的
			返回true
		否则
			返回false
	}	
	
	public int hashCode() {
		return 当前类基本类型数据对象的hashCode()方法
	}

lterator接口

泛型

网络编程（Socket编程）

	
	java.net
	ServerScoket使用来实现TCP连接的（server端）
	Socket（client端）		TCP连接是server端与client端之间的连接，建立连接时所需的寻址信息为远程计算机的IP地址和端口号，我们使用1024以上的端口号，1024以下的随时有可能被系统征用

	TCP连接:	F:\java\TCPServer.java
				F:\java\TCPClient.java
	UDP连接:	F:\java\UDPServer.java
F:\java\UDPClient.java