[笔记][java 4 android] [020~028]复写、转型、抽象、打包、权限、异常

【020】override函数的复写

对父类的构造函数进行某种改写

使用super调用父类的成员函数

override:

在具有父子关系的两个类中，存在同样定义的成员函数，子类中的成员函数会对父类的成员函数进行override.

如：

class Person{     String name;     int age;          void introduce(){          System.out.println("我的名字是"+name+" 我的年龄是"+age);     }}

class Student extends Person{     String addr;     void studing(){          System.out.println("学习ing");     }     void introduce(){          super.introduce();     //调用父类的introduce          System.out.println("我的家在"+addr);     }}

class test{     public static void main(String arg []){          Student s = new Student();          s.name ="张山";          s.age = 12;          s.addr = "地球";          s.introduce();     }}

Tips：

调用成员函数和调用构造函数不同，位置无严格要求。

【021】对象的转型

对象的向上转型和向下转型

1、向上转型：将子类的对象赋值给父类的引用

Tips:

一个引用能调用那些成员变量和函数，取决于引用的类型。
一个引用调用的是哪一个方法，取决于引用指向的对象。

如：

Student s = new Student();Person p = s;

s和p指向同一个对象。

p.addr和p.studing()是无法编译通过的。（Person类引用无法调用Student类的成员变量和函数）

但是p.introduce()调用的是子类的introduce()函数。（p指向了一个Student类对象）

2、向下转型：将父类的对象赋值给子类的引用

Tips:

一定要先向上转型再向下转型

如：

Student s1 = new Student();     Person p = s1;     //先向上转型Student s2 = (Student)p;     //再强制转型为子类（向下转型）

s1,s2,p指向同一个对象。

【022】面向对象应用

呃，有经验的不用看了

【023】抽象类和抽象函数

1、只有函数的定义，没有函数体的函数成为抽象函数

如：

abstract void func();

2、使用abstract定义的类是抽象类
Tips:

抽象类不能生成对象，但是其子类可以生成对象，override抽象父类中的抽象函数

一个类中包含抽象函数，则必须声明这个类为抽象函数

如果一个类中没有抽象函数，也可以声明为抽象类

抽象类也是有构造函数的（子类一定会调用父类的构造函数）

如：

abstract class Person{     abstract void eating();}class chinese extends Person{     void eating(){          //这个成员函数override了父类的抽象函数     }}chinese c1 = new chinese();     //这样是可以编译通过的

*抽象类专门作父类的[´・ω・`]

【024】为啥要用抽象类呢~

用一个例子来说明~

声明一个抽象类，包含一个抽象函数

abstract class Print{     void open(){          System.out.println("open the printer");     }          void close(){          System.out.println("close the printer");     }          abstract void printing();}

声明这个抽象类的子类1

class HPPrint extends Print{     void printing(){          System.out.println("使用HP打印机进行打印");     }}

声明这个抽象类的子类2

class CNPrint extends Print{     void printing(){          System.out.println("使用Canon打印机进行打印");     }}

测试用例

class test{     public static void main(String arg []){          Print p1 = new HPPrint();          p1.open();          p1.printing();          p1.close();                    Print p2 = new CNPrint();          p2.open();          p2.printing();          p2.close();     }}

结果如下

也就是说，在一定需要子类进行不同的函数操作时，抽象父类是很必要滴~~~

【025】包

（终于到了很特色的东西了[´・ω・`]

1、打包~这个不解释了- -命名空间的一个东东

Tips:

需要使用package 包名；

编译指令更换为javac -d 目录 x.java

一个类的全名是包名.类

test.java如下：

package com.android.google;class test{     public static void main(String arg []){          System.out.println("hello package");     }}

编译指令为：

javac -d . test.java

//要求在文件夹根目录（.）下生成一个文件夹（包）

这样的话就是在目录下生成了对应的class文件，而目录如下（和.有关系，一个点就多一个层级）

生成包后，执行注意类名已经变化，为包名.类名

java com.android.google.test

Tips:包名的命名规则

1、小写

2、一般情况下是域名倒过来写，如google.android.com---包名就是com.android.google

【026】包的访问权限

public     公共

private     私有

default     包级别

protected     受保护

权限都是和包有关系的

Tips:

public

• 能修饰类、成员变量和成员函数
• 当一个类是public权限，类名必须和文件名一样
• 可以从外部调用public权限的成员变量和函数

private

• 在普遍情况下不能修饰类，但是能修饰变量和函数
• 当一个类中的成员变量和函数为private权限时，只能本类中使用

default（默认权限）

• 能修饰类、成员变量和成员函数
• 只有在同一个包中才能调用的权限设置，不同包是不可以调用的

protected

• 和继承关系较大

*导入类机制

import 类名;

如：

在PB包的B类中想要使用PA里的A类，则有import PA.A;

如果是PA包里的所有类，则是import PA.*;

【027】继承和权限

protected权限

和default权限同级，但是protected只能修饰成员变量和成员函数

只有子类能访问父类的protect的跨包访问，但是不允许非子类的跨包访问

Tips:

如果子类和父类不在同一个包中，则子类无法访问父类的非public和非protected成员变量和成员函数

如：

Person.java

package com.kaigara;//Person类需为public，因为Student要在另外的包里调用public class Person{     //这两个变量需为public，因为Student要在另外的包里调用     public String name;     protected int age;          void eating(){          System.out.println("eating");     }     void sleeping(){          System.out.println("sleeping");     }}

Student.java

package cn.kaigara;import com.kaigara.Person;class Student extends Person{     void introduce(){          System.out.println("我的名字是"+name+" 我的年龄是"+age);     }}

test.java

package cn.kaigara;import com.kaigara.*;class test{     public static void main(String arg []){          Person p1 = new Person();          p1.name = "zhangsan";          p1.age = 11;     }}

结果如下，test类中无法访问Person类中protected int age

权限从大到小：

public | 公共使用 > protected | 父子类跨包使用 > default | 包内使用 > private | 类内使用

【028】异常

中断正常指令流的事件，也就是说程序在运行时出现的错误，而非编译的时候。

JDK提供的异常类（继承关系结构图）：

只能处理Exception，不能处理Error

• check exception     需要被处理（RuntimeException及子类）
• uncheck exception     不强制处理

如：

class checktest{     public static void main(String arg []){          System.out.println("1");          try{               int i = 1/0;//可能异常的代码放到try里，在异常代码后的代码不再进行               System.out.println("2");          }          catch(Exception e){               //不出异常时此代码块不会执行               e.printStackTrace();               System.out.println("2-catch");          }          finally{               //一定会被执行的代码块               System.out.println("finally");          }          System.out.println("3");     }}

*这几课涉及到java特色的一些知识点，理解之后还是比较容易的，但是明显比之前看的要慢咯~很多都是基础，先打好~