Java笔记（上）

第一章 Java开发入门

			  特点:
			 ①简单性
			 ②面向对象性
			 ③安全性
			 ④跨平台性
			 ⑤支持多线程

3.JDK:Java开发环境
4.JRE:Java运行环境
关系:

第二章 Java编程基础

1.Java代码格式:

修饰符 class 类名{
	代码
}

输出语句 System.out.println();//注意大写以及分号

2.Java中的标识符
Java标识符不能以数字,Java关键字作为开头

3.变量的数据类型

类型名	占用空间	取值范围
byte	8位(1个字节)	-27~27-1
short	16位(2个字节)	-215~215-1
int	32位(4个字节)	-231~231-1
long	64位(8个字节)	-263~263-1

float f=123.4f; //为float类型变量赋值,后面必须加字母f
double d=123.4; //为double类型变量赋值,后面可省略字母d
char c='a';
char c=97;//为一个char类型的变量赋值整数97,相当于赋值字符a

4. 变量的类型转换

1.自动类型转换
byte b=3;
int x=b;//由于int的取值范围大于byte 因此编译器可自动完成转换

2.强制类型转换
目标类型 变量名=(目标类型) 值;
int a=4;
byte b=(byte) a;//int的取值范围大于byte 需要对其强制转化

3.表达式类型自动提升
byte b1=3;
byte b2=4;
byte b3=byte (b1+b2);//由于表达式b1+b2运算期间,变量b1和b2被自动提升为int型,因此结果也为int型

5.变量的作用域
略
6.方法
可理解为c语言里的函数

1.方法的格式:
修饰符 返回值类型 方法名(参数类型 参数名){
	执行语句
	...
	return 返回值;
}
2.方法的重载:
public class ex1{
	public static void main(String[] args){
	int sum1=add(1,2);
	int sum2=add(1,2,3);
	double sum3=add(1.2,2.3);
	System.out.pritnln(sum1);
	System.out.pritnln(sum2);
	System.out.pritnln(sum3);
	}
	//根据参数类型 参数个数的不同来进行返回值
	public static int add(int x,int y){
		return x+y;
	}
	public static int add(int x,int y,int z){
		return x+y+z;
	}
	public static double add(double x,double y){
		return x+y;
	}
}

7.数组

1.数组的定义
int[] x=new int[100];
		||
int []x;//声明一个int[]类型的变量
x=new int [100];//创建一个长度为100的数组

2.多维数组
int[][] x=new int [100][100]; 

第三章 面向对象(上)

面向对象的特点:
1.封装性
2.继承性
3.多态性

1.类的定义
class Person{
int age;
void speak(){
	System.out.println("我今年"+age+"岁");
	}
}

2.对象的创建
类名 对象名称=new 类名();
Pesron p=new Person();//实例化对象

3.对象的引用
p.age=18;
p.speak();

4.类的封装
略

3.构造方法

定义
1.方法名与类名相同
2.在方法名的前面没有返回值类型的声明
3.在方法中不能用return语句返回一个值,但是可以单独写return语句来作为方法的结束

1.无参的构造方法
class Person{
	public Person(){
		System.out.println("无参的构造方法被调用了");
		}
	}
public class ex1{
	public static void main(String[] args){
		Person p=new Person();
		}
	}
	
	运行结果为:无参的构造方法被调用了
	
2.有参的构造方法
class Person{
	int age;
	public Person(int a){
	age=a;
	}
	public void speak(){
	System.out.println("我今年"+age+"岁了");
	}
}
public ex2{
	public static void main(String[] args){
	Person p=new Person(10);
	p.speak;
	}
}
	运行结果为:我今年10岁了

3.构造方法的重载	
class Person{
	String name;
	int age;
	//定义两个参数的构造方法
	public Person(String con_name,int con_age){
	name=con_name;
	age=con_age;
	}
	//定义一个参数的构造方法
	public Person(String con_name){
	name=con_name;
	}
	public void speak(){
	System.out.println("我叫"+name+"今年"+age+"岁");
	}
}
public class ex3{
	public static void main(String[] args){
	Person p1=new Person("张三");
	Person p2=new Person("李四",20);
	p1.speak;
	p2.speak;
	}
}
	运行结果为:
				我叫张三今年0岁
				我叫李四今年20岁

4.this关键字

1.访问成员变量
class Person{
	int age;
	public Person(int age){
	this.age=age;
	}
	public int getAge(){
	return this.age;
	}
}

2.在一个构造方法中调用其他构造方法
class Person{
	public Person(){
	System.out.println("无参的构造方法被调用了");
	}
	public Person(String name){
	this();//此处调用上面无参的方法
	System.out.println("有参的构造方法被调用了");
	}
}
public class ex1{
public static void main(String[] args){
	Person p=new Person("aa");	
	}
}
	输出结果为:
	无参的构造方法被调用了
	有参的构造方法被调用了

5.垃圾回收

class Person{
	public void fianlize(){
		System.out.println("对象将作为垃圾回收");
	}
}
public class ex{
	public static void main(String[] args){
		Person p1=new Person();
		Person p2=new Person();
		//给这些对象赋值为null,使其变成垃圾
		p1=null;
		p2=null;
		System.gc();//调用该方法进行垃圾回收
		for(int i=0;i<100000;i++){
		//延长程序运行时间
		}
	}
}

6.static关键字

1.static关键字只能修饰成员变量,不能修饰局部变量,否则报错
public class Student{
	public void study(){
		static int num=10; //编译报错	
	}
}

2.静态方法
class Person{
	public static void speak(){
		System.out.println("hello");
	}
}
class ex{
	public static void main(String[] args){
		Person.speak;//类名.方法名 直接调用静态方法
		Person p=new Person();
		p.speak();//通过实例化对象来调用静态方法
	}
}

7.成员内部类

外部类名.内部类名 变量名=new 外部类名().new 内部类名();

class Outer{
	private int num=4;
	public void test(){
		Inner in=new Inner();
		in.show();
	}
	class Inner{
		void show(){
			System.out.println("num="+num);
		}	
	}
}
public class ex{
	public static void main(String[] args){
		Outer out=new Outer();//创建外部对象
		out.test();//调用show()方法中的test()方法
		Outer.Inner in=new Outer().new Inner();//创建内部对象
		in.show();//调用test()方法
	}
}
运行结果:
num=4
num=4

第四章 面向对象(下)

1.类的继承

1.继承的概念
class animal{
	String name;
	void shout(){
		System.out.println("动物叫");
	}
}
class dog extends animal{
	public void printname(){
		System.out.prinltn("name="+name);
	}
}
public class ex1{
	public static void main(String[] args){
		dog d=new dog();
		d.name="廖彬涵";
		dog.printname();
		dog.shout();
	}
}
运行结果:
name=廖彬涵
动物叫

2.重写父类方法
class animal{
	String name;
	void shout(){
		System.out.println("动物叫");
	}
}
class dog extends animal{
	void shout(){
		System.out.println("狗叫");
	}
}
public class ex2{
	public static void main(String[] args){
		dog d=new dog();
		d.shout();
	}
}
运行结果:狗叫
				注:一个类最多一个父亲

3.super关键字
当子类重写父类方法后,子类对象将无法访问父类被重写的方法.因此可用super关键字访问父类的成员
super.成员变量
super.成员方法(参数1,参数2 etc)

class animal{
	String name="动物";
	void shout(){
		System.out.println("动物叫");
	}
} 
class dog extends animal{
	String name="狗"
	void shout(){
		super.shout();//该处已重写父类中shout()方法 因此可用super.shout()来访问该父类方法
	}
	void printname(){
		System.out.println("name="+super.name);//访问父类成员变量
	}
}
public class ex3{
	public static void main(String[] args){
		dog d=new dog();
		d.shout();
		d.printname();
	}
}
运行结果:
动物叫
name=狗

4.使用super关键字访问父类的构造方法
class animal{
	public animal(String name){
		System.out.println("我是"+name);
	}
	public animal(){
		System.out.println("我是一只动物");
	}
}
class dog extends animal{
	public dog(){
		super("沙皮狗");//由于此处super引用了父类带参的方法 因此此处用的是有参的方法 
	}//反之若把super注释掉 则用无参的方法
}
public class ex4{
	public static void main(String[] args){
		dog d=new dog();
	}
}
运行结果:我是狗

2.final关键字

特点:
1.final修饰的类不能被继承
2.final修饰的方法不能被子类重写
3.final修饰的变量是常量,只能赋值一次

3.抽象类和接口

1.抽象类
注意事项:抽象类中可包含抽象方法,但包含抽象方法的类一定是抽象类
abstract class animal{
	abstract void shout();
}
class dog extends animal{
	void shout(){
		System.out.println("狗叫");
	}
}
public class ex1{
	public static void main(String[] args){
		dog d=new dog();
	}
}
运行结果:狗叫

2.接口
[public] interface 接口名[extends 接口1,接口2]{
	[public] [static] [final] 数据类型 常量名=常量值;
	[public] [abstract] 返回值 抽象方法名;
}

interface animal{
	String behavior="动物的行为";
	void breathe();
	void run();
}//定义animal接口

interface landanimal extends animal{
	void liveland();
}//定义landanimal接口

class dog implements landanimal{
	public void breathe(){
		System.out.println(bahavior+":"+"狗在呼吸");
	}
	public void run(){
		System.out.println(behavior+":"+"狗在跑");
	}
	public void liveland(){
		System.out.println("狗是陆地生物");
	}//因为landanimal接口继承了animal接口,因此landanimal有三个抽象方法
}
public class ex2{
	dog d=new dog();
	dog.brethe();
	dog.run();
	dog.liveland();	
}
输出结果:
动物的行为:狗在呼吸
动物的行为:狗在跑
狗是陆地生物

4.多态

1.
interface animal{
	void shout();
}
class cat implements animal{
	public void shout(){
		System.out.println("喵喵");
	}
}
class dog implements animal{
	public void shout(){
		System.out.println("汪汪");	
	}
}
public class ex1{
	public static void main(String[] args){
		animal a1=new cat();
		animal a2=new dog();
		animalshout(a1);
		animalshout(a2);
	}
	
	public static void animalshout(animal a){
		a.shout();
	}//定义一个静态animalshout()方法,接收一个animal类型的参数	
}
输出结果:
喵喵
汪汪

2.对象的类型转换
interface animal{
	void shout();
}

class dog implements animal{
	public void shout(){
		System.out.println("汪汪");
	}	
}

class cat implements animal{
	public void shout(){
		System.out.println("喵喵");
	}
	public void sleep(){
		System.out.println("猫猫睡觉");
	}
}
public class ex3{
	public static void main(Stingr[] args){
		dog d=new dog();
		animalshout(d);//此处传入一个dog类型的d对象 导会导致animal类型的变量无法强制转化为cat类型
	}
}
public static void animal animalshout(animal a){
	if(a instanceof cat){//判断a是否为cat类型
		cat c=(cat)a;//将a对象转化成cat类型
		c.sleep();
		c.shout();//调用cat中的方法 
	}else{
		System.out.println("这个动物不是猫");
	}
}
运行结果:
这个动物不是猫

5.Object类

Object类是所有类的父类

方法名称	方法说明
equals()	指示其他某个对象是否与此对象相等
getClass()	返回此Object的运行时类
hashCode()	返回该对象的哈希码值
toString()	返回该对象的字符串表示

class animal{
	public String tostring(){
		return "这是一个动物";
	}
}
public class ex1{
	public static void main(String[] args){
		animal a=new animal();
		System.out.println("animal.tostring()");
	}
}
运行结果:
这是一个动物

6.匿名内部类

在类里再定义类(套娃)

interface animal{
	void shout();
}
public class ex1{
	public static void main(String[] args){
		class cat implements animal{
			public void shout(){
				System.out.println("喵喵");
			}
		}//定义一个内部类cat
		animalshout(new cat());//调用animalshout()方法传入cat对象
	}
	public static void animalshout(animal an){
		an.shout();
	}
}

7.异常

1.什么是异常
public class ex1{
	public static void main(String[] args){
		int result=divide(4,0);
		System.out.println(result);
	}
	public static int divide(int x,int y){
		int result=x/y;
		return result;
	}
}
运行结果:
Exception in thread "main" java.lang.ArithmeticException: / by zero 
at work1.work1.divide(ex1.java:11)
at work1.work1.main(ex1.java:7)

2.try...catch和finally
public class ex2{
	public static void main(String[] args){
		try{
			int result=divide(4,0);
			System.out.println(result);
		}catch(Exception e){
			System.out.println("捕获的异常信息为:"+e.getMessage());
		}
		System.out.println("程序继续往下执行");
	}
	public static int divide(int x,int y){
		int result=x/y;
		return result;
	}
}
运行结果:
捕获的异常信息为:/ by zero
程序继续往下执行

public class ex2{
	public static void main(String[] args){
		try{
			int result=divide(4,0);
			System.out.println(result);
		}catch(Exception e){
			System.out.println("捕获的异常信息为:"+e.getMessage());
			return;//结束当前语句
		}finally{
			System.out.println("进入finally代码块");//虽然return已经结束语句 但finally仍会执行
		}
		System.out.println("程序继续往下执行");
	}
	public static int divide(int x,int y){
		int result=x/y;
		return result;
	}
}
运行结果:
捕获的异常信息为:/ by zero
进入finally代码块

8.throws关键字

public class ex1{
	public static void main(String[] args){
		try{
			int result=divide(4,2); //由于第二个参数为2 因此不会异常,但定义divide时抛出异常
			System.out.println(result);//因此调用divide方法时进行try...catch处理
			}catch(Exception e){
				e.printStackTrace();//打印捕获的异常信息
			}
	}
	public static int divide(int x,int y)throws Exception{
		int result=x/y;
		return result;
	}
}
	

9.自定义异常

public class ex1{
public static void main(String[] args){
//使用try...catch的原因因为下边方法里使用了throws 
	try{
		int result=divide(4,-2);
		System.out.println(result);
		}catch(zdyException e){
			System.out.println(e.getMessage());
		}
}
public static int divide(int x,int y) throws zdyException{
	if(y<0){
		throw new zdyException("除数是负数");
		}
	int result=x/y;
	return result;
	}	
}

	//自定义一个异常类zdyException继承Exception
class zdyException extends Exception{
	public zdyException(){
		super();//调用Exception的无参的构造方法
	}
	public zdyException(String message){
		super(message);//调用Exception的有参的构造方法
	}
} 
输出结果:除数是负数

10.访问控制

> 访问及控制级别从左到右逐渐增大

第五章 Java API

1.String类和StringBuffer类

1. 	 String类表示的字符串是常量，一旦创建后，内容和长度都无法改变。
	 StringBuffer表示字符容器，其内容和长度都可以随时改修改。
	 在操作字符串时，如果该字符串仅用于表示数据类型，使用String类即可，
	 但是如果需要对字符串中的字符进行增删操作，则使用StringBuffer类。

2.String类覆盖了Object()方法,而StringBuffer类没有覆盖Object类的equals()方法.
	String s1=new String("abc");
	String s2=new String("abc");
	System.out.println(s1.equals(s2));// 打印结果为true
	StringBuffer sb1=new StringBuffer("abc");
	StringBuffer sb2=new StringBuffer("abc");
	System.out.println(sb1.equals(s2));//打印结果为false
	
3.String类对象可以用操作符	"+"进行连接,而StringBuffer类对象之间不能,
	String s1="a";
	String s2="b";
	String s3=s1+s2;//合法
	System.out.println(s3);//打印输出:ab
	StringBuffer sb1=new StringBuffer("a");
	StringBuffer sb2=new StringBuffer("b");
	StringBuffer sb3=sb1+sb2; //编译出错

方法声明	功能描述
int indexOf(int ch)	返回指定字符在此字符串中第一次出现的索引
int length()	返回此字符串的的长度
boolean equals(Object anObject)	判断字符串与指定字符串比较是否相同
boolean startsWith(String prefix)	判断字符串是否以指定的字符串开始
String replace(CharSequence oldstr,CharSequence newstr)	返回一个新的字符串,他是通过用newstr替换此字符串中出现的所有的oldstr得到的
String[] split(String regex)	根据参数regex将原来的字符串分割为若干个字符串 (个人理解则为删除参数regex后形成的字符串数组)

2.System类和Runtime类
1.System类

System类定义了一些与系统相关的属性和方法,它所提供的属性和方法都是静态的,因此System.方法名就能用

System类的常用方法

方法声明	功能描述
static void exit(int status)	该方法终止正在运行的java虚拟机,status若为非0,则表示异常终止
static void gc()	垃圾回收

2.Runtime类
略

3.Math类和Random类

1.Math类
public class ex1{
	public class static void main(String[] args){
		System.out.println("计算绝对值的结果:"+Math.abs(-1));
		System.out.println("求小数进行四舍五入的结果:"+Math.round(-4.6));
		System.out.println("求两个数的较大值:"+Math.max(2.1,-2.1));
		System.out.println("求两个数的较小值:"+Math.min(2.1,-2.1));
	}
}
运行结果:
计算绝对值的结果:1
求小数进行四舍五入的结果:-5
求两个数的较大值:2.1
求两个数的较大值:-2.1

2.Random类
import java.utill.Random;
public class ex1{
	public static void main(String[] args){
		Random r=new Ramdom();
		//随机生成[0,100)之间的整数
		for(int x=0;x<10;x++){
			System.out.println(r.nextInt(100));
		}
	}
}

***3.包装类***
1.
public class ex1{
	public static void main(String[] args){
		int a=20;
		Integer in=new Integer(a);
		System.out.println(in.toString());
	}
}
输出结果:20

2.
public class ex2{
	public static void main(String[] args){
		Integer num=new Integer(20);
		int a=10;
		int sum=num.intValue()+a;//将Integer对象转化为int类型
		System.out.println("sum="+sum);
	}
}
输出结果:sum=30

3.自动装箱
int num=20;
Integer number=num;

4.自动拆箱
Integer number=new Integer(18);
int number2=number;

第六章 集合类

1.单列集合Collection
单列集合的根接口,有两个重要子接口List和Set
List特点:元素有序,可重复
Set特点:元素无序,不可重复

List接口主要实现类有ArrayList和LinkedList
Set接口主要实现类有HashSet和TreeSet

2.双列集合Map
双列集合的根接口
具有存储有键(Key) 值(Value)映射关系的元素,每个元素都包含一对键值,在使用Map集合时可以通过指定的Key找对应的Value.
Map接口的主要实现类有HashMap和TreeMap

3.ArrayList集合

import java.util.*; 该语句可把java.util的所有包导入进来

import java.util.*;//使用时一定要记得写该语句导包或import java.util.ArrayList
public class ex1{
	public static void main(String[] args){
		ArrayList list=new ArrayList();
		list.add("st1");
		list.add("st2");
		list.add("st3");
		System.out.println("集合的长度是:"+list.size());
		System.out.println("第二个元素是:"+list.get(1));
	}
}

3.LinkedList集合

import java.util.*;
public class ex2{
	public static void main(String[] args){
		Linkedlist list=new LinkedList();
		list.add("st1");
		list.add("st2");
		list.add("st3");
		System.out.println("link.toString()");
		link.add(3,"Student");
		link.addFirst("First");//LinkedList集合里特有的方法
		System.out.println("link");
		System.out.println("link.getFirst()");LinkedList集合里特有的方法
		link.remove(3);
		link.removeFirst();//LinkedList集合里特有的方法
		System.out.println(link);
	}
}
输出结果:
[st1,st2,st3]
[First,st1,st2,st3,Student]
[First]
[st1,st2,Student]

3.Iterator接口

Iterator主要用于迭代访问(遍历)Collection中的元素,因此Iterator对象也称为迭代器

import java.util.*;
public class ex1{
	public static void main(String[] args){
		ArrayList list=new ArrayList();
		list.add("st1");
		list.add("st2");
		list.add("st3");
		Iterator it=list.iterator();
		while(it.hashNext()){
			Object obj=it.next();
			System.out.println(obj);	
		}
	}
}
运行结果:
st1
st2
st3

4.foreach循环

for(容器中元素类型 临时变量:容器变量){
	执行语句
}
1.
import java.util.*;
public class ex1{
	public static void main(String[] args){
		ArrayList list=new ArrayList();
		list.add("Jack");
		list.add("Rock");
		list.add("Tom");
		for(Object obj: list){
			System.out.println(obj);
		}
	}
}
运行结果:
Jack
Rock
Tom

2.当foreach循环遍历集合和数组时,只能访问集合中国的元素,不能对其中的元素进行修改
import java.util.*;
public class ex2{
	static String[] strs={"aaa","bbb","ccc"};
	public static void main(String[] args){
		for(String str:strs){
			str="ddd";
		}
		System.out.println("foreach循环修改后的数组:"+strs[0]+","+strs[1]+","+strs[2]);
		for(int i=0;i<strs.length;i++){
			strs[i]="ddd";
		}
	}
	System.out.println("for循环修改后的数组:"+strs[0]+","+strs[1]+","+strs[2]);
}
运行结果:
foreach循环修改后的数组:aaa,bbb,ccc
for循环修改后的数组:ddd,ddd,ddd

5.Set接口

1.HashSet集合
import java.util.*;
public class ex1{
	public static void main(String args){
		HashSet s=new HashSet();
		s.add("jack");
		s.add("tom");
		s.add("eve");
		Iterator it=s.iterator();
		while(it.hashNext()){
			Object obj=it.next();//因为不清楚返回的值是什么类型,所以用Object类型安全
			System.out.println(obj);
		}
	}
}

2.
import java.util.*;
class Student{
		private String id;
		private String name;
		public Student(String id,String name){
			this.id=id;
			this.name=name;
		}
		public String toString(){
			return id+":"+name;
		}
		public int hashCode(){
			return id.hashCode();
		}
		public boolean equals(Object obj){
			if(this==obj){//通过地址比较是否是同一个对象
				return ture;
			}
			if (!(obj instanceof Student)){
				return false;
			}
			Student stu=(Student) obj;//将对象强制转化为Student类
			boolean b=this.id.equals(stu.id)//判断id值是否相同
			return b;
	}
}
//如果Student类不重写hashCode()和equals()方法 则出现相同元素不符合HashSet集合的特性
public ex3{
	public static void main(String[] args)
	HashSet hs=new HashSet();//创建HashSet对象
	Student stu1=new Student("1","jack");//创建Student对象
	Student stu2=new Student("2","rock");
	Student stu3=new Student("2","rock");
	hs.add(stu1);//向集合存入对象
	hs.add(stu2);
	hs.add(stu3);
	System.out.println(hs);
}
输出结果:
[2:rock,1:jack]

6.Map接口

Map接口是双列集合,每个元素都包含一个键对象Key和值对象Value(不能相同)
映射关系:只要指定了Key,就能找到对应的Value

import java.util.*;
public class ex1{
	public static void main(String[] args){
		Map map=new HashMap();//创建Map集合
		map.put("1","Jack");//存储键和值
		map.put("2","Rose");
		map.put("3","Lucy");
		Set keySet=map.keySet();//获取键的集合
		Iterator it=keySet.iterator();//迭代(遍历)键的集合
		while(it.hasNext()){
			Object key=it.next();
			Object value=map.get(key);//获取每个键所对应的值
			System.out.println(key+":"+value);
		}
	}
}
运行结果:
3:Lucy
2:Rose
1:Jack

import java.util.*;
public class ex1{
	public static void main(String[] args){
		Map m=new LinkedHashMap();//创建Map集合
		map.put("1","Jack");//存储键和值
		map.put("2","Rose");
		map.put("3","Lucy");
		Set keySet=map.keySet();//获取键的集合
		Iterator it=keySet.iterator();//迭代(遍历)键的集合
		while(it.hasNext()){
			Object key=it.next();
			Object value=map.get(key);//获取每个键所对应的值
			System.out.println(key+":"+value);
		}
	}
}
运行结果:
1:Jack
2:Rose
3:Lucy

7.泛型

ArratList<参数化类型> list=new ArrayList<参数化类型>();

import java.util.*;
public class ex{
	public static void main(String[] args){
		ArrayList<String> list=new ArrayList<String>();
		list.add("Strig");
		list.add("Collection");
		for(String str:list){
			System.out.println(str);	
		}
	}
}
输出结果:
String
Collection