Java之面向对象编程20170619

/******************************************************************************************************************/

一、类的引入:

1.c语言中通过结构体中的函数访问变量要么定义的是全局变量要么传入整个该结构体。而在JAVA中的函数成员可直接访问类(结构体)中的变量成员

2.

1)class可以看作是一种(类似结构体的)变量类型，术语上称为类，相对应的变量术语上称为对象，

类也可以叫概念，对象可称为实例化，即类创建对象可称为类的实例化或概念的实例化

2）

Dog dog=new Dog()

左边是创建一个Dog类的引用，右边是创建Dog类的一个对象，这个过程就是类的实例化(创建类的实例化对象)也就是把对象的值赋给引用（相当于创建了一个结构体变量并进行了初始化）

3)创建对象就相当于给结构体进行初始化，创建后除了分配了内存，构造函数被调用，其中的方法也可以被调用了(除了加了static的方法，因为加了是静态的，就不需要创建也能调用了)，相当于结构体里面的函数指针对初始化了，可以被使用了

3.构造方法

1)类中的一个方法成员，该方法格式为:public 该类的类名(没有任何返回值void都不行，可以有传入参数)，该方法就是构造方法，创建对象时该方法会自动执行

可以有多个构造方法，类似于函数重载(根据不同类型参数，不同个数 参数访问对应的函数)

2)如果一个类没有实现构造方法，java编译器会给他定义一个空的构造方法。

4.一个文件中只能有一个public class，并且该类类名要与文件名相同

5.super和this

1)简单理解，super是指向父类的，this是指向当前类的

2)类中函数的形参名字如果与变量成员名字相同，则有问题，根据参数就近使用原则，这样就等于都在操作形参没有意义。

为解决这个问题进行区分，引入this(当前的)关键字

加入this表示是当前类中的，比如变量名前加this表示该变量是当前类中的成员变量

6.static 关键字

方法前面加static 表示在不创建任何对象的时候都可以调用它(调用方式:类名.方法)，属于类方法

同时如果在字段（数据成员）前面加static ，表示这个字段对于同一个类所创建各个

对象来说都只有一份空间，属于类的数据成员(不创建对象也是存在的)

不加static则是每个对象都有一个存储空间。

7.代码块

1)普通代码块，方法｛｝里面的代码集合

2）构造块，在class里面用{}括起来的代码为构造块，每实例化一个对象前，都执行；先于构造方法执行

3)静态代码块，static{}，括号里面的为静态代码块，实例化第一个对象前执行，并且只执行一次

局部变量的作用域在代码块的范围中

/******************************************************************************************************************/

二、封装性:

1.把属性和方法封装为一个整体，并具有权限，

一般是通过公有函数访问私有数据成员(c语言也可以实现，在文件中定义静态的全局变量，再把操作该变量的函数前面加上static并放在结构体里，这样外部只能通过结构体函数成员访问变量，类似于公有函数访问私有数据成员,加上static的函数不放在结构体里就类似于私有函数(方法)，整个文件以及结构体变量可以看作对象,全局变量类型以及结构体变量类型可以看作类)

权限有四类

1)private 本类可访问

2)default 本包可访问

3)protected 本包，其他包子类可访问

4)public 所有

/******************************************************************************************************************/

三、继承性:

1.继承性的目的:为了复用代码

定义类的使用后面加上: extends(扩展)  类名

2.覆写

子类可以定义和父类形式一样(函数名一样)的方法(内部语句不一样)，调用子类的该方法将执行子类定义的方法，如果子类中没有定义则会调用父类中的该方法

3.构造方法

实例化子类对象时，先调用父类的构造方法，在调用子类的构造方法

1)默认调用父类没有参数的构造方法，即相当于在子类的构造方法中第一行加入super();//父类无参数的构造方法

2)如果在子类加入super(6)而不是super()，则会调用父类带参数的构造方法，不会调用父类不带参数的构造方法

4.final关键字

1)final类不能有子类

2)final方法不能被覆写

3)final变量变成常量，不能被修改

5.继承的限制

1)子类无法直接操作父类的私有数据成员

2)子类无法使用父类的私有方法成员

3)子类不能私吞祖传的东西，应该是继承发扬，

即子类覆写的方法不能缩小权限，也就是覆写父类方法不能修改属性为私有的

6.抽象类

1)即在class前面加上关键字abstract,并且在类内部有抽象方法(在方法的访问权限后面加上abstract关键字，同时只需要声明不需要实现(没有函数体),定义抽象函数必须是在抽象类里面)

2)子类继承抽象类，必须实现(覆写)父类中所有的抽象方法

3)作用:制作一个模版让继承者必须实现

4)注意:抽象类不能用于创建对象，即不能用来实例化对象

　　正是由于不能实例化,所以要继承才行，也就意味着抽象类中的方法的访问权限至少是protected以上，否则是不合法的。又由于抽象类一定要继承才行,所以其中的方法的访问权限public和protected就没区别了,一般习惯性使用public

5)类内部的还可以定义变量，常量，以及普通方法

7.接口(可以理解为特殊的类,实现接口可理解为继承特殊的类)

1)抽象名称前加interface,省略了class

2）接口内部只能定义全局(public 实现者可以直接使用)常量和公共抽象方法，

即使数据成员的类型前面没有加final和public，还是一个全局常量

即使抽象方法前面没有加public abstract也还是抽象方法

3)作用；和抽象类类似，起模版作用：子类可以继承多个接口

4)子类继承(实现)接口(使用implements不再是extends)，必须覆写(实现)全部抽象方法,

5)一个接口可以继承多个接口：这里是继承不是实现，因为没有复写

interface A{

void funa();

}

interface B{

void funb();

}

interface C extends A,B{//这样C中就包含A,B中的方法，当实现C的时候就要复写A,B中的，也就是三个方法都要复写

void func();

}

8.总结抽象类与接口:

1)子类可以又继承类又实现接口(extends 类名 implements 接口名)

2)抽象类可以容纳更多的其他类型的内容,接口可以突破单继承的限制，即子类可以实现多个接口

3)抽象类和接口一般都用来作为模版(内部声明抽象方法，其子类必须实现这些抽象方法)

/******************************************************************************************************************/

四、多态性(有多种状态传入一种状态能得到相对应的状态):

1.方法的多态性，

方法的重载与覆写

2.对象的多态性

1)向上转换

I、格式:父类 父类对象=子类实例(子类对象)

II、父类调用自己包含的方法中，如果在子类中已经覆写了，则调用的是子类里面的，如果没有覆写则调用的是父类自己的方法

III、应用:

public static void print(Father f) {

f.printInfo();//传进来可能是f的各个子类，这里就体现了多种状态即多态

}

传入不同的子类得到相对应的状态(方法)

print(f);

print(s);

print(d);

2)向下转换

I、格式：

父类 父类对象=new 子类();//由于父类对象空间小,如果下面转换使用小的那么小的 转换为大(会出错，大的到小没问题可以截取)，

//所以new空间大的即用子类

子类 子类对象=(子类)父类对象//强制转换

II、转换后子类对象可以使用子类中自己的方法了

III、应用:

Father f = new Father();

Son s = new Son();

Daughter d = new Daughter();

printAction(f);

printAction(s);//传入不同的子类得到相对应的状态(一般是子类特有的方法

//(自己实现的))

printAction(d);

public static void printAction(Father f) {

if (f instanceof Son) {

//传进来可能是f的各个子类，这里就体现了多种状态即多态

Son son = (Son)f;

son.playGame();

}

else if (f instanceof Daughter){

//instanceof 用来判断一个对象是不是某个类的实例

Daughter d = (Daughter)f;//向下转换

d.dance();//子类自己实现的方法

}

else if (f instanceof Father){

//子类一定是父类的实例,所以放最后

f.drink();

}

}

instanceof:用来判断一个对象是不是某个类的实例

继承和多态C难实现

/******************************************************************************************************************/

五、异常

异常分类(见图)：

1.必须处理的(Exception中除去RuntimeException的异常(可查异常))

1)自己处理:try...catch...finally

格式:

try{//异常，内部的语句就不执行了

}

catch(异常类型(所有异常类型中找符合当前的) 异常名称(自己定义))

｛//出现异常后要执行的代码

｝

finally{

}

try(可能出现异常的代码,出现异常这里的代码就不执行了)

catch(出现异常后要执行的代码)

finally(不管是否发生异常都会执行finally中的代码)

2)让别人处理:throws(对于不可查异常，系统也会抛出，写不写throws效果一样)

首先扔出public static int div(int m, int n) throws ArithmeticException {

然后外面处理:

try {

r = div(m, n);

} catch (ArithmeticException e) {

System.out.println(e);

}

3)异常处理后，其他地方就没办法再获得该异常了，除非处理完异常后再用throw关键字

抛出异常即：

try {

r = div(m, n);

} catch (ArithmeticException e) {

System.out.println(e);

throw e;//手工抛出异常，同时程序在此抛出后return(返回)

}

4）多个异常的处理:

try {

m = Integer.parseInt(args[0]);

n = Integer.parseInt(args[1]);

r = div(m, n);//这三条语句可能发送多种异常

} catch (ArithmeticException e) {//某一异常的处理(先处理子类异常)

System.out.println("main :"+e);

} catch (NumberFormatException e) {//某一异常的处理(先处理子类异常)

System.out.println("main :"+e);

} catch (RuntimeException e) {//统一处理一类异常(最后处理父类异常,其他类异常从属于该父类所以在这里得到处理)

System.out.println("main :"+e);

}

5)finally中有return的情况:

try {

r = m / n;

} catch (ArithmeticException e) {

System.out.println("div :"+e);

throw e;//在执行throw这条语句时，先执行finally里面的语句,因为finally里面有return,函数已经返回，所有抛出异常失败即没有

//抛出异常,外面也就捕获不到

} finally {

System.out.println("finally of div");

return r;

}

try或catch块中有return或throw语句,会先执行finally块,再返回来执行return或throw语句，所以最好不要在finally里面加return

6)自己创建异常(人为抛出一个异常)

public static int div(int m, int n) throws Exception {

//抛出去处理,同时外部也要捕获处理(必须有处理)

int r = 0;

try {

r = m / n;

} catch (ArithmeticException e) {

System.out.println("div :"+e);

throw new Exception("My Error");//自己创建的异常(名称My Error)(人为抛出一个异常),是可查异常(不是Runtime异常的子类)，必须处理

} finally {

System.out.println("finally of div");

}

2.可以不处理

1)java虚拟机的错误，不处理，自己也处理不了

2)程序运行过程中发生的错误(不可查异常)，可以不处理(系统也会抛出)，但不处理后果是程序直接退出

3.assert

assert boolean表达式 ;

assert boolean表达式 : 详细信息 ;

表达式为true时，无错误；

表达式为false时，打印“详细信息”

assert x == 0;

assert x == 0 : "X is not zero";

/******************************************************************************************************************/

六、包和权限

1.包实际上是一个文件夹(可以含有多级子目录)

2.格式:package 包名称.子包名称；//声明某个类属于某个包

编译的时候，编译的结果就是存放在package后面的目录中

编译:javac -d(当前目录生成目录) . 名称.java

执行:java a.b.c.d.pack

3.作用:同名java文件放在不同目录，用目录(包)来区分(如果类没有同名，可以不用前面目录也能找到对应的，即直接调用该类就行)

被引用的文件里加入：package a.b.c.d1；//表示编译后放在的目录

引用:

import a.b.c.d1.Math;//手工导入某个类

import a.b.c.d2.Math;//Math同名编译错误，可以把Math替换为*(自动加载需要的类)

a.b.c.d1.Math.add//调用方法

a.b.c.d2.Math.add

4.如果把java文件和class类文件都放在一个文件夹并打包，那么其他类想使用该打包中的文件和类文件，就需要设置环境变量，这样编译和运行的时候才可以找到要的类

设置环境变量例子:

export CLASSPATH=.:my.jar//:分隔符

恢复默认值:

export CLASSPATH=. //默认值为当前目录

5.权限(访问控制)

1)类

I public class 可以被本包和外包访问

II class 只能在本包中访问

2)类成员

I、private          　　　本类可访问

II、default(默认)   　　本包可访问

　　　　　即本类，本包可访问

III、protected     　　   本包，其他包的子类可访问(继承该类的子类(在其他包里) 中的方法成员里可访问)

　　　　　　即本类，本包，其他包的子类可访问

IV、public     　　　　  所有都可以访问

　　　　　　即本类，本包，其他包的子类和非子类可访问

/******************************************************************************************************************/

七、内部类(类里面又重新定义了一个新类)

1.内部类的唯一好处

内部类可以访问外部类中的私有属性

2.内部类的使用

Outer o=new Outer();

Outer.Inner i=o.new Inner();//内部类的实例化(需要外部类的实例化对象)

//因为需要访问外部类的变量，即使不访问也要

//先有实例化对象，这是语法规定，语法要有普适性

3.静态内部类

1)在内部类加上static(其实也就变成了属于外部类)，同时还要在访问的数据成员前加上static(即使不创建对象也是存在的),这样就不需要外部类的实例化对象

2)用static声明的内部类就变成了外部类；它只能访问外部类的static属性

3)唯一好处是可以访问外部类的静态私有属性

4.匿名内部类

某个类只使用一次，那么就不定义这个类了，直接使用匿名内部类

示例：

interface A {

public void printInfo( );

}

testFunc(new A( ) {//直接new A肯定有问题因为没有实现,后面加上实现就可以了

public void printInfo() {

System.out.println("Hello, world!");

}

});//方法中的参数即为匿名内部类

/******************************************************************************************************************/

八、IO

InputStrem OutputStream是所以字节流的父类，都是抽象类

子类有

FileInputStream FileOutputStream

例如：

OutputStream os = socket.getOutputStream();

os.write(msg.getBytes());

InputStream mmInStream = null;

mmInStream = socket.getInputStream();

if( (bytes = mmInStream.read(buffer)) > 0 ){

byte[] buf_data = new byte[bytes];

for(int i=0; i<bytes; i++) {

buf_data[i] = buffer[i];

}

String s = new String(buf_data);

ForView.setText(s);

}

mmInStream.close();

/******************************************************************************************************************/

九、线程

class FirstTread extends Thread{

public void run(){

system.out.println();

}

}

class Test{

public static main(String args[]){

FirstTread firstthread=new FirstTread();//创建线程

firstthread.start()//线程就绪运行

}

}

第二种方法：(由于继承只能使用一次，所以能不用就不用，所以第二种用的多些)

class Runnabletmp implements Runnable{

public void run(){

}

}

class Test{

public static main(String args[]){

Runnabletmp runabletmp=new Runnabletmp ();//生成一个实现接口的对象

Tread t=new Thread(runabletmp);//并将对象传进去（相当于结构体变量传进去）

t.start();

}

}

控制函数：

Tread.sleep()  Thread.yield()

getPriority() setPriority();

线程最大优先级10最小1，可以使用Thread.里面提供的静态常量当参数进行设置

被并发线程访问的共享临界区(被并发线程访问的变量或方法)在方法返回值前加上synchronized关键字。

synchronized，Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

I、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

II、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

III、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

IV、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

V、以上规则对其它对象锁同样适用.

/******************************************************************************************************************/

十、类集框架

类集框架是一组类和接口

位于java.util中

主要用于存储和管理对象

分为三大类 集合，列表，映射