一、面向对象
面向对象 ： 就是一种编程思想
1、类和对象
类是指描述一类事物，或者看成是一个分类，可以把类看作构造对象的模板。
对象是指具体的个体（也叫实例-instance）。创建对象使用 new，没对象就 new 一个对象。
1、设计类
语法：
1 class 类名{ 2 成员变量 (字段) 3 方法 （具体的一个功能行为） 4 }
类规范书写：
①类名首字符大写;
②类名必须具有意义;
③必须写注释；
1 public class Car { 2 String name; //字段 3 Integer price; 4 5 void run(){ //方法，具体行为 6 System.out.println("run"); 7 } 8 }
2、构造方法
创建对象本质上是调用类的构造方法。
1 public class Car { 2 String name; //字段 3 Integer price; 4 5 void run(){ //方法，具体行为 6 System.out.println("run"); 7 } 8 9 //构造方法，无参构造方法 10 public Car() { 11 } 12 }
特点：
1、每一个类中都至少有一个构造方法；如果没有看到（显示的），那么存在一个隐式的无参数的构造方法；如果一个类中有显示的构造方法，那么隐式的就不存在了。
2、构造方法的名字和类名一致（包括大小写完全一致）。
3、没有返回值类型，构造方法内部不需要返回任何的数据。
4、其他的和普通方法类型 ，可以有修饰（public）,可以有形参列表，可以有方法体。
5、在创建对象的同时给对象的字段赋值，有参数的构造方法的作用。
6、构造器总是伴随着new操作一起调用的。
1 public class Car { 2 String name; //字段 3 Integer price; 4 5 void run(){ //方法，具体行为 6 System.out.println("run"); 7 } 8 9 //构造方法 10 public Car() { 11 } 12 13 //有参构造方法 14 public Car(String name, Integer price) { //在创建对象的同时给对象的字段赋值 15 this.name = name; 16 this.price = price; 17 } 18 }
3、封装
在面向对象程式设计方法中，封装是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法（数据隐藏）。
在Java 中的体现
1 把类中的字段（实例域）私有化；
2 给每一个字段都提供一组getter， setter方法 (方法的规范写法)；
3 在测试类中尝试创建对象,并通过调用getter setter方法完成对字段的赋值和取值；
优点：
适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。减少耦合。类内部的结构可以自由修改。可以对成员变量进行更精确的控制。隐藏信息，实现细节。
1 public class Student { 2 private String name; //私有化字段 3 private Integer age; 4 5 //getter和setter方法 6 public String getName() { 7 return name; 8 } 9 10 public void setName(String name) { 11 this.name = name; 12 } 13 14 public Integer getAge() { 15 return age; 16 } 17 18 public void setAge(Integer age) { 19 this.age = age; 20 } 21 }
this介绍：
当setter方法，里面参数名称都一样的时候，就选择就近原则；使用this。
4、继承
1、具体实现
提高了代码的维护性和复用性，并且让代码更加简洁。
Java类中的继承的语法格式：
1 class A{ } 2 3 class B extends A{ }
A 是 B 的父类，B 是 A 的子类。子类中可以继承父类的东西。
1 /** 2 * 父类 3 */ 4 public class Animal { 5 6 public void move(){ 7 System.out.println("move"); 8 } 9 10 }
子类，非私有字段和方法可以被继承到。构造方法不能被继承。
1 /** 2 * 子类 3 */ 4 public class Cat extends Animal { 5 6 @Override 7 public void move() { 8 super.move(); //super关键字：通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。 9 } 10 }
Java中只能是单继承，即一个类只有一个父类；但支持多重继承（多层继承），即一个类可以有子类,子类还可以子类... 子子孙孙无穷无尽...
2、方法的重写（Override）
方法重写的要求：
1、子类和父类的方法签名（方法名+方法参数列表）一致。
2、子类的访问权限不能比父类更低。
3、最好加上@Override，来让编译器检查是否重写正确。
4、私有方法和 static 方法不能被重写。
5、子类的返回值类型可以和父类相同或者是父类返回类型的子类。
1 /** 2 * 子类 3 */ 4 public class Cat extends Animal { 5 @Override 6 public void move() { 7 System.out.println("move on"); //重写父类方法 8 } 9 10 }
5、接口
接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
声明语法：
interface 接口名{ // 内部可以有哪些成员--参考类 字段 全部都是全局常量（public static final修饰） 方法 全部都是抽象方法（缺省修饰public abstract） 构造方法 没有！ }
接口名一般加个大写的 I 在前面。
1 public interface IAnimal { 2 3 void run(); 4 5 void eat(); 6 }
使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。
注意：
1、必须全部覆写接口中的抽象方法。
2、否则实现类也抽象类。
3、一个类可以实现多个接口，但必须重写所有接口中的抽象方法。
1 public class AnimalImpl implements IAnimal { 2 @Override 3 public void run() { 4 System.out.println("run"); 5 } 6 7 @Override 8 public void eat() { 9 System.out.println("eat"); 10 } 11 }
6、多态
多态是同一个行为具有多个不同表现形式或形态的能力。即同一个事件发生在不同的对象上会产生不同的结果。
多态的优点：
1. 消除类型之间的耦合关系
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化性
多态存在的三个必要条件
1、继承
2、重写
3、父类引用指向子类对象
1 /** 2 * 父类 3 */ 4 public class Animal { 5 public void eat() { 6 System.out.println("吃东西"); 7 } 8 } 9 10 /** 11 * 子类 12 */ 13 class Cat extends Animal { 14 public void eat() { 15 System.out.println("猫吃鱼"); 16 } 17 18 public void work() { 19 System.out.println("猫抓老鼠"); 20 } 21 } 22 23 class Dog extends Animal { 24 public void eat() { 25 System.out.println("狗吃骨头"); 26 } 27 public void work() { 28 System.out.println("狗看家"); 29 } 30 } 31 32 class Person extends Animal { 33 public void eat() { 34 System.out.println("人吃东西"); 35 } 36 public void work() { 37 System.out.println("人努力工作"); 38 } 39 }
测试多态：
1 public class Test { 2 public static void main(String[] args) { 3 Animal a = new Cat(); // 向上转型 4 a.eat(); // 调用的是 Cat 的 eat ：首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。 5 Cat c = (Cat)a; // 向下转型，强制转换 6 c.work(); // 调用的是 Cat 的 work 7 8 Animal b = new Dog(); 9 b.eat(); 10 Dog d = (Dog)b; 11 d.work(); 12 13 Animal person = new Person(); 14 person.eat(); 15 Person p = (Person)person; 16 p.work(); 17 18 /* 输出： 19 猫吃鱼 20 猫抓老鼠 21 狗吃骨头 22 狗看家 23 人吃东西 24 人努力工作*/ 25 } 26 }
多态的实现方式
1、重写
2、接口
3、抽象类和抽象方法
