类、对象和包
1） 面向对象编程（Object Oriented Programming ，简称 OOP）：20世纪70年代以后开始流行。
2） 结构化编程与面向对象编程的区别：
A. 在结构化编程中，程序主要围绕着解决的任务来设计。编写程序就是编写执行特定任务的过程，过程中需要用到的数据通过过程参数传递到过程中。过程可以查看以及改变传递进来的数据，并可以将值返回给调用它的过程。
B. OOP主要围绕着解决的问题中的对象来设计，对于每个对象，我们会编写一个类来描述对象的属性和行为。
3） 对象和类
A. 对象：“万物皆对象”、对象由属性和行为组成，属性是对象所具有的特征，行为是对象可以做到动作。
B. 类：类是具有相同属性和行为的一组对象的集合。对象的每个属性被表示为类中的一个成员变量，每个行为成为类中的一个方法。
C. 两者关系：类是对象的抽象（描述），对象是类的实例。
4） 成员变量和局部变量
A. 成员变量：在类中声明的变量，有默认值，可以用在一个类的所有地方。
一个对象的成员变量的初始值 成员变量的数据类型 初始值
a. 成员变量组成部分：
— 访问修饰符（public 公用的、private 私有的、protected 受保护的、默认的）
— 数据类型
— 成员变量名称（必须是一个有效的标识符）。后面用分号结束
例如：
/**
* 学生
*
* @author Administrator
*
*/
public class Student {
/* 属性 成员变量 */
public String name = null; // 姓名
public String sex; // 性别
public int age; // 年龄
public String stuNo; // 学号
}
B. 局部变量：在方法中声明的变量，没有默认值，仅限于在一个方法中有用。
b. 局部变量组成部分：
— 访问修饰符
— 返回值
— 方法名称（必须是一个有效的标识符）
— 参数列表，在括号中出现
例如：
/* 方法 */
访问修饰符 返回值类型 方法名([参数列表]) {
方法主体 -- 待实现的功能代码块
}
*/
public void introduce() {
System.out.println(this.toString());
System.out.println("姓名：" + name + "\n性别：" +
sex + "\n年龄：" + age +
"\n学号：" + stuNo);
}
5) 如何创建对象以及 访问对象的属性和方法？
例如：
import java.util.Scanner;
public class StudentTest {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
/* 创建学生对象 */
Student stu = new Student();
stu.introduce();
// 为对象属性赋值
// 如何调用对象的属性 对象名.属性名
System.out.print("请输入姓名：");
stu.name = input.next();
System.out.print("请输入性别：");
stu.sex = input.next();
// 调用对象的方法，实现自我介绍
// 对象名.方法名([实参列表]);
System.out.println("********************");
stu.introduce();
}
}
7） 包（关键字：package）：包声明必须是源代码文件中除注释以外的第一条语句。
例如：
package com.lovo;
public class StudentTest {
public static void main(String[] args) {
Student student = new Student("0051", "王菲", 24);
Student stu = new Student();
student.display();
}
A. 用途：
a. 提供了一个组织类的机制。同时可以防止类命名冲突。
b. 为包中的类提供了一个命名空间。
B. 使用import关键字导入其它包中的类：
a. 使用类的全名。例如：pay.Employee;
b. 使用关键字import以及通配符（*）导入包。例如：import pay.*;
c. 使用关键字import导入类本身。例如：import pay.Employee;
1：继承的定义：
Java继承是面向对象的最显著的一个特征。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。
2：关键字： extends ：继承
3：格式形式： public class A extends B {} A:代表子类 B:代表父类
4：子类可继承父类的public，protected成员。
5：java中的继承是单继承的，具有单根性，传递性。所以一个类就只有一个父类。
6：方法重写： （子类对父类方法的重写）
其规则：
1：子类的返回值类型，方法名，参数列表必须和父类的相同；
2：访问修饰符必须大于父类修饰符的范围；
3：子类重写的异常不能抛出的比父类多。
与之区别的 方法重载
规则：在一个类中有两个及以上的方法名相同，参数列表不同的。
7：super 关键字：父类 超类
8：final 关键字
1：final类：没有子类，不能被继承
2：final方法：不能被重写
3：final常量：常量值不能被修改
9：继承的优点：
1: 代码的重用性
2：父类的方法和属性可以用于子类
3：设计应用程序变得简单
4：子类可继承父类的属性和方法
Java基本特征[封装，继承，多态，抽象]
Java三大特性[封装，继承，多态]
封装
封装是使类中的成员变量都是private，并提供public方法访问这些变量的技术
实现封装：
1）、修改属性的可见性来限制对属性的访问。
2）、为每个属性创建一对赋值方法和取值方法，用于对这些属性的访问。
3）、在赋值和取值方法中，加入对属性的存取的限制。
用get方法访问成员变量，用set方法获取成员变量。
例如：
//员工类
public class Employee{
private String name;//名字
private String gender;//性别
......
}
//set方法获取名字
public void setName(String name){
this.name=name;
}
//get方法访问名字
public String getName(){
return this.name;
}
封装的好处：
通过封装，可以实现对属性的数据访问限制，同时增加了程序的可维护性。
由于取值方法和赋值方法隐藏了实现的变更，因此并不会影响读取或修改该属性的类，避免了大规模的修改，程序的可维护性增强。
继承
1：extends 关键字
public class Employee {
String name;
Date hireDate;
Date dateOfBirth;
String jobTitle;
int grade;
... }
public class Manager extends Employee {
String department;
Employee[] subordinates;
... }
在这样的定义中，Manager 类被定义，具有 Employee 所拥有的所有变量及方法。所有 这些变量和方法都是从父类的定义中继承来的。
2：初始化子类必先初始化父类
在 Java 编程语言中，对象的初始化是非常结构化的，这样做是为了保证安全。在前面 的模块中，看到了当一个特定对象被创建时发生了什么。由于继承性，对象被完成，而且下 述行为按顺序发生：
（1）存储空间被分配并初始化到 0 值
（2）进行显式初始化
（3）调用构造方法
3.单继承性：
当一个类从一个唯一的类继承时，被称做单继承性。单继承性使代码更可靠。 接口提供多继承性的好处，而且没有（多继承的）缺点。 Java 编程语言允许一个类仅能继承一个其它类，即一个类只能有一个父类。这个限制 被称做单继承性
4：构造方法不能被继承
尽管一个子类从父类继承所有的方法和变量，但 它不继承构造方法，掌握这一点很重要。 一个类能得到构造方法，只有两个办法。或者写构造方法，或者根本没有写构造方法， 类有一个默认的构造方法。
5：关键字 super
关键字 super 可被用来引用该类的父类，它被用来引用父类的成员变量或方法
super 关键字的功能：
（1）：点取父类中被子类隐藏了的数据成员
（2）：点取已经覆盖了的方法
（3）：作为方法名表示父类构造方法
例如： public class Employee {
private String name;
private int salary;
public String getDetails() {
return "Name: " + name + "\nSalary: " + salary; }
}
public class Manager extends Employee {
private String department;
public String getDetails() {
return super.getDetails() + // 调用父类的方法 "\nDepartment: " + department; }
}
6：调用父类构造方法 在许多情况下，使用默认构造方法来对父类对象进行初始化。
当然也可以使用 super 来显示调用父类的构造方法。
public class Employee {
String name;
public Employee(String n) {
this.name = n;
}
}
public class Manager extends Employee {
String department;
public Manager(String s, String d) {
super(s);
department = d;
}
}
注意：无论是 super 还是 this，都必须放在构造方法的第一行
多态
多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，就是同一种事物表现出的多种形态。
多态存在的三个必要条件
一、要有继承；
二、要有重写；
三、父类引用指向子类对象。
多态的好处：
1.可替换性（substitutability）。多态对已存在代码具有可替换性。
2.可扩充性（extensibility）。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。
3.接口性（interface-ability）。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。
4.灵活性（flexibility）。它在应用中体现了灵活多样的操作，提高了使用效率。
5.简化性（simplicity）。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。
instanceof
运算符功能：用来判断某个实例变量是否属于某种类的类型。
一旦确定了 变量所引用的对象的类型后，可以将对象恢复给对应的子类变量，以获取对象的完整功能。
例如：
public class Employee；
public class Manager extends Employee；
public class Contractor extends Employee ；
public void method(Employee e) {
if (e instanceof Manager) {
//如果雇员是经理，可以做的事情写在这里
}else if (e instanceof Contractor) {
//如果雇员是普通的职员，可以做的事情写在这里
}else { //说明是临时雇员，可以做的事情写在这里
}
}
两种类型转换
1.向上类型转换
将子类型转换为父类型。
对于向上的类型转换，不需要显示指定，即不需要加上前面的小括号和父类类型名。
2.向下类型转换
将父类型转换为子类型。
对于向下的类型转换，必须要显式指定，即必须要使用强制类型转换。