华清远见-重庆中心-JAVA面向对象阶段技术总结

[public] [abstract|final] class <class_name>[extends<class_name>] [implements<interface_name>] {
    // 定义属性部分
    <property_type><property1>;
    <property_type><property2>;
    <property_type><property3>;
    …
    // 定义方法部分
    function1();
    function2();
    function3();
    …
}

public：如果使用 public 修饰，则可以被其他类和程序访问。每个 Java 程序的主类都必须是 public 类，作为公共工具供其他类和程序使用的类应定义为 public 类。
abstract：如果类被 abstract 修饰，则该类为抽象类，抽象类不能被实例化，但抽象类中可以有抽象方法（使用 abstract 修饰的方法）和具体方法（没有使用 abstract 修饰的方法）。继承该抽象类的所有子类都必须实现该抽象类中的所有抽象方法（除非子类也是抽象类）。
final：如果类被 final 修饰，则不允许被继承。
class：声明类的关键字。
class_name：类的名称。
extends：表示继承其他类。
implements：表示实现某些接口。
property_type：表示成员变量的类型。
property：表示成员变量名称。
function()：表示成员方法名称。

创建类

创建一个新的类，就是创建一个新的数据类型。实例化一个类，就是得到类的一个对象。

成员变量通过在类的主体中定义变量来描述类所具有的特征（属性）表明对象的状态和属性
方法表明对象所具有的行为

1.2 对象

当一个类的定义存在后，可以使用 new 运算符创建该类的对象。
对象创建的过程一般称为类的实例化

语法规则：

成员变量的初始化

成员变量的默认初始化值规则

声明成员变量的语法如下：

[public|protected|private] [static] [final] <type><variable_name>

各参数的含义如下。

public、protected、private：用于表示成员变量的访问权限。
static：表示该成员变量为类变量，也称为静态变量。
final：表示将该成员变量声明为常量，其值无法更改。
type：表示变量的类型。
variable_name：表示变量名称。

对象创建之后，其成员变量可以按照默认的方式初始化，对象成员具有默认值。

成员变量的调用

成员变量的调用，可以根据某个对象的引用，找到成员变量，然后使用成员变量。

// 1. 创建一个汽车
Car car = new Car() ; // 创建的对象，赋值给引用类型的变量。
// 2. 给汽车的属性赋值
car.pinPai = "BYD宋";
car.color = "红色";
car.faDongJi = "byd发动机";
car.count = 7 ;

成员方法的调用

方法的调用必须通过某个对象的引用。

当通过么对象的引用调用方法时，方法中涉及的成员变量就是该对象的成员变量。

Person p1 = new Person();
 p1.eat("火锅");
 p1.sayHello();
 p1.driver();

1.3引用类型

除8种基本数据类型之前，用类名（接口，数组）声明的变量称为引用类型变量，简称引用。
引用类型变量中存储的是某个对象在内存中的地址信息。
引用的功能在于访问对象。
引用类型变量声明语法规则：

二、java的继承

在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的
extends关键字可以实现类的继承
子类（sub class）可以继承父类（super class）的成员变量及成员方法。同时也可以定义自己的成员变量和成员方法。
java语言不支持多继承，一个类只能继承一个父类。但一个父类可以有多个子类。

向上造型

一个子类的对象可以向上造型为父类的类型 Father f = new Sun();
java编译器编译的时候根据父类型检查调用的成员变量和成员方法是否匹配。

// 3. 向上造型 ： 子类对象，赋值给父类的引用
Animal dog = new Dog() ;//
dog.birth = new Date();
dog.color = "黄色";
dog.count = 4 ;
dog.sex = "女";
dog.sing("汪汪。。。。");
dog.eat("狗粮......");
dog.run();
// dog.seeDoor() ;// 编译错误： 在编译的时候， dog引用是按引用的类型Animal使
用。 Animal没有seeDoor的方法
// 在运行的时候， dog引用找到的是对象的实际类型Dog ，进行使
用，这个时候就有seeDoor方法。
// 如果一定要调用seeDoor（） , 这里只能修改dog的引用类型为Dog. ,即： Dog dog
= new Dog();

继承中的构造方法

子类的构造方法中必须通过super调用父类的构造方法。因为创建子类之前，必须先创建父类。
子类的构造函数如果没有直接使用super调用父类构造方法，java编译器会自动的加入对父类无参构造函数的调用（那么要求父类必须有无参构造方法）。

三、java的重写和重载

重写(Override)

子类从父类继承的方法，如果不能满足子类的需要，可以重写父类的方法。即方法名和参数列表和
父类保持完全一致，方法的实现不同。
子类重写父类的方法之后，子类对象优先调用自己的方法。
子类重写父类的方法的时候，可以在重写的方法中，使用super关键字调用到父类的方法。

// 图形
public class Shape {
int x ;
int y ;
public double area(){ // 成员函数
System.out.println("Shape的area函数被调用");
return 0 ;
}
}
class Rect extends Shape{
double w ;
double h ;
方法重载之后，子类调用自己重写之后的方法
6.package 关键字
定义类的时候需要指定类的名称。但是如果仅仅将类名作为类的唯一标志，则会出现命名冲突的问
题。
在java中，是用package 来解决命名冲突的问题。因此定义类的时候，一般需要先给类指定一个包
名。
类的真实名字是： 包名 + 类名。
包名可以有层次结构，一个类可以有多层包名。
// 重写：方法签名(方法的修饰符 ， 返回值类型， 方法名，参数等)和父类的方法完全一致。
public double area(){
System.out.println("Rect中的area函数被调用。");
return w * h ;
}
public double area(double w , double h ){
return w * h ;
}
}

方法重载之后，子类调用自己重写之后的方法

Super 关键字的使用

当需要在子类中调用父类的被重写方法时，要使用 super 关键字。

super( ) 必须是在子类构造方法的方法体的第一行。

重载(Overload)

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
最常用的地方就是构造器的重载。
在一个类中，如果多个方法的方法名相同，参数列表不同时，这些方法称为重载的方法。同名不同参。重载用于在一个类中，某个方法在不同的条件下，执行不同的内容。

super和this的区别

this 指的是当前对象的引用，super 是当前对象的父对象的引用。

super 关键字的用法：

super.父类属性名：调用父类中的属性
super.父类方法名：调用父类中的方法
super()：调用父类的无参构造方法
super(参数)：调用父类的有参构造方法

如果构造方法的第一行代码不是 this() 和 super()，则系统会默认添加 super()。

this 关键字的用法：

this.属性名：表示当前对象的属性
this.方法名(参数)：表示调用当前对象的方法

当局部变量和成员变量发生冲突时，使用this.进行区分。

关键字

1、null

引用类型变量用于存放对象的地址，可以给引用类型赋值为null,表示不指向任何对象。
如果某个引用类型变量为null的时候，不能访问对象，否则抛出空指针异常。

2、instanceof关键字

对于一个父类的引用类型，可以指向该类的对象也可以指向其任意一个子类型的对象。
通过instanceof 关键字判断引用指向的对象的实际类型。
根据引用指向的实际类型，将引用强制转换为实际类型。

// 4. 创建Animal ： 动物是动物 ， 狗是动物 ， 鸡是动物。
Animal a1 = new Animal() ;
Animal a2 = new Dog(); // Dog 和Chicken都是Animal的子类。
Animal a3 = new Chicken() ;
// 5. 类型转换 ：
4.继承中的构造方法
子类的构造方法中必须通过super调用父类的构造方法。因为创建子类之前，必须先创建父类。
子类的构造函数如果没有直接使用super调用父类构造方法，java编译器会自动的加入对父类无参
构造函数的调用（那么要求父类必须有无参构造方法）。
// instanceof : 用于判断 引用 对应的对象是否为某种类型 , 是结果为true ,否
则结果为false.
// a2是动物 ， 但是a2本质是狗。 a2不能转换为鸡这个类型。
if(a2 instanceof Dog){ // instanceof的运算结果是true或者false.
// a2 是 Dog , 那么就可以把a2转换为Dog ，然后赋值给Dog类型的引用.
Dog dog1 = (Dog) a2;
dog1.seeDoor(); // 类型转换之后，就可以调用到子类Dog的所有方法。
}
if(a3 instanceof Chicken){
Chicken chicken = (Chicken) a3;
chicken.fly();
}
Chicken chicken = (Chicken) a2; // 没有编译错误。 有运行错误:
ClassCastException - 类型转换错误。

3、package 关键字

定义类的时候需要指定类的名称。但是如果仅仅将类名作为类的唯一标志，则会出现命名冲突的问题。
在java中，是用package 来解决命名冲突的问题。因此定义类的时候，一般需要先给类指定一个包名。
类的真实名字是：包名 + 类名。
包名可以有层次结构，一个类可以有多层包名。
如果各个公司和组织的程序员都随意命名包，并不能很好的解决命名冲突问题。因此指定包名的时候建议使用：

公司域名反写 + 项目名 + 项目模块名 + mvc 模式分层

4、import 关键字

如果要在程序中，使用某个类，可以用该类的全名，这样比较复制。

java.util.Date date = new java.util.Date();
一般使用import 语句导入这个类，然后使用该类。

package oopday2;
import java.util.Date;
//import java.sql.Date ;
public class ImportDemo {
public static void main(String[] args) {
//java.util.Date date = new java.util.Date(); // java.util.Date是Date
类的全名。
Date date = new Date(); // 使用import关键字，先导入java.util.Date ， 在
类中就可以直接通过类名，使用到这个类型。
java.sql.Date date1 = new java.sql.Date(1);
}
}