3_java面向对象

1、3 JAVA面向对象,面向对象的基本概念 Java中的类和对象 定义、访问、引用、初始化 类的封装、方法重载、构造函数，this Java对象的存储结构与管理 变量的存储、参数传递、垃圾回收、数组 Java面向对象的各种机制 静态变量与静态方法、内部类 类的继承、方法的重写与重载、superObject类、上朔、多态、抽象类与抽象方法、接口与多重继承、匿名内部类、程序包、访问控制 异常处理,3.1 理解面向对象的概念,面向过程 在一个结构体中定义窗口的大小，位置，颜色，背景等属性，对窗口操作的函数与窗口本身的定义没有任何关系，如HideWindow，MoveWindow，MinimizeWin

2、dow，这些函数都需要接受一个代表要被操作的窗口参数 ，是一种谓语与宾语的关系 。 面向对象 定义窗口时，除了要指定在面向过程中规定的那些属性，如大小，位置，颜色，背景等外，还要指定该窗口可能具有的动作 ，如隐藏，移动，最小化等。这些函数被调用时，都是以某个窗口要隐藏，某个窗口要移动的语法格式来使用的 ，这是一种主语与谓语的关系。,3.1.1 面向对象的内涵,面向对象(Object Oriented)，是一种现代的软件开发方法学，它涵盖了软件开发的整个过程，主要包括：面向对象的分析(OOA)、面向对象的设计(OOD)、面向对象的程序设计(OOP),3.1.2 类、对象、实例,类(class)用

3、来表示客观世界中的一种事物或者一个概念，如：人、汽车、房屋 对象(object)，原意是物体，用于表示客观世界中的一个具体事物，如：一个人，一辆汽车、一间房屋 2个特征：属性（Property）和行为（Behavior） 某类(class)的一个对象(object)称为该类的一个实例(instance),3.1.3 面向对象的基本特征,1.封装：将数据成员（Data Member）和属于此数据的操作方法（Operating Method），放在同一个实体（Entity）或对象中。 2.继承：父类定义（Define）一些通用的属性与行为，其孩子继续使用。 3.多态：在同一个类中可有许多同名的方法

4、，但其参数数量与数据类型不同，而且操作过程与返回值也可能会不同。,3.1.4 面向对象的程序设计,所有东西都是对象 程序是一大堆对象的组合；通过消息传递，各对象知道自己要做什么 每个对象都有自己的存储空间，可以容纳其它对象 每个对象都有一种类型 同一类的所有对象都能接收相同消息,面向对象程序设计: 程序=对象+消息,3.2.1 类的定义,定义类的语法 类的数据 类的方法,定义类的语法,最简单的类class SimpleClass 使用class关键字来定义类，语法：class 类名/类的数据和方法 , 类的数据,可以在类中定义属于类的数据，类的数据通常表示类的实例的

5、某些属性(attribute)class Humanchar sex;int age; 类中的数据通常称为“域”(field), 类的数据,类的数据不仅可以使用基础类型，而且可以包含引用类型的数据：class Humanchar sex;int age;String name;, 类的方法,类的方法表示可以对类进行的一种操作，方法的功能类似于传统程序设计语言中的函数 以下是一个简单的方法定义：void getMoney (int money)if(0 = money)System.out.println (“No money!”);elseSystem.out.pr

6、intln (“I got money!”);, 类的方法,方法声明的分析： void getMoney (int money),返回值类型,方法名称,参数列表, 方法的返回值,方法返回值： 一个方法可以返回一个值来表示方法执行的结果，这个结果可以是任意类型的数据 一个方法只能有一个返回值，不能返回一个以上的值 通常一个方法(构造方法除外)必须有一个返回值类型，如果确认方法不会返回任何值，则必须将返回值类型声明为void, 方法的参数,方法的参数： 方法可以接收参数作为输入 方法可以由任意多个参数 方法不需要任何参数时，可以将参数列表保留为空,3.2.

7、1.9 使用return,方法可以使用return来返回值，使用方法：return 100; 方法内用return返回的值的类型，需要同方法返回值类型兼容 使用return可以立即结束方法的执行并返回调用点 如果方法返回值声明为void，可以使用不带值的return语句结束方法执行：return；,0 使用return,如果方法需要返回值，则方法的每一条执行路径都必须要使用return返回一个值。如果有一个或一个以上分支没有返回值，方法的定义无法通过编译 在方法的任何分支上，return语句后都不能有其他的语句。如果有则方法的定义无法通过编译,class Human int ag

8、e; char sex; int money; void printAge() System.out.println(My age is + age); void isManOrWoman() if (sex = M | sex = m) System.out.println(I am a man); else if (sex = F | sex = f) System.out.println(I am a woman); else System.out.println(I am sorry ); int getMoney() return money; void addMoney(int m

9、) money += m; System.out.println(I got $ + money); ,3.2.2 对象与对象的引用,一个对象是一个类的实例(instance)，对象与类的关系类似于一个具体的人同人这个概念之间的关系 对象的引用类似于C语言中的指针，它是在程序中代表对象的一个名字, 对象与对象的引用,定义引用的方法如下：ClassTypeName referenceName;例如：Human aMan; 定义引用时并没有创建对象，应该使用new关键字创建对象：aMan = new Human();, 对象与对象的引用,可以将定义引用和创建对象两个步骤

10、同时进行：Human aMan = new Human(); 可以使用null来给对象赋值，给一个对象赋值为null代表这个变量不指向任何对象，null可以赋值给任何类型的对象引用,3.2.3 访问对象的成员,在程序中，通过引用来操控对象；对于我们，对象是不可见的，引用是可见的 对成员的访问需要通过对象(的引用)： Human human = new Human(); human.sex = M; human.age = 24; human.printAge();, 访问对象的成员,成员变量属于某个具体对象，不同的对象拥有不同的成员变量 Human man1 = new Huma

11、n(); Human man2 = new Human(); man1.sex = M;man1.age = 24; man2.sex = F;man2.age = 34; man1.printAge(); man2.printAge(); man1.isManOrWoman(); man2.isManOrWoman();, 访问对象的成员,在类的成员方法中可以直接访问成员变量或者其他的成员方法，成员方法直接访问的是当前对象的成员变量 class Human int age; void printAge() System.out.println(My age is + age);

12、 , 访问对象的成员,注意：如果一个对象未被初始化，就不能通过它来访问类中的成员，否则编译时会出现错误Human man;System.out.println(man.age); /Compile Error 注意：如果一个对象为null，则不能通过它来访问对象的成员，否则在运行时产生异常 Human man = null;System.out.println (man.age); /NullPointerException,3.2.4 成员变量的初始化,变量的类型 实例变量：在类中声明，在整个类中有效 局部变量：又称为临时变量，在方法中声明， 仅在该方法中有效 局部变量(临时变

13、量)在使用之前必须被初始化，否则会出现编译错误！,成员变量的显式初始化,可以在类的实例变量声明同时进行实例变量的初始化，例如： class Humanint age = 5;char sex = M;, 成员变量的缺省初始化,在创建类的对象时，类中的每个实例变量，如果没有被显式的初始化，系统就会给这个实例变量指定一个缺省的初始值 各种类型的变量缺省的初始值 整数类型：0 浮点类型：0.0 字符类型(char)：u0000 逻辑类型(boolean)：false 对象的引用：null,class Human int age; public int getAge() r

14、eturn age; public class Test public static void main(String args) Human h1=new Human(); h1.age=10; h1.age=-12; System.out.println(h1.getAge(); ,3.2.5 类的封装,隐藏类的实现细节 通过事先制定好的方法访问数据，限制不合理操作 便于修改，增强代码的可维护性 可进行数据检查, 类的封装,Human h1=new Human(); h1.age=-12; private与public控制访问权限 通过将类的实例变量声明为私有的（privat

15、e），再提供一个或多个公有（public）方法实现对该实例变量的访问或修改，这种方式称为封装, 类的封装,class Human private int age; public void setAge(int i) if(i130) return; age=i; public int getAge() return age; ,class Human double salary; void setSalary(double a) salary=a; void setSalary(double a,double b) salary=a+b; void setSalary(doubl

16、e a,int b) salary=a+b; ,3.2.6 方法的重载 (overload),同一个类中允许多个方法拥有同样的名字，这种情况叫做方法的重载(overload) 在进行方法调用时，将通过传递给方法的参数，由编译器来决定最终调用方法的哪一个实现, 方法的重载 (overload),重载的多个方法必须要有不同的参数表，只能通过参数表分辨，不能通过返回值 / wrong way of overload int max(int a, int b) long max(int a, int b) , 方法的重载 (overload),选择被执行方法的原则最相近原则

17、： 通过参数的个数，必须与提供的参数相同 通过参数的类型，必须与提供的参数兼容 在有多个重载版本与提供的参数兼容时： 选择与提供的参数完全相同的 选择需要隐式转型的参数个数最少的 选择对需要转型的参数类型改变最小的,练习,编写一个类，用于计算整数的和。该类中有三个重载的方法count，分别计算2个、3个和4个整数的和。调用某个count方法计算348和578的和，并将结果显示出来。,class Human Human() System.out.println(“A Human has been created”); public static void main(String args) Hu

18、man h1=new Human(); ,3.2.7 构造方法,构造方法在创建对象时被自动调用 构造方法的功能通常是进行对象的初始化工作，在构造方法执行之后才完成对象的创建 一个类一定有至少一个构造方法，如果程序没有明确定义一个构造方法，编译器会自动生成一个缺省的的构造方法, 构造方法的语法,无参的构造方法 class Human . Human() age = 0; sex = M; System.out.println(A human has benn created.) , 构造方法的语法,带有参数的构造方法 class Human . Human(int a

19、, char s) age = a; sex = s; System.out.println(A human has been created.) , 构造方法的语法,构造方法的名字同类名完全一致 构造方法没有返回值字段！ 构造方法一般都是public的,因为它们在产生对象时会被系统自动调用 构造方法也可以重载, 构造方法的重载,class Human Human() ; Human(int a) ; Human(char s) ; Human(char s, int a) ; Human(int a, char s) age = a; sex = s; Syste

20、m.out.println(A human has created.) , 构造方法创建对象,如果类声明了带参数的构造方法，则需要在创建类时传递所需的参数：class Apple Apple() class Orange Orange(int o) Apple apple = new Apple(); / OK! Orange orange = new Orange(4); / OK! / Orange orange = new Orange(); ERROR!,初始化块,在一个构建器中设定一个值 在声明中分配一个值 所有的数据字段，按其声明的顺序初始化 按其在类声明中的顺序，执

21、行所有初始化块 如果在这个构建器中调用另外一个构建器，就会先执行调用那个 执行构建器的主体,class Tag Tag(int marker) System.out.println(Tag( + marker + ); class Card Tag t1 = new Tag(1); / Before constructor Card() / Indicate were in the constructor: System.out.println(Card(); t3 = new Tag(33); / Reinitialize t3 Tag t2 = new Tag(2); / After co

22、nstructor void f() System.out.println(f(); Tag t3 = new Tag(3); / At end public class OrderOfInitialization public static void main(String args) Card t = new Card(); t.f(); / Shows that construction is done , this关键字,“this”关键字的两个作用： 在类的定义中，this代表当前正在处理的对象: class MyDate int year, month, day; v

23、oid setDate(int year, month, day) this.year = year; this.month = month; this.day = day; ,public class TryThis int value = 10; /成员变量 public void showValue() int value = 20; /临时变量 System.out.println(value = +value); System.out.println(this.value = +this.value); public static void main(String args) Try

24、This t = new TryThis(); t.showValue(); ,就是指向对象的本身 例， public class Leaf int i = 0; Leaf increment () i+; return this; void print () System.out.println(“i = ”+i ); public static void main(String args) Leaf x = new Leaf(); x.increment().increment().increment().print(); , this关键字,构造方法互相调用时，方法名称应该

25、使用this来替代 class Human String name; int age; public Human(String name) =name; public Human(String name,int age) this(name); this.age=age; ,Public class Flower int petalCount = 0; String s = new String(“null”); Flower(int petals) petalCount = petals; System.out.println(“Constructor, petalCoun

26、t=”+petalCount); Flower(String ss) System.out.println(“Constructor, s=”+ss); s = ss; ,Flower(String s, int petals) this(petals); /! This(s); / Cant call two! this.s = s; /another use of “this” System.out.println(“String ,3.2.8 Java的存储结构,Java虚拟机对存储器的划分 基本类型的储存 引用与对象在内存中的储存 变量在内存中的示意, Java虚拟机对存

27、储器的划分,寄存器(register)：CPU内部的存储器，数量很少但速度极快。 寄存器的使用由编译程序控制，不受编程者控制。, Java虚拟机对存储器的划分,栈(stack)：栈中的变量有着确定的大小和生存周期， Java中基本类型变量和对象引用所需的内存都在栈中分配 堆(heap)：堆中变量的大小和生存周期都是不确定的，在使用new创建新对象时，创建的对象所需的内存将在堆中分配, Java虚拟机对存储器的划分,静态存储区：Java中一切静态的(static)变量都在静态存储区中进行分配 常量存储区：Java中一切常量(final)都在常量存储区中进行分配,3.2

28、.8.4 基本类型的储存,方法中声明的基本类型变量被储存在栈(Stack)中，储存空间在方法被调用时进行分配，在方法返回时分配的空间被释放 类中的静态成员变量被储存在静态存储区中，存储空间在类被装入虚拟机时分配 作为类中普通变量的基本类型将在类创建时分配在对象所占的内存中，这些内存在堆(Heap)中分配, 对象的引用在内存中的储存,对象的引用是一个单独的变量 为引用分配内存的原则同基本类型的分配原则是一样的, 对象在内存中的储存,对象所需的内存在堆中分配，在创建对象时JVM为对象分配所需的内存，这些内存将一直被占用着，直到垃圾回收器将其回收 对象占据的内存中可能包括

29、对其他对象的引用, 变量在内存中的示意图,int i = 8; char c = a; double d = 10.0; int j = i; String s = “Hello”; Human man1 =new Human();Human man2 = man1;,s,man1,man2, 变量在内存中的示意图,class Wheel int r = 5;class Bike Wheel fornt = new Wheel(); Wheel back = new Wheel();Bike b1 = new Bike();,b1,5,5,back,3.2.9 方法

30、参数的传递,Java语言中方法的参数传递采用值传递(pass by value)规则 在方法中对参数进行的一切修改都不会影响方法外的变量, 方法参数的传递,void change1(int i)i = 100;System.out.println(“i in change is:” + i); /打印出? int i = 10; System.out.println(“i before change is:” + i); /打印出? change1(i); System.out.println(“i after change is:” + i); /打印出?, 方法

31、参数的传递,i,i,i=10,i=10,i=100, 方法参数的传递,注意：方法中改变引用变量指向的对象不会影响方法外的引用变量；方法中改变引用变量指向对象的值会对方法外的该对象产生影响, 方法参数的传递,void change2(Human h) = “Bob”;System.out.println(“Human in change:”+); Human m = new Human(); = “Bill”; System.out.println(“Human before change:”+); change2(m

32、); System.out.println(“Human after change:”+);, 方法参数的传递,m,h,Bill,Bob, 方法参数的传递,void change3(Human h)h = new Human(); = “Bob”;System.out.println(“Human in change:”+); Human m = new Human(); = “Bill”; System.out.println(“Human before change:”+); change3(m);

33、System.out.println(“Human after change:”+);,方法参数的传递,m,Bill,h,Bob,3.2.10 垃圾回收机制,在Java语言中对象所占据的内存在创建对象时分配 Java中不需要自己释放对象占据的内存，JVM会自动利用垃圾回收机制回收不再使用的对象占据的内存 当一个对象不能被程序再次访问时它就成为垃圾，垃圾回收机制就可能将其回收，并释放它所占据的内存, 什么样的对象是垃圾,不再被任何引用指向的对象将成为垃圾，请考虑下面一段程序：Human h1 = new Human();Human h2 = new Hu

34、man();h2 = h1;/此时h2原来指向的对象成为垃圾, 什么样的对象是垃圾,几个对象相互引用，但只这几个对象都不能从其他的引用访问到，例如：class RubbishRubbish r;Rubbish r1 = new Rubbish(), r2 = new Rubbish();r1.r = r2; r2.r = r1;r1 = r2 = null;/此时r1和r2都成为垃圾,r1,r,r2,r,垃圾回收机制的工作原理,通常JVM采用mark-sweep-compress方法工作 从一个根对象出发搜索所有由根对象开始能够访问到的对象，在能够搜索到的对象上

35、做一个标记(mark) 在内存不足时，将所有未做标记的对象释放，回收它们的内存(sweep) 移动将保留下来的对象所占用的内存，使占用的内存相连(compress), 垃圾回收机制的特点,垃圾回收时系统自动进行的，通常不需要程序员干预 垃圾回收可能在任何时间进行，进行垃圾回收的时机由JVM决定，程序员不能加以干涉 不同版本的JVM有着不同的垃圾回收方式，不能对垃圾回收方式加以任何假定, finalize方法,每个类中都有一个finalize方法，它将在JVM进行垃圾回收之前被调用 protected void finalize() 虽然可以直接由程序调用fina

36、lize方法，但是通常不要这样做 JVM调用finalize方法的时机是不确定的, System.gc的作用,垃圾回收机制执行的偶然性有时会给程序带来麻烦 System.gc()方法可以强制启动垃圾回收器,及时进行垃圾清理,3.2.11 数组,数组初步知识 数组的声明 数组的创建 数组的初始化 多维数组 数组定义与创建举例,数组初步知识,访问数组的语法使用 数组即可以容纳基本类型也可以容纳引用类型 Java中的数组是对象，数组类型属于引用类型 容纳不同类型成员的数组也属于不同的类型 Java数组类的成员变量length Java中的数组使用固定的基数0,3.2.

37、11.2 数组的声明,Java中声明数组有两种写法：char s;Human h;char s;Human h; 数组的声明只是声明了对象的引用，在使用之前需要创建数组对象, 数组的创建,使用关键字new创建数组对象，在创建对象时需要指明数组的大小，例如：char s = new char16;Human h;h = new Human32; 数组的下标范围是0size-1,比如h的下标范围是031, 数组,栈内存,堆内存,x=null;,int x=new int100, 数组的初始化,数组的显式初始化：数组可以在定义的同时被初始化为指定值，显

38、示初始化的语法如下：char s = a, b, c, d;Point p = new Point(0, 0), new Point(-50, 0), new Point(50, 0) ;初始化时不必指出数组的大小，数组的大小将根据所给对象的数量决定。, 数组的初始化,数组的自动初始化：如果数组在创建之后不进行显式初始化，则数组中的每个成员都会被初始化为0值。 各种类型的0值：整数类型：0浮点类型：0.0字符类型：u0000逻辑类型：false引用类型：null,多维数组,Java中没有真正意义上的多维数组，而是通过数组的数组来实现的 多维数组的声明方式如下，以

39、二维为例：int a; 多维数组可以用以下方式进行创建：int a = new int108;, 多维数组,多维数组可以看作容纳数组对象的数组 int xx; xx=new int xx3; int xx0, int xx1, int xx2, 多维数组,多维数组不一定是矩阵形式 xx0=new int3; xx1=new int2; xx2=new int1;,xx11,xx00,xx01,xx02,xx10,xx20,xx11,0 数组定义与创建举例,正确的数组定义与创建：int a = new int8; a0 = new int3;a4

40、= new int5;int a = new int64;,错误的数组定义与创建：int a = new int;int b = new int4;int3 c = new int3;int d = new int1, 2, 3;int e = new int31, 2, 3;int f = 1, 2, 3,4, 5,6,3.2.12 静态变量与静态方法,在声明类的变量或方法时使用static关键字可以将变量和方法声明为类的静态变量或静态方法 类中的静态变量属于类本身，所有这个类的对象共享同样的静态变量 静态变量和方法通常用于表示类自身的某些特性或操作,静态变量与静态方法,cl

41、ass Human int age;boolean sex;String name;static long population;/静态变量static void printPopulation()/静态方法 ,访问类的静态成员,对于类中的静态变量和静态方法，即可通过引用访问也可以通过类名本身访问Human man = new Human();man.population = 100;System.out.println(Human.population); /100 注意：不论通过引用还是通过类名来访问，访问到的静态变量都是同一个(利用这个特性,有特殊用途),class A

42、private static int count=0; public A() count=count+1; 练习：创建多个A类的实例，输出A.count的值, 访问类的静态成员,不能在类的静态方法中直接访问类中的变量或方法，除非被访问的成员也是静态的class Humanstatic long population;int age;String name;static void print() System.out.println(population); System.out.println(age);/错误，不能访问, 理解main方法的语法,public

43、static void main(String args),public class TestMain public static void main(String args) for(int i=0;iargs.length;i+) System.out.println(argsi); ,3.2.13 内部类,内部类(Inner Class)是定义在其他类中或方法中的类，包含内部类的类通常称作Enclosing Class 内部类的功能通常与包含它的类的功能有紧密的关联 内部类的存取控制方式与同他在同一位置上的成员是相同的, 内部类,Java语言的内部类有以下几种类型： 静态

44、内部类(Static inner class) 成员内部类(Member inner class) 本地内部类(Local inner class) 匿名内部类(Anonymous inner class), 静态内部类,定义静态内部类的方法类似于声明类的一个静态成员：public class Enclosingprivate static int staticMember = 0; public static class StaticInnerpublic void innerMethod() System.out.println(staticMember);, 静态内部类,声明静态内部类的引用：Enclosing.StaticInner