下五子棋{

    开始游戏（）；

    黑子先走（）；

    绘制画面（）；

    判断输赢（）；

    轮到白子（）；

    绘制画面（）；

    判断输赢（）；

    返回到 黑子先走（）；

    输出最后结果；

}

class Fruit{

	public double weight;

	public void info() {

		System.out.println("我是一个水果，重"+weight+"g");

	}

}

public class Apple extends Fruit{

	public static void main(String[] args) {

		//创建Apple对象

		Apple apple=new Apple();

		//Apple对象本身并没有weight成员变量

		//但是Apple的父类用于weight变量，所以Apple也可以方位

		apple.weight=88;

		apple.info();

	}

}

结果：我是一个水果，重88.0g

//父类

class Bird{

	public void fly() {

		System.out.println("我在天空自由的飞翔");

	}

}

public class Ostrich extends Bird {

	//重写Bird的fly方法

	public void fly() {

		System.out.println("我只能在地上奔跑");

	}

	public static void main(String[] args) {

		//创建Ostrich对象

		Ostrich ostrich=new Ostrich();

		ostrich.fly();

	}

}

结果：我只能在地上奔跑

class Animal{

	public Animal() {

		System.out.println("我是父类动物");

	}

}

class Humanity extends Animal{

	public Humanity() {

		System.out.println("我是父类人类");

	}

}

public class Student extends Humanity{

	public Student() {

		System.out.println("我是子类学生");

	}

	public static void main(String[] args) {

		Student student=new Student();

	}

}

import java.util.Arrays;

public class FinalTest {

	public static void main(String[] args) {

		//final修饰数组变量，arr只是一个引用变量

		final int[] arr= {3,90,33,12};

		System.out.println(Arrays.toString(arr));

		//对数组进行排序，合法

		Arrays.sort(arr);

		System.out.println(Arrays.toString(arr));

		//对数组元素进行赋值，合法

		arr[2]=109;

		System.out.println(Arrays.toString(arr));

		//下面语句对arr重新赋值，非法

		//arr=null;

	}

}

public class Student{

	String username;

	String password;

	public Student(String username,String password) {

		//this 代表当前对象 也就是下面的student

		this.username=username;

		this.password=password;

	}

	public static void main(String[] args) {

		Student student=new Student("jack","123");

	}

}

class Humanity{

	public void eat() {

		System.out.println("动物吃肉");

	}

}

public class Student extends Humanity{

	public void eat() {

		//super调用父类中的同名方法

		super.eat();

		System.out.println("人吃饭");

	}

	public static void main(String[] args) {

		Student student=new Student();

		student.eat();

	}

}

动物吃肉

人吃饭

class Humanity{

	public Humanity() {

		System.out.println("父类无参构造");

	}

	public Humanity(String s) {

		System.out.println("父类有参构造======"+s);

	}

}

public class Student extends Humanity{

	public Student() {

		super();//调用父类的无参构造方法

		System.out.println("子类无参构造");

	}

	public Student(String s) {

		super(s);//调用父类的有参构造

		System.out.println("子类的有参构造======"+s);

	}

	public Student(String username,String password) {

		this(username);//调用本类的有参构造

		System.out.println("子类带两个参数的构造函数======"+username+"======"+password);

	}

	public static void main(String[] args) {

		Student student=new Student();

		Student student2=new Student("小明");

		Student student3=new Student("小明","123");

	}

}

输出结果：

父类无参构造

子类无参构造

父类有参构造======小明

子类的有参构造======小明

父类有参构造======小明

子类的有参构造======小明

子类带两个参数的构造函数======小明======123

二、封装：

1、封装的概念与优点：

封装（Encapsulation）是面向对象的三大特征之一，它指的是将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，而是通过该类所提供的方法来实现对内部信息的操作和访问。

封装是面向对象编程语言对客观世界的模拟，在客观世界里，对象的状态信息都被隐藏在对象内部，外界无法直接操作和修改。就如刚刚说的Person对象的age变量，只能随着岁月的流逝，age才会增加，通常不能随意修改Person对象的age。对一个类或对象实现良好的封装，可以实现以下目的。

1. 隐藏类的实现细节。
2. 让使用者只能通过事先预定的方法来访问数据，从而可以在该方法里加入控制逻辑，限制对成员变量的不合理访问。
3. 可进行数据检查，从而有利于保证对象信息的完整性。
4. 便于修改，提高代码的可维护性。

为了实现良好的封装，需要从两个方面考虑。

1. 将对象的成员变量和实现细节隐藏起来，不允许外部直接访问。
2. 把方法暴露出来，让方法来控制对这些成员变量进行安全的访问和操作。

2、访问修饰符：

Java提供了3个访问修饰符：public、protected和private，另外还有一个默认的修饰符default，Java的访问控制级别如下图所示：

下面来详细介绍一下四个访问修饰符：

• private（当前类访问权限）：如果类里的一个成员（包括成员变量、方法和构造器等）使用private访问控制符来修饰，则这个成员只能在当前类的内部被访问。很显然，这个访问控制符用于修饰成员变量最合适，使用它来修饰成员变量就可以把成员变量隐藏在该类的内部。
• default（包访问权限）：如果类里的一个成员（包括成员变量、方法和构造器等）或者一个外部类不使用任何访问控制符修饰，就称它是包访问权限的，default 访问控制的成员或外部类可以被相同包下的其他类访问。关于包的介绍请看5.4.3节。
• protected（子类访问权限）：如果一个成员（包括成员变量、方法和构造器等）使用protected访问控制符修饰，那么这个成员既可以被同一个包中的其他类访问，也可以被不同包中的子类访问。在通常情况下，如果使用protected来修饰一个方法，通常是希望其子类来重写这个方法。
• public（公共访问权限）：这是一个最宽松的访问控制级别，如果一个成员（包括成员变量、方法和构造器等）或者一个外部类使用public访问控制符修饰，那么这个成员或外部类就可以被所有类访问，不管访问类和被访问类是否处于同一个包中，是否具有父子继承关系。

掌握了访问修饰符后，我们就可以来使用封装了。

public class Person {

	private String username;

	private Integer age;

	public String getUsername() {

		return username;

	}

	public void setUsername(String username) {

		this.username = username;

	}

	public Integer getAge() {

		return age;

	}

	public void setAge(Integer age) {

		this.age = age;

	}

}

上述代码Person类中有两个成员变量username和age，它们都是私有变量，外部不能访问，但是提供了get和set方法，通过这两个方法便可以修改和获取Person类中的相关数据，这就是封装

3、java中的包是什么？

记得我上初中的时候，班级有两个同名的同学，都叫王健，老师每次叫王健的时候他俩不知道叫的是谁，后来加上性别区分，一个叫男王健，一个叫女王健，这次区分开。

那么我们在java中会不会遇到这种情况呢？当然会，比如就Person这个类而言，在一个大型项目中，多人协作开发，你写了一个类叫Person，我也写个类叫Person，那么该如何区分这两个类呢？总不能一个叫男Person，一个叫女Person吧，哈哈。这时候java就引入了包的机制，允许在类名前面加上一个前缀来限制这个类，提供了类的多层命名空间

注意：

1、package语句必须作为源文件的第一条非注释性语句，一个源文件只能指定一个包，即只能包含一条package语句，该源文件中可以定义多个类，则这些类将全部位于该包下。

2、如果没有显式指定package语句，则处于默认包下。在实际企业开发中，通常不会把类定义在默认包下，但本书中的大量示例程序为了简单起见，都没有显式指定package语句。

3、同一个包下的类可以自由访问

三、多态：

1、多态的概念：

多态是指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）

2、多态的作用：

消除类型之间的耦合关系。

3、多态产生的条件：

　　1、要有继承；

　　2、要有重写；

　　3、父类引用指向子类对象。

4、多态的优点：

1、可替换性（substitutability）。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。

2、可扩充性（extensibility）。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。

3、接口性（interface-ability）。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。如图8.3 所示。图中超类Shape规定了两个实现多态的接口方法，computeArea()以及computeVolume()。子类，如Circle和Sphere为了实现多态，完善或者覆盖这两个接口方法。

4、灵活性（flexibility）。它在应用中体现了灵活多样的操作，提高了使用效率。

5、简化性（simplicity）。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。

 Java中多态的实现方式：接口实现，继承父类进行方法重写，同一个类中进行方法重载。

5、经典的多态案例：

class Animal{

	public void eat() {

	}

}

class Cat extends Animal

{

	public void eat()

	{

		System.out.println("吃鱼");

	}

	public void catchMouse()

	{

		System.out.println("抓老鼠");

	}

}

class Dog extends Animal

{

	public void eat()

	{

		System.out.println("吃骨头");

	}

	public void kanJia()

	{

		System.out.println("看家");

	}

}

public class AnimalTest {

	 public static void main(String[] args) {

		Animal cat=new Cat();//向上转型

		cat.eat();

		Animal dog=new Dog();

		dog.eat();
　　　　　　　　　 //Cat c=(Cat)cat;//向上转型

	}

}

Animal是父类，它有两个之类分别是Dog和Cat，之类分别重写了父类的eat方法。

输出结果：

吃鱼

吃骨头

从输出结果可以看出，同样都是Animal，但是却有不同的行为表现，这就是多态

6、向上转型和向下转型：

1、向上转型：就以上述的父类Animal和一个子类Dog来说明，当父类的引用可以指向子类的对象时，就是向上类型转换：Animal cat=new Cat();

2、向下转型：向下类型转换(强制类型转换)，是大类型转换到小类型(有风险,可能出现数据溢出)。例如：Cat c=(Cat)cat

7、重写和重载：

重写：父类与子类之间的多态性，对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。

重载：方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。重载是一个类中多态性的一种表现。

重载发生在一个类当中，重写发生在两个类当中，但是这两个类是父子类的关系。