文章目录

面向对象设计概述
- 认识类
- 类的定义格式
- 对象特征
- 类的实例化
- 类和对象的关系
自定义类
- 构造器
- 封装的优点
- this关键字
- final实例域
静态域和静态方法
- 静态域和静态成员变量
- 静态方法
对象构造
- 重载
- 默认域初始化
- 无参数地构造器
- 显式域初始化
- 代码块
- - 普通代码块
  - 构造代码块
  - 静态代码块
包
- 类的导入
- 静态导入
- 把类放入包中
- 访问修饰符
- - 公有访问修饰符-public
  - 私有访问修饰符-private
  - 默认访问修饰符-不使用任何关键字
  - 受保护的访问修饰符-protected
- 类的设计技巧
内部类
- 实例内部类
- 匿名内部类
- 静态内部类
- 文件生成

面向对象设计概述

面向对象程序设计(简称OOP)，每个对象包含对用户公开的特定功能部分和隐藏的实现部分。在OOP中，人们不必关心对象的具体实现，只要能够满足用户的需求即可。

认识类

类(class)是构造对象的模板或蓝图，我们可以把类想象为一部手机，手机具有属性：品牌，电池容量，颜色，像素…还具有功能：打电话，打游戏，照相…,这里的手机就是我们的对象。

类的定义格式

// 创建类
class ClassName{field; // 字段(属性) 或者 成员变量method; // 行为 或者 成员方法
}

class为定义类的关键字，ClassName为类的名字，{}中为类的主体。

类中包含的内容称为类的成员。属性主要是用来描述类的，称之为类的成员属性或者类成员变量。方法主要说明类具有哪些功能，称为类的成员方法。

下面介绍洗衣机这个类的构造：

class WashMachine{public String brand; // 品牌public String type; // 型号public double weight; // 重量public double lenght; // 长public double weidth; // 宽public double height; // 高public String color; // 颜色public void WashClothes(){ // 洗衣服System.out.println("洗衣功能");}public void dryClothes(){ // 脱水System.out.println("脱水功能");}public void SetTime(){ // 定时System.out.println("定时功能");}
}

对象特征

对象有三个主要特征：

对象的行为(behavior)——可以对对象施加哪些操作，或可以对对象施加哪些方法?
对象的状态（state）——当施加那些方法时,对象如何响应?
对象标识(identity)——如何辨别具有相同行为与状态的不同对象?

首先，同一个类的所有对象实例，由于支持相同的行为而具有家族式的相似性。对象的行为是可调用的方法定义的。
其次，每个对象都保存着描述当前特征的信息。这就是对象的状态。对象的状态可能会随着时间而发生改变，但这种改变不会是自发的。对象状态的改变必须通过调用方法实现(如果不经过方法调用就可以改变对象状态，只能说明封装性遭到了破坏)。
对象的状态并不能完全描述一个对象。每个对象都有一个唯一的身份。例如，在一个订单处理系统中，任何两个订单都存在着不同之处，即使所订购的货物完全相同也是如此。需要注意，作为一个类的实例,每个对象的标识永远是不同的，状态常常也存在着差异。

类的实例化

我们自己定义的类和java内置的基本数据类型int，long类似，它们都是类型，但我们创建好这些自定义类型后，使用这些类型创建对象的过程就叫做类的实例化。在java中我们通过new关键字来实例化对象。

例如我们实例化狗类型：

class Dog {//狗的属性public String name;//名字public Color color;//颜色//狗的行为public void backs() {System.out.println(name + "汪汪叫");}public void wag() {System.out.println(name + "摇尾巴~~~");}public void fight(Dog dog1, Dog dog2) {System.out.println(dog1.name + "在打" + dog2.name + "!!!");}
}

实例化：

        Dog dog1 = new Dog();dog1.name = "常威";dog1.color = Color.black;dog1.backs();dog1.wag();Dog dog2 = new Dog();dog2.name = "来福";dog2.color = Color.white;dog2.backs();dog2.wag();dog1.fight(dog1,dog2);

注：

使用.来访问对象的方法和属性。
我们可以不为一个对象变量初始化，比如Dog dog这时候他不是一个对象，它也没有引用对象，所以我们不能所以任何方法在dog上，如果我们想使用其方法，这时候我们就可以采用两种方法；使用新构造的对象初始化这个变量①Dog dog = new dog; 使这个变量引用另一个已存在的对象②Dog dog = dog1;
—个对象变量并没有实际包含一个对象，而仅仅引用一个对象。

类和对象的关系

类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员.
类是一种自定义的类型，可以用来定义变量，但是在java中用类定义出来的变量我们成为对象.
一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量.

自定义类

雇员管理系统

import java.util.Date;
import java.util.GregorianCalendar;/*** Created with Intellij IDEA.* Description:雇员管理系统* User: a* Date: 2022-03-19* Time: 22:55*/
class Employee {/** 关键字private确保只有Employee类自身的方法能够访问这些实例域，* 而其他类的方法不能够读写这些域。* *///雇员的基本信息private String name;private double salary;private Date hireDay;public Employee(String n, double s, int year, int month, int day) {this.name = n;this.salary = s;GregorianCalendar calendar = new GregorianCalendar(year, month - 1,day);this.hireDay = calendar.getTime();}/** 关键字public意味着任何类的任何方法都可以调用这些方法*/public String getName() {return name;}public double getSalary() {return salary;}public Date getHireDay() {return hireDay;}public void raiseSalary(double byPercent) {double raise = salary * byPercent / 100;salary += raise;}}
public class TestDemo2 {public static void main(String[] args) {//构造器与其他的方法有一个重要的不同。构造器总是伴随着new操作符的执行被调用Employee[] staff = new Employee[3];staff[0] = new Employee("Tom",1000,2001,3,12);staff[1] = new Employee("Jack",2000,2004,4,13);staff[2] = new Employee("Mark",4000,2007,12,24);//员工薪水涨5%for (Employee e:staff) {e.raiseSalary(5);}//打印所有员工信息for (Employee e:staff ){System.out.println("name = " + e.getName()+", salary = " + e.getSalary()+ ", hireDay = " + e.getHireDay());}}
}

构造器

1.构造器与类同名
2.每个类可以有一个以上的构造器构造器可以有0个、1个或多个参数
3.构造器没有返回值
4.构造器总是伴随着new操作一起调用,所以它是静态方法

    //初始化雇员信息->构造器public Employee(String n, double s, int year, int month, int day) {this.name = n;this.salary = s;GregorianCalendar calendar = new GregorianCalendar(year, month - 1,day);this.hireDay = calendar.getTime();}

不要在构造器中定义与实例域重名的局部变量

    public Employee(String n, double s, int year, int month, int day) {String name = n;double salary = s;GregorianCalendar calendar = new GregorianCalendar(year, month - 1,day);Date hireDay = calendar.getTime();}

否则成员变量的值为默认值

隐式参数与显式参数

例如：

    public void raiseSalary(double byPercent) {double raise = salary * byPercent / 100;salary += raise;}

raiseSalary方法有两个参数。第一个参数称为隐式参数，是出现在方法名前的Employee类对象。第二个参数位于方法名后面括号中的数值，这是一个显式参数。可以看到，显式参数是明显地列在方法声明中的，例如 double byPercent。隐式参数没有出现在方法声明中。在每一个方法中，关键字this表示隐式参数。如

    public void raiseSalary(double byPercent) {double raise = salary * byPercent / 100;this.salary += raise;}

这样可以将实例域与局部变量明显地区分开来

封装的优点

    private String name;private double salary;private Date hireDay;

这里我们用private关键字修饰，为了防止被外界直接修改；但我们提供了单独的方法让我们能够获得或者修改的方法：例如：

    public String getName() {return name;}public double getSalary() {return salary;}public Date getHireDay() {return hireDay;}

通过类提供的方法，我们可以直接通过这个方法来修改，如果使public修饰的，那么在外界可以任意操作修改，但我们通过private修饰后只能通过其访问，这样发生错误后直接调试这个方法即可；

通常如果我们想要获得私有域的数据；应通过下面三种方法：

一个私有的数据域; private name;
一个公有的域访问器方法;getname();
一个公有的域更改器方法。setname();

注：

注意不要编写返回引用可变对象的访问器方法,例

class Employee {private Date hireDay;...public Date getGireDay() {return hireDay;}...
}

这样会破坏封装性，情况下面的代码：

Employee Tom = ...;
Date d = Tom.getHireDay();

这里的d和Tom.hireDay引用同一个对象，对d调用更改器方法就可以改变雇员的私有状态

如果我们需要返回一个可变对象的引用，应该首先对它进行克隆：

class Employee {private Date hireDay;...public Date getGireDay() {return hireDay.clone();}

this关键字

当形式参数和成员变量名称相同时，我们可以利用this关键字来指定成员变量

this.成员变量

    public Employee(String n, double s, int year, int month, int day) {this.name = n;this.salary = s;GregorianCalendar calendar = new GregorianCalendar(year, month - 1,day);this.hireDay = calendar.getTime();}

this(); 调用构造方法（只能调用一次且只能位于第一条语句）
this（形式参数…）;访问成员方法

final实例域

可以将实例域定义为final。构建对象时必须初始化这样的域。也就是说，必须确保在每一个构造器执行之后，这个域的值被设置，并且在后面的操作中，不能够再对它进行修改。例如，可以将Employee类中的name域声明为final，因为在对象构建之后，这个值不会再被修改，即没有setName方法。

静态域和静态方法

静态域和静态成员变量

如果将域定义为static，每个类中只有一个这样的域,而每一个对象对于所有的实例域却都有自己的一份拷贝。例如，假定需要给每一个雇员赋予唯一的标识码。这里给Employee类添加一个实例域id和一个静态域nextld:private static int nextId = 1;private int id;现在，每个雇员对象都有自己的id域，但这个实例域又共享同一个nextId域。在Java中，被static修饰的成员，称之为静态成员变量，也可以称为类变量，其不属于某个具体的对象，是所有对象所共享的。

静态成员变量特点：

不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
类变量存储在方法区当中
生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

静态方法

  静态方法 是一种  不能向对象实施操作  的方法，也叫做类方法。

例如：Math类的pow方法就是一个静态方法。表达式Math.pow(x,a).计算x的a次幂。在运算时不使用Math对象，也就是没有隐式参数。

因为静态方法不能操作对象，所以不能在静态方法中访问实例域。但是，静态方法可以访问自身类中的静态域。例如：

public static int getNextId() {  return nextId;
}

这里我们省略关键字static，但是要通过Employee类对象来引用调用这个方法，Employee.getNextId

在下面两种情况下使用静态方法:

一个方法不需要访问对象状态，其所需参数都是通过显式参数提供(例如:Math.pow)。
一个方法只需要访问类的静态域(例如:Employee.getNextId)。

实际上main方法就是静态方法，main方法不对任何对象进行操作。在启动程序时还没有任何一个对象。静态的main方法将执行并创建程序所需要的对象。

静态方法特性：

不属于某个具体的对象，是类方法
可以通过对象调用，也可以通过类名.静态方法名(…)方式调用，更推荐使用后者
静态方法没有隐藏的this引用参数，因此不能在静态方法中访问任何非静态成员变量(因为非静态变量依赖于对象)

class Person {private static int a;private int age;public static void setA(int a) {this.age = 10;//errorPerson.a = a;}
}

静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用

对象构造

前面我们已经知道如何用简单的构造器来初始化我们的定义的对象，但是，由于对象的构造十分重要，所以Java提供了多种编写构造器的方法。下面将详细介绍：

重载

在前面我们已经提到过重载的概念：如果多个方法有相同的名字、不同的参数便产生了重载。编译器必须挑选出具体执行哪个方法，它通过用各个方法给出的参数类型与特定方法调用所使用的值类型进行匹配来挑选出相应的方法。如果编译器找不到匹配的参数，或者找出多个可能的匹配，就会产生编译时错误(这个过程被称为重载解析)

注：

Java允许重载任何方法，而不只是构造器方法。因此，要完整地描述一个方法,需要指出方法名以及参数类型。这叫做方法的签名,例如，Arrays类有9个称为toString的公有方法。它们的签名是:

返回类型不是方法签名的一部分，也就是说没有两个相同名字和参数类型，却返回类型不同的方法。

默认域初始化

如果在构造器中没有对成员变量(也就是类中对象的变量)，那么会被自动化地赋为默认值，基本数据类型为0，布尔值为false，对象引用类型为null。

无参数地构造器

如果在编写一个类时没有编写构造器，那么系统就会提供一个无参数构造器。这个构造器将所有的实例域设置为默认值。于是，实例域中的数值型数据设置为0、布尔型数据设置为false、所有对象变量将设置为null。

显式域初始化

由于类的构造器方法可以重载,所以可以采用多种形式设置类的实例域的初始状态。确保不管怎样调用构造器，每个实例域都可以被设置为一个有意义的初值。

代码块

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：

普通代码块
构造块
静态块
同步代码块

普通代码块

定义在方法的代码块

public static void main(String[] args) {{ //直接使用{}定义，普通方法块int x = 10 ;System.out.println("x1 = " +x);
} int x = 100 ;System.out.println("x2 = " +x);
}

构造代码块

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。

class Employee {public static int nextId;//实例成员变量private int id;private String name;private double salary;//实例代码{id = nextId;nextId++;}
}

注：实例代码块优先于构造方法执行，因为编译完成后，编译器会将实例代码块中的代码拷贝到每个构造方法第一条语句前

静态代码块

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量

class Employee {public static int nextId;//实例成员变量private int id;private String name;private double salary;//实例代码{id = nextId;nextId++;}//静态代码块static {nextId = 1;}
}

注：

静态代码块不管生成多少个对象，其只会执行一次
静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次合并，最终放在生成的<>方法中，该方法在类加载时调用，并且只调用一次

Dog类

public class Dog {private String color;private String name;public static String Master;/*** 实例代码块*/{System.out.println("实例代码块，优先于构造代码块，落后于静态代码块！");}/*** 构造代码块*/public Dog(String color, String name) {this.color = color;this.name = name;System.out.println("构造代码块");}/*** 静态代码块 1*/static{Master = "Tom";System.out.println("静态代码块1");}/*** 静态代码块2*/static {Master = "Jack";System.out.println("静态代码块2");}
}

public class TestDog {public static void main(String[] args) {Dog dog = new Dog("黑色","Jack");System.out.println("--------");Dog dog1 = new Dog("粉丝","Tom");}
}

运行结果：

实例代码块只有在创建对象时才会执行

包

Java允许使用包将类组织起来。借助于包可以方便地组织自己的代码，并将自己的代码与别人提供的代码库分开管理。使用包的主要原因是确保类名的唯一性。假如两个程序员不约而同地建立了Employee类。只要将这些类放置在不同的包中,就不会产生冲突。

类的导入

一个类可以使用所属包中的所有类，以及其他包中的公有类。我们可以通过两种方法来访问另一个包中的共有类：

在每个类名之前添加完整的包名
java.util.Date today = new java.util.Date();
可以使用import语句导入一个特定的类或者整个包。import语句应该位于源文件的顶部(但位于package语句的后面)。例如：可以导入java.util包中所有的类。

import java.util.*;

也可以单独导入我们想要的包中的类，比如：

import java.util.Date;

注：

只能使用(*)导入一个包，而不能使用import java.*或者import java.*.*来导入前缀为java的所有包；
当导入包中类名冲突时，比如import java.uti1.*;import java.sq1.*;都有Date类，如果此时我们使用Date类，就会报错
这时候我们可以明确Date是哪一个包中的类：

如果我们两个类我们都需要使用呢？例如：只需要指定出

静态导入

import语句不仅可以导入类,还增加了导入静态方法和静态域的功能。例如，如果在源文件的顶部,添加一条指令:import static java.lang.System.*;就可以使用System类的静态方法和静态域,而不必加类名前缀: out.println("Hello world!");

把类放入包中

要想将一个类放入包中，就必须将包的名字放在源文件的开头，包中定义类的代码之前
如果没有在源文件中放置package语句，这个源文件中的类就被放置在一个默认包中。默认包是一个没有名字的包。

访问修饰符

Java中主要通过类和访问权限来实现封装： 类可以将数据以及封装数据的方法结合在一起， Java中提供了四种访问限定符：

公有访问修饰符-public

被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。

私有访问修饰符-private

被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。声明为私有访问类型的变量只能通过类中公共的 get 方法被外部类访问。

默认访问修饰符-不使用任何关键字

使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的

受保护的访问修饰符-protected

protected实际上是分为两部分：包内可见和子类可见

子类与父类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；
子类与父类不在同一包中：可以由继承来访问protected方法而不能直接访问protected方法

同一包下：

创建父类

package package1;public class Father {/**构造器，方法和成员变量我们都用protected修饰* */protected int a = 1;protected Father(int a) {this.a = a;}protected void fatherOut() {System.out.println("Father out " + a);}
}

创建子类

package package1;public class Son extends Father{public Son(int a) {super(a);}public void sonOut() {System.out.println("Son out" + a);//调用父类的afatherOut();                            //调用父方法}
}

3.在同一包下创建测试类

package package1;public class Test {public static void main(String[] args) {Father father = new Father(1);System.out.println("Test out" + father.a);father.fatherOut();System.out.println("===============");Son son = new Son(2);son.fatherOut();son.sonOut();}
}

运行结果：

结论：在同一包中，被protected修饰的变量、方法和构造器都可以被使用

不同包中

创建同样的父类

package package1;public class Father {/**构造器，方法和成员变量我们都用protected修饰* */protected int a = 1;public Father(int a) {this.a = a;}protected void fatherOut() {System.out.println("Father out " + a);}public void outA() {System.out.println("Father out" + a);}
}

在包2中创建子类Son1,并且继承包1的Father类

package package2;import package1.Father;public class Son1 extends Father {public Son1(int a) {super(a);}/** 直接使用父类的被pertected修饰的a变量和outA()方法* */public void son1Out() {System.out.println("Son1 out" + a);outA();}
}

3.在包2中创建Test1类，并且引入包1的父类

package package2;import package1.Father;public class Test1 {public static void main(String[] args) {Father father = new Father(1);  //实例化Father类//System.out.println(father.a); // protected修饰的a只能由子类调用//father.fatherOut();                //protected修饰的方法fatherOut()只能由子类调用System.out.println("----------------");Son1 son = new Son1(2);son.outA();                     //可以调用父类被pretected修饰的fatherOut()方法}
}