您的位置:首页 > 编程语言 > Java开发

JAVA 基础加强学习笔记

2014-06-20 19:22 387 查看
一、面向对象

(一)继承

1.继承的好处:

(1) 提高了代码的复用性。

(2) 让类与类之间产生了关系,提供了另一个特征多态的前提。

注意: 子类中所有的构造函数都会默认访问父类中的空参数的构造函数,因为每一个子类构造内第一行都有默认的语句super(); 如果父类中没有空参数的构造函数,那么子类的构造函数内,必须通过super语句指定要访问的父类中的构造函数。 如果子类构造函数中用this来指定调用子类自己的构造函数,那么被调用的构造函数也一样会访问父类中的构造函数。

2.final特点:

(1) 这个关键字是一个修饰符,可以修饰类,方法,变量。

(2) 被final修饰的类是一个最终类,不可以被继承。

(3) 被final修饰的方法是一个最终方法,不可以被覆盖。

(4) 被final修饰的变量是一个常量,只能赋值一次。

3.抽象类的特点:

(1) 抽象方法只能定义在抽象类中,抽象类和抽象方法必须由abstract关键字修饰(可以描述类和方法,不可以描述变量)。

(2) 抽象方法只定义方法声明,并不定义方法实现。

(3) 抽象类不可以被创建对象(实例化)。

(4) 只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后,该子类才可以实例化。否则,该子类还是一个抽象类。

(5),抽象类只能单继承。

4.抽象类的细节:

(1) 抽象类中是否有构造函数?有,用于给子类对象进行初始化。

(2) 抽象类中是否可以定义非抽象方法? 可以。其实,抽象类和一般类没有太大的区别,都是在描述事物,只不过抽象类在描述事物时,有些功能不具体。所以抽象类和一般类在定义上,都是需要定义属性和行为的。只不过,比一般类多了一个抽象函数。而且比一般类少了一个创建对象的部分。

(3) 抽象关键字abstract和哪些不可以共存?final , private , static

(4) 抽象类中可不可以不定义抽象方法?可以。抽象方法目的仅仅为了不让该类创建对象。

5.接 口:

如果一个抽象类中的所有方法都是抽象的,且这个抽象类中的数据成员都是final的常量,那么,这个抽象类实际上就是一个接口,即一种特殊的抽象类。对于实现该接口的子类来说,接口不提供任何实现,接口是抽象方法和常量值定义的集合。

接口具有以下特点:

(1) 接口中的常量默认为public static final,而且也只能是public static final

(2) 接口中只能定义抽象方法,这些方法默认为public abstract,而且也只能是public abstract

(3) 接口可以继承其他接口,而且可以添加新的属性和抽象方法

(4) 在接口中声明方法时不能使用static、final、private等修饰符

(5) Java不允许类的多继承,但允许接口的多继承

(6) 不允许创建接口的实例,但允许定义接口类型的引用变量,改变量要引用实现了该接口的类的实例

(7) 一个类只能继承另外一个类,但能同时实现多个接口,并且重写方法必须显示声明为public

抽象类和接口的区别:

(1) 抽象类只能被继承,而且只能单继承。 接口需要被实现,而且可以多实现。

(2) 抽象类中可以定义非抽象方法,子类可以直接继承使用。 接口中的方法都是抽象方法,需要子类去实现。

(3) 抽象类使用的是 is a 关系。 接口使用的 like a 关系。

(4) 抽象类的成员修饰符可以自定义。

接口中的成员修饰符是固定的。全都是public的。

(二)多 态

多态是面向对象特征之一,构造函数本身就具备多态性,某一种事物有不同的具体的体现。 体现:父类引用或者接口的引用指向了自己的子类对象。

//Animal a = new Cat();

多态的好处:提高了程序的扩展性。

多态的弊端:当父类引用指向子类对象时,虽然提高了扩展性,但是只能访问父类中具备的方法,不可以访问子类中特有的方法。(前期不能使用后期产生的功能,即访问的局限性)

多态的前提:

1:必须要有关系,比如继承、或者实现。

2:通常会有覆盖操作。

(三)匿名内部类

匿名内部类是没有名字的内部类。就是内部类的简化形式。一般只用一次就可以用

这种形式。匿名内部类其实就是一个匿名子类对象。想要定义匿名内部类:需要前提,内部类必须继承一个类或者实现接口。

匿名内部类的格式:new 父类名&接口名(){ 定义子类成员或者覆盖父类方法 }.方法。

匿名内部类的使用场景:

当函数的参数是接口类型引用时,如果接口中的方法不超过3个。可以通过匿名内部类来完成参数的传递。 其实就是在创建匿名内部类时,该类中的封装的方法不要过多,最好两个或者两个以内。

二、多线程

线程的两种创建方式

(一)创建线程的第一种方式:

继承Thread ,由子类复写run方法。

步骤:

1,定义类继承Thread类;

2,目的是复写run方法,将要让线程运行的代码都存储到run方法中;

3,通过创建Thread类的子类对象,创建线程对象;

4,调用线程的start方法,开启线程,并执行run方法。

线程状态:

1新建:start()

2运行:具备执行资格,同时具备执行权;

3休眠:sleep(time),wait()—notify()唤醒;线程释放了执行权,同时释放执行资格; 临时

4阻塞状态:线程具备cpu的执行资格,没有cpu的执行权;

5消亡:stop()

例子:

package com.OpenWealth.ZSY;

import java.io.*;
import java.net.*;

public class TCPServer{

@SuppressWarnings("resource")
public static void main(String[] args) throws Exception{

ServerSocket ss=null;
ss=new ServerSocket(8866);
while(true){

try {

Socket soc=ss.accept();

new MyPicServerThread(soc).start();//开启服务端接受图片的线程

} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

/***
* 实现了多用户并发上传图片的服务端
* @author 支胜勇
*
*/
public static class MyPicServerThread extends Thread{

private Socket soc=null;

public MyPicServerThread(Socket _soc){
this.soc=_soc;
}

@Override
public void run() {
// TODO Auto-generated method stub
String clientIp=soc.getInetAddress().getHostAddress();
try {

System.out.println(clientIp+"已连接!");

InputStream in=soc.getInputStream();

FileOutputStream fos=new FileOutputStream("E:\\TcpTest.png");

byte[] buff=new byte[1024];

int len=0;

while((len=in.read(buff))!=-1){

fos.write(buff,0,len);
}

OutputStream out=soc.getOutputStream();

out.write("图片上传成功!".getBytes());

fos.close();

soc.close();

} catch (IOException e) {
// TODO Auto-generated catch block
throw new RuntimeException("客户端"+clientIp+"上传失败");
}

}
}
}


(二)创建线程的第二种方式:

实现一个接口Runnable。

步骤:

1,定义类实现Runnable接口。

2,覆盖接口中的run方法(用于封装线程要运行的代码)。

3,通过Thread类创建线程对象;

4,将实现了Runnable接口的子类对象作为实际参数传递给Thread类中的构造函数。 为什么要传递呢?因为要让线程对象明确要运行的run方法所属的对象。

5,调用Thread对象的start方法。开启线程,并运行Runnable接口子类中的run方法。

如:Ticket t = new Ticket();

直接创建Ticket对象,并不是创建线程对象。

因为创建对象只能通过new Thread类,或者new Thread类的子类才可以。 所以最终想要创建线程。既然没有了Thread类的子类,就只能用Thread类。

Thread t1 = new Thread(t); //创建线程。

只要将t作为Thread类的构造函数的实际参数传入即可完成线程对象和t之间的关联

为什么要将t传给Thread类的构造函数呢?其实就是为了明确线程要运行的代码run方法。

例子:

package com.OpenWealth.ZSY;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.net.*;
import java.util.ArrayList;
import java.util.List;
import java.io.*;
public class TCPClientSocket {

public static void main(String args[]) throws Exception{

BufferedReader buff=new BufferedReader(new InputStreamReader(System.in));

//同时上传多张图片
while(true){
String imgUrl=buff.readLine();
new Thread(new MyUpLoadPicClient(imgUrl,"localhost",8866)).start();
}

}

/**
* 实现了同时上传多张图片的客户端;可以上传多种格式的图片
* @author 支胜勇
*
*/
public static class MyUpLoadPicClient implements Runnable{

private File imgFile;

private String ip;

private int port;

private Socket soc;

private List<String> extensList=null;

private OutputStream out;
private FileInputStream fis;

/***
* 初始化构造方法
* @param imgUrl
* @param ip:服务器IP地址
* @param port:服务器端口
* @throws Exception
*/
public MyUpLoadPicClient(String imgUrl,String ip,int port) throws Exception{

this.imgFile=new File(imgUrl);
this.ip=ip;
this.port=port;

extensList=new ArrayList<String>();
extensList.add(".jpg");
extensList.add(".png");
extensList.add(".gif");
extensList.add(".jpeg");
extensList.add(".bmp");

}

public boolean isImg(){

if(!imgFile.exists()){//||!imgFile.isFile()
System.out.println("图片不存在,请重新上传!");
return false;
}

if(!imgFile.isFile()){//||!imgFile.isFile()
System.out.println("不是图片文件,请重新上传!");
return false;
}

String extenName=imgFile.getName().substring(imgFile.getName().lastIndexOf(".")).toLowerCase();
if(!extensList.contains(extenName)){

System.out.println("请上传jpg,png,gif,bmp,jpeg格式的图片");
return false;
}

if(imgFile.length()>1024*1024*5){
System.out.println("图片过大,请上传5m以内的图片!");
return false;
}

try {

fis=new FileInputStream(imgFile);

} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return true;
}

/***
* 执行向服务器上传图片的代码
*/
@Override
public void run() {
// TODO Auto-generated method stub
if(!isImg()){
return;
}else{
try {
this.soc=new Socket(this.ip,this.port);
out=soc.getOutputStream();
byte[] buff=new byte[1024];
int len=0;
while( (len=fis.read(buff)) != -1 ){

out.write(buff,0,len);
}
soc.shutdownOutput();//告诉服务器上传结束

InputStream in=soc.getInputStream();

byte[] bufIn=new byte[1024];

int num=in.read(bufIn);

System.out.println(new String(bufIn,0,num));

fis.close();
out.close();
soc.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
}
}
}


(三)多线程安全问题的原因:

通过图解:发现一个线程在执行多条语句时,并运算同一个数据时,在执行过程中,其他线程参与进来,并操作了这个数据。导致到了错误数据的产生。

涉及到两个因素:

1,多个线程在操作共享数据。

2,有多条语句对共享数据进行运算。

原因:这多条语句,在某一个时刻被一个线程执行时,还没有执行完,就被其他线程执行了。

解决安全问题的原理: 只要将操作共享数据的语句在某一时段让一个线程执行完,在执行过程中,其他线程不能进来执行就可以解决这个问题。

如何进行多句操作共享数据代码的封装呢?

java中提供了一个解决方式:就是同步代码块。

格式:

synchronized(对象) { // 任意对象都可以。这个对象就是锁。

需要被同步的代码; }

Synchronized(自己的会写得出)

wait和sleep区别:

分析这两个方法:从执行权和锁上来分析:

wait:可以指定时间也可以不指定时间。不指定时间,只能由对应的notify或者notifyAll来唤醒。

sleep:必须指定时间,时间到自动从冻结状态转成运行状态(临时阻塞状态)。

wait:线程会释放执行权,而且线程会释放锁。

Sleep:线程会释放执行权,但不是不释放锁。

三、JDK1.5新特性

(一)Collection在jdk1.5以后,有了一个父接口Iterable,这个接口的出现的将iterator方法进行抽取,提高了扩展性。

(二)增强for循环:

foreach语句,foreach简化了迭代器。

格式:// 增强for循环括号里写两个参数,第一个是声明一个变量,第二个就是需要迭代的容器

for( 元素类型 变量名 : Collection集合 & 数组 ) { „ }

高级for循环和传统for循环的区别:

高级for循环在使用时,必须要明确被遍历的目标。这个目标,可以是Collection集合或者数组,如果遍历Collection集合,在遍历过程中还需要对元素进行操作,比如删除,需要使用迭代器。

如果遍历数组,还需要对数组元素进行操作,建议用传统for循环因为可以定义角标通过角标操作元素。如果只为遍历获取,可以简化成高级for循环,它的出现为了简化书写。 高级for循环可以遍历map集合吗?不可以。但是可以将map转成set后再使用foreach语句。

1)、作用:对存储对象的容器进行迭代: 数组 collection map

2)、增强for循环迭代数组:

String [] arr = {"a", "b", "c"};//数组的静态定义方式,只试用于数组首次定义的时候

for(String s : arr) { System.out.println(s); }

3)、单列集合 Collection:

List list = new ArrayList(); list.add("aaa"); // 增强for循环, 没有使用泛型的集合能不能使用增强for循环迭代?能 for(Object obj : list) { String s = (String) obj; System.out.println(s); }

4)、双列集合 Map:

package com.ItHeima.WeekAct;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class Test5 {
public static void main(String[] args){

Map<String, String> map = new HashMap<String, String>();

map.put("a", "aaa");

// 传统方式
Set entrys = map.entrySet();
// 1.获得所有的键值对Entry对象
Iterator iter = entrys.iterator();

// 2.迭代出所有的entry
while(iter.hasNext()) {

Map.Entry entry = (Entry) iter.next();

String key = (String) entry.getKey(); // 分别获得key和value

String value = (String) entry.getValue(); System.out.println(key + "=" + value); }

// 增强for循环迭代:原则上map集合是无法使用增强for循环来迭代的,因为增强for循环只能针对实现了Iterable接口的集合进行迭代;Iterable是jdk5中新定义的接口,就一个方法iterator方法,只有实现了Iterable接口的类,才能保证一定有iterator方法,java有这样的限定是因为增强for循环内部还是用迭代器实现的,而实际上,我们可以通过某种方式来使用增强for循环。
for(Object obj : map.entrySet()) {

Map.Entry entry = (Entry) obj;  // obj 依次表示Entry

System.out.println(entry.getKey() + "=" + entry.getValue()); }
//5)、集合迭代注意问题:在迭代集合的过程中,不能对集合进行增删操作(会报并发访问异常);可以用迭代器的方法进行操作(子类listIterator:有增删的方法)。
//6)、增强for循环注意问题:在使用增强for循环时,不能对元素进行赋值;
int[] arr = {1,2,3}; for(int num : arr) { num = 0; //不能改变数组的值 }

System.out.println(arr[1]); //2
}
}
}


(三)可变参数(...)

用到函数的参数上,当要操作的同一个类型元素个数不确定的时候,可是用这个方式,这个参数可以接受任意个数的同一类型的数据。 和以前接收数组不一样的是:

以前定义数组类型,需要先创建一个数组对象,再将这个数组对象作为参数传递给函数。现在,直接将数组中的元素作为参数传递即可。底层其实是将这些元素进行数组的封装,而这个封装动作,是在底层完成的,被隐藏了。所以简化了用户的书写,少了调用者定义数组的动作。

如果在参数列表中使用了可变参数,可变参数必须定义在参数列表结尾(也就是必须是最后一个参数,否则编译会失败。)。

如果要获取多个int数的和呢?可以使用将多个int数封装到数组中,直接对数组求和即可。

(四)静态导入

导入了类中的所有静态成员,简化静态成员的书写。

import static java.util.Collections.*; //导入了Collections类中的所有静态成员

(五)枚举

关键字 enum

问题:对象的某个属性的值不能是任意的,必须为固定的一组取值其中的某一个; 解决办法: 1)、在setGrade方法中做判断,不符合格式要求就抛出异常; 2)、直接限定用户的选择,通过自定义类模拟枚举的方式来限定用户的输入,写一个Grade类,私有构造函数,对外提供5个静态的常量表示类的实例; 3)、jdk5中新定义了枚举类型,专门用于解决此类问题;

4)、枚举就是一个特殊的java类,可以定义属性、方法、构造函数、实现接口、继承类;

自动拆装箱:java中数据类型分为两种 : 基本数据类型 引用数据类型(对象)

在 java程序中所有的数据都需要当做对象来处理,针对8种基本数据类型提供了包装类,如下:

int --> Integer byte --> Byte short --> Short long --> Long char --> Character

例子:

package com.OpenWealth.Traffic;

/***
* 关于方向的枚举类
* @author 支胜勇
*
*/
public enum Direction {

EAST{

@Override
public Direction reverse() {
// TODO Auto-generated method stub
return WEST;
}

@Override
public Direction positive() {
// TODO Auto-generated method stub
return EAST;
}

@Override
public Direction leftSide() {
// TODO Auto-generated method stub
return SOUTH;
}

@Override
public Direction rightSide() {
// TODO Auto-generated method stub
return NORTH;
}

},
SOUTH{

@Override
public Direction reverse() {
// TODO Auto-generated method stub
return SOUTH;
}

@Override
public Direction positive() {
// TODO Auto-generated method stub
return NORTH;
}

@Override
public Direction leftSide() {
// TODO Auto-generated method stub
return WEST;
}

@Override
public Direction rightSide() {
// TODO Auto-generated method stub
return EAST;
}

}
,WEST{

@Override
public Direction reverse() {
// TODO Auto-generated method stub
return WEST;
}

@Override
public Direction positive() {
// TODO Auto-generated method stub
return EAST;
}

@Override
public Direction leftSide() {
// TODO Auto-generated method stub
return NORTH;
}

@Override
public Direction rightSide() {
// TODO Auto-generated method stub
return SOUTH;
}

},NORTH{

@Override
public Direction reverse() {
// TODO Auto-generated method stub
return NORTH;
}

@Override
public Direction positive() {
// TODO Auto-generated method stub
return SOUTH;
}

@Override
public Direction leftSide() {
// TODO Auto-generated method stub
return EAST;
}

@Override
public Direction rightSide() {
// TODO Auto-generated method stub
return WEST;
}
};

/**
* 该方向的反方向
* @return
*/
public abstract Direction reverse();

/**
* 该方向的正方向
* @return
*/
public abstract Direction positive();

/**
* 该方向的左面
* @return
*/
public abstract Direction leftSide();

/**
* 该方向的右面
* @return
*/
public abstract Direction rightSide();

}


四、高新技术

(一)反射

反射技术:其实就是动态加载一个指定的类,并获取该类中的所有的内容。而且将字节

码文件封装成对象,并将字节码文件中的内容都封装成对象,这样便于操作这些成员。简单说:反射技术可以对一个类进行解剖。 反射的好处:大大的增强了程序的扩展性。 反射的基本步骤:

1、获得Class对象,就是获取到指定的名称的字节码文件对象。

2、实例化对象,获得类的属性、方法或构造函数。

3、访问属性、调用方法、调用构造函数创建对象。

获取这个Class对象,有三种方式:

1:通过每个对象都具备的方法getClass来获取。弊端:必须要创建该类对象,才可以调用getClass方法。

2:每一个数据类型(基本数据类型和引用数据类型)都有一个静态的属性class。弊端:必须要先明确该类。

前两种方式不利于程序的扩展,因为都需要在程序使用具体的类来完成。

3:使用Class类中的方法,静态的forName方法。

指定什么类名,就获取什么类字节码文件对象,这种方式的扩展性最强,只要将类名的字符串传入即可。

// 1. 根据给定的类名来获得  用于类加载
String classname = "cn.itcast.reflect.Person";// 来自配置文件
Class clazz = Class.forName(classname);// 此对象代表Person.class
// 2. 如果拿到了对象,不知道是什么类型   用于获得对象的类型
Object obj = new Person();
Class clazz1 = obj.getClass();// 获得对象具体的类型
// 3. 如果是明确地获得某个类的Class对象  主要用于传参 Class clazz2 = Person.class;
//反射的用法:
//1)、需要获得java类的各个组成部分,首先需要获得类的Class对象,获得Class对象的三种方式:
Class.forName(classname) //用于做类加载
obj.getClass() //用于获得对象的类型 类名.class     用于获得指定的类型,传参用
//2)、反射类的成员方法:
Class clazz = Person.class;
Method method = clazz.getMethod(methodName, new Class[]{paramClazz1, paramClazz2}); method.invoke();
//3)、反射类的构造函数:
Constructor con = clazz.getConstructor(new Class[]{paramClazz1, paramClazz2,...}) con.newInstance(params...)
//4)、反射类的属性:
Field field = clazz.getField(fieldName); field.setAccessible(true); field.setObject(value);


获取了字节码文件对象后,最终都需要创建指定类的对象:

创建对象的两种方式(其实就是对象在进行实例化时的初始化方式):

1,调用空参数的构造函数:使用了Class类中的newInstance()方法。

2,调用带参数的构造函数:先要获取指定参数列表的构造函数对象,然后通过该构造函数的对象的newInstance(实际参数) 进行对象的初始化。

综上所述,第二种方式,必须要先明确具体的构造函数的参数类型,不便于扩展。所以一般情况下,被反射的类,内部通常都会提供一个公有的空参数的构造函数。

// 如何生成获取到字节码文件对象的实例对象。
Class clazz  =  Class.forName("cn.itcast.bean.Person"); //类加载
// 直接获得指定的类型
clazz  =  Person.class;
// 根据对象获得类型
Object obj  =  new Person("zhangsan",  19);
clazz  =  obj.getClass();
Object obj  =  clazz.newInstance(); //该实例化对象的方法调用就是指定类中的空参数构造函数,给创建对象进行初始化。当指定类中没有空参数构造函数时,该如何创建该类对象呢?请看method_2();
public static void method_2() throws Exception  {
Class clazz  =  Class.forName("cn.itcast.bean.Person");
}
//既然类中没有空参数的构造函数,那么只有获取指定参数的构造函数,用该函数来进行实例化。
//获取一个带参数的构造器。
Constructor constructor  =  clazz.getConstructor(String.class, int.class);  //想要对对象进行初始化,使用构造器的方法newInstance();
Object obj = constructor.newInstance("zhagnsan",30); //获取所有构造器。
Constructor[] constructors  =  clazz.getConstructors(); //只包含公共的
constructors = clazz.getDeclaredConstructors();//包含私有的
for(Constructor con : constructors) {
System.out.println(con);
}

//反射指定类中的方法:  //获取类中所有的方法。
public static void method_1() throws Exception  {
Class clazz  =  Class.forName("cn.itcast.bean.Person");
Method[] methods  =  clazz.getMethods(); //获取的是该类中的公有方法和父类中的公有方法。
}
methods  =  clazz.getDeclaredMethods(); //获取本类中的方法,包含私有方法。 for(Method method : methods) { System.out.println(method); } }
//获取指定方法;
public static void method_2() throws Exception  {
Class clazz  =  Class.forName("cn.itcast.bean.Person");  //获取指定名称的方法。
}
Method method  =  clazz.getMethod("show",  int.class, String.class);
//想要运行指定方法,当然是方法对象最清楚,为了让方法运行,调用方法对象的invoke方法即可,但是方法运行必须要明确所属的对象和具体的实际参数。 Object obj = clazz.newInstance();
method.invoke(obj,  39, "hehehe"); //执行一个方法 }
//想要运行私有方法。
public static void method_3() throws Exception  {
Class clazz  =  Class.forName("cn.itcast.bean.Person");  //想要获取私有方法。必须用getDeclearMethod();
}
Method method  =  clazz.getDeclaredMethod("method",  null);
// 私有方法不能直接访问,因为权限不够。非要访问,可以通过暴力的方式。 method.setAccessible(true);//一般很少用,因为私有就是隐藏起来,所以尽量不要访问。 }
//反射静态方法。
public static void method_4() throws Exception  {
Class clazz  =  Class.forName("cn.itcast.bean.Person");
Method method  =  clazz.getMethod("function", null);
method.invoke(null, null);
}
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: