面向对象设计

面向对象设计（要素：封装，继承，多态）

类：

属性，方法（java使用类的属性和方法必须创建类的对象，然后通过对象来引用类成员变量和方法）

对象：

具有属性和动作的实体。

 

类对象的创建，使用，清除：

类对象的创建 类名+对象名字

使用new，为声明对象分配内存

系统默认：objCircle =new Circle();

创建：Circle obCircle=new Circle();

 

对象的使用：

通过对象和“.”运算符来引用对象中的成员变量和方法

对象的清除（垃圾回收抛异常）

垃圾回收集（自动处理内存重新分配问题）

对象清除的相关方法两个：finalize()和gc();

1.finalize()方法是object类的一个方法，在对象被当成垃圾从内存释放前调用，而不是变成垃圾后调用。并不是一产生垃圾就会被唤起，甚至可能程序结束都没有启动机会。这是一个很不可靠的机制。

2.java提供System.gc()方法，使用这个方法强制启动垃圾回收器来回收垃圾。

try{

 

 }catch(OutOfMemoryErrore){

 System.out.println("内存溢出！");

         System.gc();

 }

包：

组织类（类组织成单元）

减少命名冲突

控制包中类，接口成员变量和方法的可见性（除private外，类中成员变量和方法可以被同一包中其它类和方法访问）

Public任何地方都可访问

Protected同一包可访问，其他包访问时只能被子类继承，然后访问

Private只能当前类中访问

继承

类 extend 父类

父类中private类方法不能被子类继承

Class Father{

Int a;

Private int c;  //子类不能引用

}

Class Childern extend Father{
a=2;   //不用再定义，直接引用

}

覆盖  （参数不同，子类中找不到，就会再父类中找。Java中采用单继承，避免父类中方 法或变量名相同造成混乱）

子类中方法名，返回类型及参数个数都相同

成员变量变量名相同

1.成员变量和局部变量

成员变量：

（实例成员变量和类成员变量）

成员变量前加static，就是静态成员变量，或者类成员变量。

成员变量的隐藏：

当局部变量和成员变量名字相同时，成员变量被隐藏

Int a=2;

Void Test(){
int a=3;

Int b=a;

Int c=this.a;

System.out.println(b);  //b=3  a为局部变量

System.out.println(c);  //c=2   这里a为成员变量

}

2.成员方法

（1）方法命名：

小写字母开始，从第二个单词开始，首字母大写

（2）方法重载

（一个类中可以有多个方法具有相同名字，但方法参数不同：方法类型，数量）

（3）方法返回值

使用return来返回一个值，任何声明的void方法都不返回任何值

3.构造方法（特殊的成员方法）（类中可以有多个，也可以没有）

必须与类名相同，没有返回类型，void关键字也不能有。如果没有显示定义类的构造方法，系统会默认提供一个（不含任何参数）。如果自己定义了，系统不在提供。

eg:            //下面两个构造方法，一个带参数，一个不带

Public class Test{

int a,b;

Test(){

a=12;

}

Test(int d,int c){

a=d;

b=c;

}

}

 

4.多态：

当类从父类派生出来时可能需要修改父类中某个实现方法

多态

package com.test.mxdx;

 

public class DT {

 

 

public static void main(String[] args) {

// TODO Auto-generated method stub

Rabbit rt=new Rabbit();

Elephant el=new Elephant();

rt.move();

el.move();

System.out.println("ww");

}

 

}

 

class Animal{

void move(){

System.out.println("11");

}

}

class Elephantextends Animal{

void move(){

System.out.println("22");

}

}

class Rabbitextends Animal{

void move(){

System.out.println("33");

}

}

5.参数传递：

Class Test{

Void method(int m.int n){
int sum;

sum=n+m;

}

Public static voi main(String[] args ){

Int m=10,n=10;

Test t=new Test();

t.method(m,n);  //m,n的值已经传递到method方法中

}

}

6.抽象类

1.抽象类定义

抽象类不能创建对象，只能由其它派生的子类创建。

抽象类专门作为其他类的父类来使用。

具体定义：在程序开发过程中，很多时候需要构造一系列的类及其继承关系，这时候，通常会将一些类层次中共有的特性抽取出来，创建包含这些共有特性的抽象类，并有抽象类派生出更加具体，有更多实现的子类或后代类，形成一个完整的类的层次体系。

abstract class 类名称{

类体

}

Eg: abstract public class Admin{}或者public abstract class Admin{}

2.抽象方法定义

Eg: abstract public class Admin(){}或者public abstract class Admin(){}

3.抽象类实例

abstract class Admin{

 String name;

Abstract run();  //不提供具体方法

}

Class dog extends Admin{

Void run(){
System.out.println(“这里具体方法”);

}

}

7.接口

实现多重继承

（接口中所有方法都是抽象的方法，变量都是static常量）

定义：

interface 接口名{

接口中类和方法

}

接口中，方法都是抽象方法，所有变量都是static类型的常量

Intrface Myii{

static final int a=12;

int b=23;        //虽然没有static和final关键字，但编译时编译器会默认加上

astract void aa();

aoid bb();       //虽然没有astract，但也是抽象方法

}

接口的使用

一个类通过使用关键字implement声明自己使用一个或多个接口

多个接口：class ClassName implement Interface1,Interface2

接口的类必须实现接口中的所有方法。方法名，返回至类型，参数个数及类型都有相同

比如：dao.impl包中DAOImpl接口实现类中，一旦继承接口，都会创建里面的方法

接口默认都是public，所以接口中方法必须加public

接口在返回类型不是void，类中实现该接口方法是，方法体至少要有一个return语句。如果是void，方法体中除了大括号外，没有任何语句.

加public，可以被任何类使用，不加（友好接口），只可以可以被同一个包中类使用

接口的继承

一个接口继承另一个接口，该类继承此接口，必须实现所有接口中的方法。

8.内部类

匿名类（anonymous class）

 

静态类（static class）

static 关键字定义

内部创建静态类：A a=new A();

外部创建静态类(在ClassName类外部创建)：ClassName.A a=new ClassName();

成员类（member class）

局部类（local class）

9.类的关键字

this

对象自身的引用，即类本身

class ThisTest{

Int a;

void set(int a){     //局部变量和成员变量同名

this.a=a;     //this关键字引用成员变量

}

}

static修饰符

静态变量也称类变量

类成员变量分为：类变量和实例变量

实例变量属于类的对象（分配不同内存空间）

类变量属于类（所有类对象共享同一个内存空间）

 

final修饰符

最终变量，即常量，不允许修改，要有初始值

最终类，不允许作为父类被继承

最终方法，继承包含最终方法的类的子类不能覆盖最终方法（子类不能对父类中最终方法修改）

Fianl int a=12;

super关键字

指明是对父类的引用

父类中方法或变量因和子类同名被覆盖被隐藏，不能被子类继承时，要使用父类的成员变量和方法，用super

Class Facther{

int a;

void get(){

 

}

}

Class Childern extends Facther{

int a;

void get(){

 

}

void method(){

 

super.a=10;    //通过super为父类中变量a赋值

a=20; //子类a赋值

super.get();   /通过super调用父类中的方法

get();

}