类和对象

3/1/2017来源:Android开发人气:848

类和对象

一、 定义

对象:具有一组属性和方法的实体。万事万物皆对象。

类:具有相同属性和方法的对象的集合。抽象的概念。

关系:类是对象的抽象,对象是类的具体存在。

二、 类

1. 定义类

访问修饰符   class   类名{

//定义属性

//定义方法

}

 

public  class  Student{

String name;

int age;

public  void  study(){

}

public  void  eat(String food){

}

}

2. 创建对象

语法:类名  对象名  =  new  类名();

示例:Student  stu  =  new  Student();

通过对象名+.的方式可以调用类的成员(属性、方法)。

stu.name = “zhangsan”;   

stu.study();

3. java中的数据类型

u 基本数据类型(值类型)

1) 整型:byte、short、int、long

2) 浮点型:float、double

3) 字符型:char

4) 布尔型:boolean

u 引用数据类型:

1) String

2) 数组

3) 类

三、 方法

1. 定义方法

语法:访问修饰符   返回值类型   方法名称(数据类型  参数名,  数据类型  参数名){

          //方法体

}

注意:

u 如果方法没有任何返回值,那么返回值类型写void。

u 如果方法有返回值,那么应该使用return关键字将结果值返回。

u 方法的参数列表可以为空。

u 定义方法时,参数列表中的参数为形参(形式参数)。

u 方法体中不能再定义其他方法。

2. 方法的调用

语法:通过对象名.方法名进行方法的调用。

注意:

u 方法如果有参数,那么必须传递参数(参数的类型、个数)。

u 参数如果为值类型,方法调用前后,实参的值不变;参数如果为引用类型,方法调用前后,实参的值要改变。

u 如果方法定义时,没有返回值,那么不能定义变量接受方法的返回值。

u 如果方法定义时,有返回值,那么可以定义变量接收返回值;也可以不定义变量接受。

u 同一类中相互调用方法时,直接通过方法名调用。

public  class  Teacher{

public  void  teach(){

    study();

}

public void study(){

}

}

 

u 不同类中调用方法时,需要首先创建类对象,通过对象名.方法名()进行调用。

public  class  Teacher{

public void teach(){

}

}

public  class  Student(){

public  void  learn(){

    //调用Teacher类中的teach方法

    Teacher  teacher = new  Teacher();

    teacher.teach();

}

}

u 方法调用时,不需要写{}

Teacher  teacher  =  new  Teacher();

teacher.teach(){};//错误

teacher.teach();//正确

3. 构造方法

u 构造方法的方法名和类名相同。

u 如果没有显示定义构造方法,那么系统会默认创建一个无参的构造方法。

u 如果显示定义了构造方法,那么系统将不会再创建任何构造方法。

u 构造方法没有返回值类型。

u 一个类中可以存在多个构造方法。

u 创建类对象时,关键字new后面跟的就是类的构造方法。

4. 方法的重载

1. 重载需要满足以下条件:

在同一个类中

方法名相同

参数列表不同(参数个数不同、参数类型不同、参数顺序不同)

2. 注意:方法的访问修饰符和返回值类型不在考虑范围之内。

四、 局部变量和成员变量

成员变量:类中定义的属性或字段就是成变量。

局部变量:方法中定义的变量、代码块中定义的变量({})都是局部变量。

成员变量可以通过this进行访问;局部变量不可以。

成员变量的优先级 < 局部变量的优先级

成员变量,在类的所有方法中均可以使用;但是局部变量只能在相应的代码块中使用。

五、 类成员的访问修饰符

                       同一个类中             同一个包中           子类中          任何地方           

    PRivate              yes                     no                  no              no

    默认修饰符            yes                     yes                 no              no

    protected            yes                     yes                 yes             no

public               yes                     yes                 yes             yes

 

    注意:优先级从低到高依次为:private(私有) < 默认 < protected(受保护) < public(公共)

    上述访问修饰符适用于:属性、方法。不适用于类,类的访问修饰符只有2个:public和默认修饰符。

六、 JAVA中的命名规则

1. 驼峰命名法

标识符中,第一个英文单词首字母小写,其他单词首字母均大写。

2. 帕斯卡命名法

标识符中,所有英文单词首字母均大写。

3. JAVA中的命名规则

包:全小写。

类:帕斯卡命名法。

属性|方法:驼峰命名法。

七、 静态成员

1. 定义

被static关键字修饰的成员就是静态成员,静态成员包括:静态属性、静态方法、静态代码块。

public  class  MathHelper{

//定义静态成员

public static final double PI = 3.14;

//静态代码块

static{

    //代码

}

//静态方法

public  static  double  calculateCircleArea(double  r){

    return PI * r * r;

}

}

2. 注意事项

u 静态成员需要通过类名进行调用:double area = MathHelper.calculateCircleArea(5.0)。

u 静态代码块只执行一次,并且在系统启动时执行。

u 静态成员虽然使用方便(不需要事先实例化),但是静态成员在内存中会一直存在。

八、 包

1. 设置类所在的包:在源文件的第一行添加:  package 包名

      package com.bdqnsjz.demo;

      public class Test{}

2. 导入包:在源文件的package和类名中间添加:  import 包名

      package com.bdqnsjz.demo;

      import com.dbqnsjz.homework;

      public class Test{}

3. 注意:

u 包名由小写字母组成,不能以圆点开头或结尾

u 包名之前最好加上唯一的前缀,通常使用组织倒置的网络域名

u 常见的包:

java.lang:虚拟机自动引入

java.util:提供一些实用类

java.io:   输入、输出

u package和import的顺序是固定的:

1.package必须位于第一行(忽略注释行)

2.只允许有一个package语句

3.其次是import

4.接着是类的声明

九、 封装

1. 定义

将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问。

public  class  Student{

private  String  name;

private  int  age;

 

public  String  getName(){

    return this.name;

}

public  void  setName(String  name){

    this.name  =  name;

}

}

2. 通俗的讲,封装就是将类的属性(字段)设置为私有的(private),并添加getter/setter方法操作属性。

十、 继承

1. 目的

解决代码冗余的问题。

2. 语法:

          public class 子类名 extends 父类名{

          }

3. 注意:

1.子类(扩展类)、父类(基类)

      2.一个类只有有1个父类

      3.在父类中被protected修饰符修饰的变量,可以在子类中访问。

        在父类中被private修饰符修饰的变量,不可以在子类中访问。

      4.在子类中通过super关键字来访问父类的成员。

        在当前类中通过this关键字来访问本类的成员。

      5.实例化子类对象时,会默认调用父类无参的构造方法。

      6.在子类中调用父类构造方法时,应该在子类的构造方法的第一行进行调用。

4. 方法的重写

定义:子类重新实现父类的方法。

要求:方法名相同;参数列表相同;返回值类型相同;子类方法访问修饰符高于父类方法的修饰符。

    注解:@Override  重写

5. 方法重载和方法重写的区别

    1.方法重写研究的是子类和父类,方法的重载研究的是同一个类中的方法

    2.方法重写的方法名要相同,方法重载时方法名也相同

    3.方法重写时,参数列表相同,方法重载时,参数列表不同。

    4.方法重写时,返回值相同,方法重载时,返回值类型无关。

6. Object类

    1.Object是所有类的父类(所有类都直接或间接继承自Object类)

    2.判断值类型的变量是否相等用==   判断引用类型的变量是否相等用equals

    3.hashCode哈希值。每次通过构造方法创建类的对象后,都有1个唯一的哈希值。

7. instanceof关键字

    用途:instanceof用于判断一个引用类型所引用的对象是否是一个类的实例。

向上转型:子类对象转父类对象       

Pet pet1 = new Dog();      Pet pet2 = new Penguin();

向下转型:父类对象转子类对象       

Dog dog = (Dog)pet1;       Penguin penguin = (Penguin)pet1;//null

注意:向上转型安全,向下转型有风险,可能会存在类型不兼容的问题。

解决办法就是使用instanceof关键字判断是否类型兼容。

十一、 多态

1. 定义:

同一个引用类型,使用不同的实例而执行不同操作。

2. 具体实现步骤:

1.定义父类和子类,在子类中重写父类的方法;

2.定义一个方法,方法的参数为父类型,在方法中调用父类被重写的方法;

3.调用该方法时,传递子类对象,结果执行的为子类的方法,而非父类的方法。

3. 注意:

多态中涉及到的类应该存在继承关系。

里氏代换原则(凡是出现父类的地方,都可以使用子类对象)

public void takeCare(Pet pet){

pet.cure();

}

Pet dog = new Dog();

Pet penguin = new Penguin();

doctor.takeCare(dog);

doctor.takeCare(penguin);

 

十二、 抽象类

抽象方法:被abstract关键字修饰的方法就是抽象方法。

抽象类:被abstract关键字修饰的类就是抽象类。

注意:

1. 抽象方法不能有方法体。    

public abstract void run();

2. 抽象方法所在的类一定是抽象类。    

public abstract class Traffic{}

3. 抽象类中的方法不一定都是抽象方法。

4. 抽象类无法直接实例化创建对象,必须调用子类的构造方法创建对象。

十三、 接口

1. 定义:

接口用于提供一种约定(方法),使得实现接口的类在形式上保持一致。

2. 语法:

public interface 接口名{

//抽象方法

}

public class 类名 implements 接口名{

        //实现接口中所有的抽象方法

}

3. 注意:

1.接口中只能包含抽象方法(不需要使用abstract关键字修饰)

2.一个类可以实现多个接口(只能继承1个类)

3.接口不能直接被实例化(由实现类去实例化接口)。

4.一个接口可以继承多个接口

5.一个类可以实现多个接口

6.接口中的所有方法都为抽象方法

7.抽象类实现接口后,可以不实现接口中的抽象方法

十四、 异常

1. 定义

异常是指在程序运行过程中所发生的不正常的事件,它会中断正在运行的程序。

2. 异常相关的关键字

    try、catch、finally、throw、throws

u try:执行可能产生异常的代码

u catch:捕获异常,编写处理异常的代码

u finally:无论是否发生异常,都要执行的代码块

u throw:手动抛出异常

u throws:声明方法可能要抛出的各种异常

3. 注意

u try代码块有可能出现异常也可能不会出现异常

u 只有try代码块出现异常时,catch代码块才会执行

u try中的代码块一旦出现异常,那么出现异常后面的代码不会继续执行。

u ex.printStackTrace()方法用于向控制台打印输出异常堆栈信息(在执行哪一行代码时出现什么异常)

u 如果出现的异常类型和catch块中异常的类型匹配,那么才会执行catch块中的代码,否则不执行。

u 所有异常类均直接或间接继承自类Exception

u 多重catch  在try代码块后,包含了多个catch代码块

u 多重catch时,Exception一定要放在最后

u System.exit(1);表示强制性退出系统。

u try-catch-finally结构中try语句块是必须的,catch、finally语句块均可选,但两者至少出现之一

u try-catch块中存在return语句,是否还执行finally块,如果执行,说出执行顺序

4. 常见的异常

1.ArrayIndexOutOfBoundsException   数组下标越界异常

2.NullPointerException              空指针异常

3.NumberFormatException             数字格式化异常

4.ArithmeticException               算术运算异常

5.RuntimeException                  运行时异常

6.FileNotFoundException            文件未找到异常

7.IOException                       输入输出异常

8.NoSuchMethodException            方法未找到异常

9.Exception                         所有异常的父类

10.ClassCastException              类型强制转换异常