Java编程进阶

一、类和对象

1、面向对象的概念

现实世界就是“面向对象的”。任何存在的事物都可以看作“对象”。

面向对象就是采用“现实模拟”的方法设计和开发程序。面向对象技术利用“面向对象的思想”去描述“面向对象的世界”，实现了虚拟世界和现实世界的一致性，符合人们的思维习惯使设计开发人员之间更加流畅，同时有代码重用性高、可靠性等优点，大大提高了软件尤其是大型软件的设计和开发效率。

2、使用面向对象进行程序设计

面向对象设计的过程就是抽象的过程，分以下三步来完成：

第一步：发现类

第二步：发现类的属性

第三步：发现类的方法

抽象时遵循的原则如下:

1. 属性和方法的设置是为了解决业务问题
2. 关注主要属性和方法
3. 如没有必要，勿增加额外的类、属性和方法

3、创建类和对象

类的语法如下:

访问修饰符 class 类名{
      //属性和方法
}

创建对象、调用属性以及方法的语法：

类名 对象名=new 类名();  //创建对象

对象名.属性=值;  //调用属性并赋值

对象名.方法; //调用方法

类和对象是面向对象的两个核心概念，类是对某一类事物的描述，是抽象的定义，对象是实际存在的，具体的事物个体。可以由一个类创建多个对象。

4、构造方法及其重载

构造方法的概念：

构造方法的名称和类名相同，没有返回值类型。构造方法的主要作用就是在创建对象时执行初始化操作，如给成员属性复制。构造方法是一个特殊的方法，当没有手写构造函数时，系统会提供一个默认无参构造函数，以下是构造函数的一个示例：

public class Dog{
    String name="无名氏";
    int love=0;
    String strain="拉布拉多";
	//无参构造函数
	public Dog(){
    	this.name="欧欧";
    	this.love=0;
    	this.strain="雪纳瑞";
    	System.out.println("执行无参构造方法");
	}
	//有参构造函数
	public Dog(String name,String strain){
   	 	this.name=name;
    	this.strain=strain;
	}
}

方法重载的特点：

1、必须在同一个类中

2、方法名相同

3、参数列表不同

4、重载与方法返回值和修饰符没有任何关系

在使用this调用自身的其他构造方法时，只能作为第一条语句

5、static修饰符

static可以用来修饰属性，方法和代码块。**static修饰的变量属于这个类所有，即由这个类创建的所有对象共用一个static变量。通常把static修饰的属性和方法称为类属性和类方法。**不使用static修饰的属性和方法属于单个对象，通常称之为实例属性和实例方法。

使用static修饰的属性和代码块时，分配空间，得出结果：

1、在加载类的过程中，完成静态变量的内存分配，再执行静态块，两者是在创建对象之前执行的。

2、类属性和类方法可以通过类名和对象名去访问，实例属性和实例方法只能通过对象名

3、类方法只能访问类属性和其他类方法

注意：方法里不能定义static变量，也就是说，类变量不能是局部变量

6、类的三大特性

6.1、封装

概念：封装是面向对象的三大特性之一，就是将类的状态信息隐藏在类内部，不允许外部程序直接访问，而通过该类提供的方法来实现对隐藏信息的操作和访问

封装的具体步骤：修改属性的可见性来限制对属性的访问;为每个属性创建一对赋值（setter）方法和取值（getter）方法，用于对这些属性的存取；在赋值方法中，加入对属性的存取控制语句

封装的好处：隐藏类的实现细节，让使用者只能通过程序规定的方法来访问数据，可以方便加入存取控制语句，限制不合理操作。

访问修饰符

封装会用到多个权限控制符来修饰成员变量和方法，区别如下：

1. private：成员变量和方法只能在其定义的类中被访问，具有类可见性
2. 默认的(friendly)：成员变量和方法只能被同一个包里的类访问，具有包可见性
3. protected：可以被同一个包中的类访问，被同一个项目中不同包的子类访问
4. public：可以被同一个项目中的所有类访问，具有项目可见性，是最大的访问权限

6.2、继承

**概念：**继承是面向对象的三大特性之一，是Java实现代码重用的重要手段，Java只支持单继承，即每个类只能有一个直接父类。

继承的语法如下：

访问修饰符 class 子类类名 extends 父类类名{
    //类定义部分
}

继承通过extends关键字来实现，修饰符如果是public，则该类在整个项目中可见，不可以使用private和protected修饰类。

继承表达的是is a的关系，java中所的类都之间或间接的继承了java.lang.Object类。

在java中，子类可以从父类中继承的东西：

1. 继承public和protected修饰的属性和方法，无论子类和父类是否在同一个包
2. 继承默认修饰的属性和方法，但子类和父类要在同一个包
3. 无法继承private修饰的属性和方法
4. 无法继承父类的构造方法

重写和继承关系中的构造方法

子类重写父类方法

概念：

在子类中可以根据需求对从父类继承的方法进行重新编写，称为方法的重写或者方法的覆盖。方法重写必须满足以下要求：

1、重写方法和被重写方法必须具有相同的方法名

2、重写方法和被重写方法必须具有相同的参数列表

3、重写方法的返回值必须和被重写的返回值类型相同或是其子类

4、重写方法不能缩小被重写方法的访问权限

super关键字

super 代表对当前对象的直接父类对象的默认引用。在子类中可以通过 ”super“去访问父类的成员。

1、super必须出现在子类中，而不是其他位置

2、可以访问父类的成员，如父类的属性和方法，构造方法

3、注意访问权限的控制，如无法通过super访问private成员

注意：在构造方法中如果有this语句或super语句出现，则只能位于第一条语句，在同一个构造方法中不允许同时出现使用this和super语句。

6.3、多态

概念：多态（polymorphism）是具有表现多种形态的能力的特征，更专业化的说法，同一个实现接口，使用不同的实例而执行不同的操作。

子类到父类的转换（向上转型）

子类转换父类时的规则：

1. 将一个父类的引用指向一个子类对象，称为向上转型，自动进行类型转换
2. 通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法
3. 通过父类引用变量无法调用子类特有的方法

父类到子类的转换（向下转型）

概念：将一个指向子类对象的父类引用赋给一个子类的引用，称为向下转型

instanceof运算符

该运算符用来判断一个对象是否属于一个类或者实现了一个接口，结果为true或者false。大多用于判断真实的数据类型

语法如下

对象 instanceof 类或接口

1. 使用instanceof运算符时，对象的类型必须和instanceof的第二个参数所指定的类或接口在继承上有上下级关系，否则会出现编译错误
2. instanceof通常和强制类型转换

总结多态的三个条件：

1. 继承的存在（继承是多态的基础，没有继承就没有多态）
2. 子类重写父类的方法（多态下调用子类重写后的方法）
3. 父类引用变量执行子类对象（子类到父类的类型转换）

7、抽象类和抽象方法

概念：

Java中可以使用abstract来修饰类，抽象类，抽象类不能new对象。抽象方法也用abstract修饰，语法如下：

访问修饰符 abstract class 类名{} //抽象类
访问修饰符 abstract 返回值 方法名();//抽象方法不能有方法体

抽象类和抽象方法的特点如下：

1、抽象类和抽象方法都通过abstract关键字来修饰

2、抽象类不能实例化

3、抽象方法只有方法声明，没有方法实现，抽象类中也可以有构造方法

4、抽象方法子类必须重写

abstract可以用来修饰类和方法，但不能用来修饰属性和构造方法。

注意：

1、abstract不能和private同时修饰一个方法

2、abstract不能和static同时修饰一个方法

3、abstract不能和final同时修饰一个方法或类

8、final修饰符

final的特点：

1、final修饰的类不能再被继承

2、用final修饰的方法，不能再被重写

3、final修饰的变量，只能在初始化进行赋值，不能在其他地方修改

二、接口

1、概念

在生活中，接口是一套规范，只要是满足这个规范的设备，就可以组装到一起，从而实现这个设备的功能。在软件中，接口同样是一种规范和标准，他们可以约束类的行为，是一些方法特征的集合，但是没有方法的实现。接口可以看作一种特殊的 “抽象类”，它有利于代码复用，利于代码的维护。

2、介绍

接口的语法如下：

修饰符  interface 接口名 extends 父接口1,父接口2{
    //常量定义
    //方法定义
}

接口的命名规则与类相同，采用帕斯卡命名法。

实现接口的语法如下：

class 类名 extends 父类名 implements 接口1，接口2{
    //类成员
}

接口的特点：

1. 接口中可以定义常量，不能定义变量。接口中的属性都会自动用public static final修饰。
2. 接口中所有方法都是抽象方法。方法都会自动用public abstract 修饰
3. 和抽象类一样，接口不能实例化，接口中不能有构造方法
4. 接口之间可以通过extends实现继承关系，一个接口可以继承多个接口，但接口不能继承类
5. 实现接口的类必须实现接口的全部方法，否则必须定义为抽象类

注意：一个类只能有一个父类，但可以通过implements实现多个接口，当在继承父类的同时又要实现多个接口时，extends关键字必须位于implements关键字之前。

3、在C#中使用接口

定义语法如下：

[访问修饰符]  interface 接口名 : 父接口1,父接口2{
    //常量定义
    //方法定义
}

C#中实现接口的语法：

class 类名 : 父类名,接口1，接口2{ }

在C#中使用接口的特点：

1、接口之间可以通过冒号 “ ：”来实现继承关系，一个接口可以继承多个接口，但接口不能继承类。类只能有一个父类，但可以实现多个接口，使用冒号“:”来继承类并实现接口

2、接口定义零个或多个成员，成员主要是方法、属性和索引器。接口中不能包含常量、变量或构造方法，也不能包含任何静态成员。

3、接口中成员访问权限是public，定义接口时显示指定任何修饰符都是非法的

4、按照惯例，C#中接口的名称以大写字母 “I”开头

4、Java中和C#的接口对比

1、Java中接口通过extends来继承接口，类通过implements实现接口；C#中用 “：“来实现这两个功能

2、Java接口中的成员变量都是常量，自动用public static final修饰；C#中不允许存在成员变量，但可以有属性

3、Java接口中属性和方法都可以使用public；C#默认为public，但不允许使用public修饰

4、Java接口中可以定义静态常量和方法；C#接口中不允许包含任何静态成员