黑马程序员_面向对象（三）

mvplee

于 2013-05-24 23:18:35 发布

阅读量155

点赞数

分类专栏： JavaSE

本文链接：https://blog.csdn.net/mvplee/article/details/8972199

版权

JavaSE 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

android培训、java培训

对象的多态性：

abstract class Person{

private String name;

private int age;

Person(String name,int age){

this.setName(name);

this.setAge(age);

}

public void setName(String name){

this.name = name;

}

public void setAge(int age){

this.age = age;

}

public String getName(){

return this.name;

}

public int getAge(){

return this.age;

}

public void say(){

System.out.println(this.fun());

}

public abstract String fun();

}

class Student extends Person{

private float point;

public Student(String name,int age,float point){

super(name,age);

this.setPoint(point);

}

public void setPoint(float point){

this.point = point;

}

public float getPoint(){

return this.point;

}

public String fun(){

return "学生信息："+"\n姓名："+super.getName()+

"\t年龄："+super.getAge()+"\t成绩："+this.getPoint();

}

class Worker extends Person{

private float salary;

public Worker(String name,int age,float salary){

super(name,age);

this.setSalary(salary);

}

public void setSalary(float salary){

this.salary = salary;

}

public float getSalary(){

return this.salary;

}

public String fun(){

return "工人信息："+"\n姓名："+super.getName()+

"\t年龄："+super.getAge()+"\t工资："+this.getSalary();

}

public class JavaDemo97{

public static void main(String args[]){

Person stu = new Student("李岩",24,99.5f);

stu.say();

Person wkr = new Worker("李小岩",25,33333.33f);

wkr.say();

}

接口的使用：通过对象的多态性，有子类为接口对象实例化。

interface A{

public void fun();

}

class B implements A{

public void fun(){

System.out.println("BBBBBBBB");

}

public class JavaDemo98{

public static void main(String args[]){

A a = new B();

a.fun();

}

开发中优先使用接口，接口支持多继承。

interface USB{

public void start();

public void stop();

}

class PC{

public static void plugin(USB u){

u.start();

u.stop();

}

class MP3 implements USB{

public void start(){

System.out.println("MP3开始工作了！！！");

}

public void stop(){

System.out.println("MP3停止工作了！！！");

}

class UDisk implements USB{

public void start(){

System.out.println("UDisk开始工作了！！！");

}

public void stop(){

System.out.println("UDisk停止工作了！！！");

}

public class JavaDemo99{

public static void main(String args[]){

PC.plugin(new MP3());

PC.plugin(new UDisk());

}

接口中都是抽象方法，则子类必须覆写接口中的全部抽象方法，如果子类不希望全部覆写呢？适配器设计模式：接口》抽象类》子类

interface A{

public void fun1();

public void fun2();

public void fun3();

}

abstract class B implements A{

public void fun1(){}

public void fun2(){}

public void fun3(){}

}

class C extends B{//选择我想实现的方法，class C起到了适配器的作用

public void fun2(){

System.out.println("适配器操作模式！！！");

}

public class JavaDemo100{

public static void main(String args[]){

A a = new C();

a.fun2();

}

工厂设计模式：

interface USB{

public void start();

public void stop();

}

class MP3 implements USB{

public void start(){

System.out.println("MP3开始工作了！！！");

}

public void stop(){

System.out.println("MP3停止工作了！！！");

}

class UDisk implements USB{

public void start(){

System.out.println("UDisk开始工作了！！！");

}

public void stop(){

System.out.println("UDisk停止工作了！！！");

}

class Factory{

public static USB getUSBInstance(){

//return new MP3();

return new UDisk();

//main()是一个客户端，当需要修改时在工厂内部完成

}

public class JavaDemo101{

public static void main(String args[]){

USB u = Factory.getUSBInstance();

u.start();

u.stop();

}

抽象类和接口都可以实例化，通过对象的多态性。

所有的类都必须继承自Object类，Java中大部分的类都是继承关系。

Object：是最大的类，所有类的父类，一切对象都可向Object类转型。

toString()：在对象打印时默认调用，但默认情况下调用的是Object类中的toString()，如果一个类希望按照自己的方法打印对象，则可以覆写toString()。

//Object类是所有类的父类，如果一个类没有明确声明继承自哪个类

//则肯定会继承Object类

class Person //extends Object

{

public String toString(){

return "Object类中的toString()被覆写了！！！";

}

public class JavaDemo102{

public static void main(String args[]){

Person p = new Person();

// 默认情况下打印对象，实际上就相当于调用对象中的toString方法

//System.out.println(p.toString());

System.out.println(p);

}

案例：为Person类中添加name和age属性，打印对象时，自动打印姓名和年龄。

class Person{

private String name;

private int age;

Person(String name,int age){

this.setName(name);

this.setAge(age);

}

public void setName(String n){

this.name = n;

}

public void setAge(int a){

this.age = a;

}

public String getName(){

return this.name;

}

public int getAge(){

return this.age;

}

public String toString(){

return "姓名："+this.getName()+"\t 年龄："+this.getAge();

}

public class JavaDemo103{

public static void main(String args[]){

Person p = new Person("Rock",23);

System.out.println(p);//Person类覆写Object类中的toString方法

}

equals()：是一个对象比较的方法，在String类中调用的equals()肯定是已经被String类覆写的方法。根据自己的需要覆写equals()

class Person{

private String name;

private int age;

Person(){}

Person(String name,int age){

this.setName(name);

this.setAge(age);

}

public boolean equals(Object obj){

if (!(obj instanceof Person)){

//做一判断，防止类似于String类的匿名对象为obj初始化，确保obj为Person初始化

return false;

}

Person p2 = (Person)obj;

if (this==p2){

return true;//判断是否是同一引用

}

if (this.name.equals(p2.name)&&this.age==p2.age){

return true;

}else{

return false;

}

public void setName(String n){

this.name = n;

}

public void setAge(int a){

this.age = a;

}

public String getName(){

return this.name;

}

public int getAge(){

return this.age;

}

public String toString(){

return "姓名："+this.getName()+"\t 年龄："+this.getAge();

}

public class JavaDemo104{

public static void main(String args[]){

Person p1 = new Person("Rock",23);

Person p2 = new Person();

p1 = p2;

//Person p2 = new Person("Rock",23);

System.out.println(p1.equals(p2));

System.out.println(p1.equals("Rock"));

//字符串是匿名对象 String类和Person类没有关系

}

内部类：在一个类中定义一个类。格式：

class 外部类

{

class 内部类{}

}

class Outer{

private String info = "Rock Lee";

class Inner{//内部类

public void print(){

System.out.println("info = "+info);

}

public void fun(){

new Inner().print();

}

public class JavaDemo105{

public static void main(String args[])

{

Outer o = new Outer();

o.fun();

}

内部类可以节省代码，但是造成类的结构混乱。内部类本身也会产生*.class

案例：在类的外部直接去实例化内部类

class Outer{

private String info = "Rock Lee";

class Inner{//内部类

public void print(){

System.out.println("info = "+info);

}

public void fun(){

new Inner().print();

}

public class JavaDemo106{

public static void main(String args[])

{

Outer o = new Outer();

Outer.Inner in = o.new Inner();

in.print();

}

内部类可以在任何地方，如方法中：

class Outer{

private String info = "Rock Lee";

public void fun(final int len){//必须用final关键字，让内部类可以访问方法中的变量

class Inner{

public void print(){

System.out.println("len = "+len);

System.out.println("intfo = "+info);

}

new Inner().print();

}

public class JavaDemo107{

public static void main(String args[]){

new Outer().fun(10);

}

在方法中的内部类要访问方法中的变量，则变量必须加final，但是此final并不表示一个常量，只是一个标记，一定要加上的标记。

匿名内部类：这个内部类只是用一次，一次之后就不用了，匿名内部类是在抽象类和接口上发展而来的。

interface A{

public void funA();

}

class B implements A{

public void funA(){

System.out.println("Rock Lee");

}

class C{

public void funC(){

this.print(new B());

}

public void print(A a){

a.funA();

}

public class JavaDemo108{

public static void main(String args[]){

new C().funC();

}

interface A{

public void funA();

}

class C{

public void funC(){

this.print (new A()//匿名内部类

{

public void funA()

{

System.out.println("Rock Lee");

}

);

}

public void print(A a){

a.funA();

}

public class JavaDemo109{

public static void main(String args[]){

new C().funC();

}

包就是一个文件夹，包里面存放了大量的类，在使用类时必须有包。在同一文件夹下不能有重名的文件，多人开发中很难保重没有重名类，但可以见每个人开发的类放在不同的文件夹里。包定义格式：package 包名称；

package sky;

class JavaDemo110{

public static void main(String args[]){

System.out.println("Rock Lee");

}

定义包之后就相当于包与类同时使用，定义一个类时，格式：包名.类名称

定义的类如果要位外部访问，必须声明为public class

格式：包的定义：package 包名称；包的访问：import包名称

package demo1;

import demo2.*;//*表示所有类

public class JavaDemo111{

public static void main(String args[]){

new JavaDemo112().print();

}

package demo2;

public class JavaDemo112{

public void print(){

System.out.println("package demo ; JavaDemo112!!!!");

}

javac *.java：表示当前文件夹下的一切.java文件都进行编译

JDK提供了一个功能，可以根据定义的package自动生成class文件

格式：javac -d . JavaDemo113.java

-d：表示生成一个文件夹，文件夹的名称是package定义的

.：表示在当前文件夹下保存的文件

一个包可以有多个子包。

package sky.sky1.sky2;//用“.”定义子包

class JavaDemo113{

public static void main(String args[]){

System.out.println("Rock Lee");

}

public class含义：

1、类名称必须与文件夹名称一直

2、此类可以被外部的包所访问

在java中可以通过*进行集体导入，*是为了使用方便，程序会自动根据所需的类进行导入。

如果出现重名类的情况（在不同包中），则在使用重名类时要明确声明包的路径

import sky.*;

import text.*;

public class JavaDemo114{

public static void main(String args[]){

sky.JavaDemo115 j = new sky.JavaDemo115();

j.fun1();//类文件重名时，明确指出包路径

}

异常实际上是程序中错误导致中断了正常的指令流的一种事件，只要一出现异常程序就会中断。

public class JavaDemo116{

public static void main(String args[]){

System.out.println(1 / 0);

}

异常在Java中称为throwable：

Error表示错误：JVM出错，程序无法运行

Exception表示异常：表示程序运行时出现的错误，可以由人为处理。

public class JavaDemo117{

public static void main(String args[]){

System.out.println("--------------异常发生之前---------------");

System.out.println(1 / 0);

System.out.println("--------------异常发生之后---------------");

}

使用try...catch...表示程序出错之后可以向后继续运行。

public class JavaDemo118{

public static void main(String args[]){

System.out.println("--------------异常发生之前---------------");

try{

System.out.println(1 / 0);//可能出现异常的语句

System.out.println("********");

//一但出现了错误就不在执行try中的语句直接跳到catch语句

}

catch (ArithmeticException ae){//出现的异常跟上ae对象

//如果try中没有出现异常则不会执行catch中的语句

System.out.println("发生了异常:");

System.out.println(ae);

}

System.out.println("--------------异常发生之后---------------");

}

特性：异常发生之后，发生异常代码之后的程序将不再被执行，当try中出现异常的时候才会执行catch中的代码，如果没有异常，则不会执行。

一个try语句后可以加入多个catch语句

public class JavaDemo119{

public static void main(String args[]){

System.out.println("--------------异常发生之前---------------");

try{//跑出的是一个异常类的实例化对象，这个对象去和catch中的参数进行匹配

System.out.println("第一个参数："+args[0]);

System.out.println(1 / 0);

System.out.println("********");

}

catch (ArithmeticException ae){

System.out.println("发生了异常:");

System.out.println(ae);

}

catch(ArrayIndexOutOfBoundsException abe){

System.out.println("发生了异常：");

System.out.println(abe);

}

System.out.println("--------------异常发生之后---------------");

}

如果一个程序中有多个异常？try抛出的是一个异常对象，而所有的异常类都是Exception的子类，可以简单的用Exception接受。

public class JavaDemo120{

public static void main(String args[]){

System.out.println("--------------异常发生之前---------------");

try{//跑出的是一个异常类的实例化对象，这个对象去和catch中的参数进行匹配

System.out.println("第一个参数："+args[0]);

System.out.println(1 / 0);

System.out.println("********");

}

catch(Exception e){

System.out.println("程序出错了：");

System.out.println(e);

}

System.out.println("--------------异常发生之后---------------");

}

try...catch....注意：try后可以跟多个catch，但catch中顺序和ACL一样，严格的放在前面，宽松的放在后面

public class JavaDemo121{

public static void main(String args[]){

System.out.println("--------------异常发生之前---------------");

try{//跑出的是一个异常类的实例化对象，这个对象去和catch中的参数进行匹配

System.out.println("第一个参数："+args[0]);

System.out.println(1 / 0);

System.out.println("********");

}

catch (ArithmeticException ae){//细致的条件方法在前面，像ACL

System.out.println("发生了异常:");

System.out.println(ae);

}

catch(ArrayIndexOutOfBoundsException abe){

System.out.println("发生了异常：");

System.out.println(abe);

}

catch(Exception e){

//宽泛的条件方法在后面，如果细致的条件方法款放的条件后，将不会被执行

System.out.println("程序出错了：");

System.out.println(e);

}

System.out.println("--------------异常发生之后---------------");

}

finally：表示一个异常的统一出口，不管程序是否出现了异常，都必须执行finally代码。

public class JavaDemo122{

public static void main(String args[]){

System.out.println("--------------异常发生之前---------------");

try{

System.out.println("第一个参数："+args[0]);

System.out.println(1 / 0);

}

catch (Exception e){

System.out.println("发生了异常:");

System.out.println(e);

}

finally{//一般用于释放资源的链接

System.out.println("无论是否发生异常都要执行finall内的语句！！！");

}

System.out.println("--------------异常发生之后---------------");

}

throws用在方法的声明出，表示此方法内部不处理异常，而是交给调用此方法处进行处理。

class Maths{

public int div(int i ,int j ) throws Exception{

//表示不处理异常，让客户端处理异常，谁调用我，谁处理我

return i / j ;

}

public class JavaDemo123{

public static void main(String args[]){

try{

System.out.println(new Maths().div(10,0));

}

catch (Exception e ){

System.out.println(e);

}

如果在main方法处编写了throws语句，则表示此异常交给JVM去处理，默认情况下，所有异常就是通过JVM处理的。

class Maths{

public int div(int i ,int j ) throws Exception{

return i / j ;

}

public class JavaDemo124{

public static void main(String args[]) throws Exception{//把错误抛个JVM处理

System.out.println(new Maths().div(10,0));

}

异常抛出：不是出错产生的，而是人为抛出。

public class JavaDemo125{

public static void main(String args[]) {

try{//本身抛出的就是一个异常类的对象

throw new Exception("自己跑出一个异常！！！");

}

catch (Exception e){

System.out.println(e);

}

一般throw语句和if语句连用

class Maths{

public int div(int i ,int j ) throws Exception{

if (j == 0){

throw new Exception ("除数不能为零！！！");

}

return i / j ;

}

public class JavaDemo126{

public static void main(String args[]){

try{

System.out.println(new Maths().div(10,0));

}

catch (Exception e ){

System.out.println(e);

}

包的访问权限：

public:最大的，公共方法问的

private:最小的，只能在本类中访问

defaut:默认的，只能在本包中访问

protected:本包，以及不同包的子类中可以访问

Java中的命名规则：

类：每个单词的首字母大写

方法：第一个单词首字母小写，之后每个单词的首字母大写

属性：第一个单词首字母小写，之后每个单词的首字母大写

常量：所有单词字母大写

包：所有单词小写没有包的类是不存在的。

mvplee

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员_面向对象（三）

android培训、java培训对象的多态性：abstract class Person{ private String name; private int age; Person(String name,int age){ this.setName(name);
复制链接

扫一扫

专栏目录