类和对象

标签：类中访问   堆栈   getter   目的   注解   集合   继承   bsp   重写   

一、 定义

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

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

关系：类是对象的抽象，对象是类的具体存在。

二、 类

1. 定义类

1. 创建对象

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

示例：Student  stu  =  new  Student();

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

stu.name = “zhangsan”;   

stu.study();

1. 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 方法体中不能再定义其他方法。

1. 方法的调用

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

注意：

u 方法如果有参数，那么必须传递参数（参数的类型、个数）。

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

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

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

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

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

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

1. 构造方法

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

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

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

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

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

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

1. 方法的重载
   1. 重载需要满足以下条件：

在同一个类中

方法名相同

参数列表不同（参数个数不同、参数类型不同、参数顺序不同）

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

四、 局部变量和成员变量

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

局部变量：方法中定义的变量、代码块中定义的变量（{}）都是局部变量。

成员变量可以通过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. 驼峰命名法

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

1. 帕斯卡命名法

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

1. JAVA中的命名规则

包：全小写。

类：帕斯卡命名法。

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

七、 静态成员

1. 定义

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

1. 注意事项

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

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

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

八、 包

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

      package com.bdqnsjz.demo;

      public class Test{}

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

      package com.bdqnsjz.demo;

      import com.dbqnsjz.homework;

      public class Test{}

1. 注意：

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

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

u 常见的包：

java.lang：虚拟机自动引入

java.util：提供一些实用类

java.io:   输入、输出

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

1.package必须位于第一行（忽略注释行）

2.只允许有一个package语句

3.其次是import

4.接着是类的声明

九、 封装

1. 定义

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

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

十、 继承

1. 目的

解决代码冗余的问题。

1. 语法：

          public class 子类名 extends 父类名{

          }

1. 注意：

1.子类（扩展类）、父类（基类）

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

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

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

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

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

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

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

1. 方法的重写

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

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

    注解：@Override  重写

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

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

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

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

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

1. Object类

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

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

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

1. instanceof关键字

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

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

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

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

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

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

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

十一、 多态

1. 定义：

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

1. 具体实现步骤：

1.定义父类和子类，在子类中重写父类的方法；

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

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

1. 注意：

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

里氏代换原则（凡是出现父类的地方，都可以使用子类对象）

十二、 抽象类

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

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

注意：

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

public abstract void run();

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

public abstract class Traffic{}

1. 抽象类中的方法不一定都是抽象方法。
2. 抽象类无法直接实例化创建对象，必须调用子类的构造方法创建对象。

十三、 接口

1. 定义：

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

1. 语法：

1. 注意：

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

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

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

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

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

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

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

十四、 异常

1. 定义

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

1. 异常相关的关键字

    try、catch、finally、throw、throws

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

u catch：捕获异常，编写处理异常的代码

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

u throw：手动抛出异常

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

1. 注意

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块，如果执行，说出执行顺序

1. 常见的异常

1.ArrayIndexOutOfBoundsException   数组下标越界异常

2.NullPointerException              空指针异常

3.NumberFormatException             数字格式化异常

4.ArithmeticException               算术运算异常

5.RuntimeException                  运行时异常

6.FileNotFoundException            文件未找到异常

7.IOException                       输入输出异常

8.NoSuchMethodException            方法未找到异常

9.Exception                         所有异常的父类

10.ClassCastException              类型强制转换异常

类和对象

标签：类中访问   堆栈   getter   目的   注解   集合   继承   bsp   重写   

原文地址：http://www.cnblogs.com/daniel-wang/p/6431186.html