目录
面向对象(OOP)
类（class）
对象
对象的特点
面向对象优点
面向对象三大特征
封装（Class+修饰符封装代码）
继承（子类继承父类的代码）
向上转型
向下转型
多态（同一种行为，多种代码实现）
面向对象(OOP)
对于Java来说，万物皆对象，就是把现实生活中的事务抽象的体现在编程中。只要是你想得到的，无论是实体，还是虚拟的事务。都可以称之为对象。这也意味着Java可以把任何形式的内容转化为编程语言进行开发。
类（class）
Java把我们现实生活中一个个具体的"物体"所具有的特征及行为抽象出来，并且将各种具有相同特征的"物体"分为一个个的"类（class）",这就是我们为每一事物所起的名字。例如：汽车，武器，动物，植物等。
对象
类是作为对象的抽象而存在的，所有的对象都是依据相应的类而产生。产生对象的过程称为“实例化”。对象中，有两种特征内容：
数据：数据就是描述对象信息的静态信息。例如：一辆汽车的生产日期及型号等。
行为：行为就是这个对象可以完成的动作或操作。例如：汽车的启动，刹车等。
对象的特点
1、对象具有属性（数据）和方法（行为）。
2、对象具有变化的状态。
3、对象具有唯一性。
4、对象都是某个类别的实例。
5、一切皆为对象，真实世界中的所有事物都可以视为对象。
面向对象优点
1、可复用性：代码重复使用，减少代码量，提高开发效率。
2、可扩展性：新的功能可以很容易加入系统中，便于软件的修改。
3、可管理型：能够将功能与数据结合，方便管理。
面向对象三大特征
访问修饰符：
public： 修饰的属性或方法外部类中，都可以直接访问。
protected： 修饰的属性或方法在同一个包中的其他类可以访问，同时对于不在同一个包中的子类也可以访问。
default： 修饰的属性或方法具有包访问特性，同一个包下的其他类可以访问。
private： 修饰的属性或方法为该类所持有，在任何其他类中都不能直接访问。
封装（Class+修饰符封装代码）
把数据和函数包装在一个单元中的行为叫做封装。在一个对象内部，为了避免外界的干扰和不确定性。某些代码或数据是可以设置成私有的，不被外界访问。通过这种方式，对象对内部数据提供了不同级别的保护，这样可以防止程序中无关的部分数据意外改变或使用了对象的私有部分。
实现步骤：
1、使用private关键字修饰
2、提供get方法----用来获取值
提供set方法----用来设置值
package zero;
import java.util.Arrays;
public class TestPrivatae {
public static void main(String[] args) {
// 创建对象修改属性值
User u = new User();
u.name = "零 壹";
System.out.println(u.name);
// u.money = 999999999;
// System.out.println(u.money);
// 调用查看余额的方法,获取money的值,并打印在控制台
System.out.println(u.getMoney());
//调用设置余额的方法，设置余额为9999999
u.setMoney(9999999);
// 设置完提供获取
System.out.println(u.getMoney());
}
}
// 创建一个用户类
class User{
// 定义用户类的属性
public String name;//姓名
// 为了更安全的操作余额，修改money的修饰符为private
private double money = 10000;//账户余额
// 提供公共的方法供外界调用，方法的功能：获取余额
public double getMoney(){
return money;
}
public void setMoney(double newMoney){
money = newMoney;
}
//提供公共的方法供外界调用，方法的功能：获取余额
}
继承（子类继承父类的代码）
本质就是代码重用。父类称为基类，子类称为派生类。
继承就是从已有的类派生出一个新的类，新的类会继承已有类的属性及方法，并且可以扩展新的功能。例如：学校主要人员是一个大的类别，老师和学生是学校主要人员的两个子类，而老师又可以分为语文老师和数学老师两个子类，学生也可以分为班长和组长两个子类。使用这种层次型的分类方式，是为了将多个类的通用属性和方法提取出来，放在它们的父类中，然后只需要在子类中各自定义自己独有的属性和方法，并以继承的形式在父类中获取它们的通用属性和方法即可。
注意：
1、使用extends关键字
2、Java支持单继承
3、继承可以传递（就像爷爷---儿子---孙子这样的关系）
4、父类的私有方法，子类不能继承（就像父亲的正常财富可以被儿子继承，但是父亲的小金库，儿子看不到也无法继承。）
5、子类继承父类的方法后，可以对父类方法进行拓展（例如：儿子继承父亲的财富后，还可以自己去赚钱）
6、继承就是is-a的关系
package zero;
public class ExtendsDemo1 {
public static void main(String[] args) {
// 创建子类的匿名对象
new Son().study();
}
}
// 创建父类
class Father{
// 创建父类的成员变量
int sum = 1;
int count =2;
}
/2 创建子类
class Son extends Father{
// 创建子类的成员变量
int sum =10;
// 创建子类的普通方法
public void study(){
System.out.println("good good study,day day up");
// 创建子类的局部变量
int sum =100;
// 打印子类的局部变量sum
System.out.println(sum);
// 打印子类的成员变量sum
System.out.println(this.sum);
System.out.println(super.sum);
}
}
向上转型
通过子类对象(小范围)实例化父类对象(大范围),这种属于自动转换
package com.sheepmu;
class Animal
{
public void eat()
{
System.out.println("父类的 eating...");
}
}
class Bird extends Animal
{
@Override
public void eat()
{
System.out.println("子类重写的父类的 eatting...");
}
public void fly()
{
System.out.println("子类新方法 flying...");
}
}
public class Sys
{
public static void main(String[] args)
{
Animal b=new Bird(); //向上转型
b.eat();
// b.fly(); //会报错。b虽指向子类对象。但此时子类作为向上的代价，丢失了父类没有的fly()方法
sleep(new Male());
sleep(new Female());//传入的參数是子类-----！
！
}
public static void sleep(Human h) //方法的參数是父类------！。。
{
h.sleep();
}
}
package com.sheepmu;
public class Human
{
public void sleep()
{
System.out.println("父类人类 sleep..");
}
}
class Male extends Human
{
@Override
public void sleep()
{
System.out.println("男人 sleep..");
}
}
class Female extends Human
{
@Override
public void sleep()
{
System.out.println("女人 sleep..");
}
}
向下转型
通过父类对象(大范围)实例化子类对象(小范围),这种属于强制转换
package zero;
class Fruit
{
public void myName()
{
System.out.println("我是父类 水果...");
}
}
class Apple extends Fruit
{
@Override
public void myName()
{
System.out.println("我是子类 苹果...");
}
public void myMore()
{
System.out.println("我是你的小呀小苹果~~~~~~");
}
}
public class one{
public static void main(String[] args) {
Fruit a=new Apple(); //向上转型
a.myName();
Apple aa=(Apple)a; //向下转型,编译和执行皆不会出错(正确的)
aa.myName();//向下转型时调用的是子类的
aa.myMore();;
Fruit f=new Fruit();
Apple aaa=(Apple)f; //-不安全的---向下转型,编译无错但会执行会出错
aaa.myName();
aaa.myMore();
}
}
多态（同一种行为，多种代码实现）
多态性是面向对象编程中的一个重要特性，主要是用来实现动态联编的。换句话说，就是程序的最终状态只有在执行过程中才被决定，而非在编译期间就决定了。这对于大型系统来说能提高系统的灵活性和扩展性。多态允许相同类域的不同对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法，从而实现更加灵活的编程，提高系统的可扩展性。如果对象的编译时类型和运行时类型不一致，就会造成多态。
注意：
1、在面向对象编程中，多态是指同一个操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。
2、相同的行为，不同的实现。
3、多态的前提是：继承
4、多态的前提是：要有方法的重写与重载
重写：子类和父类，父子关系，子类重新实现父类中同名方法。
重载：同一个类中，兄弟方法，方法名相同，参数个数、类型、顺序不同。
5、@Override 标记到重写的方法上。
6、多态中，编译看左边，运行看右边。
package zero;
public class one {
public static void main(String[] args) {
Animal a = new Animal();
Dog d = new Dog();
d.eat();
System.out.println(d.sum);
Animal a1 = new Dog();
System.out.println(a1.sum);
a1.eat();
a.play();
a1.play();
}
}
//创建父类
class Animal{
int sum = 10;
public void eat(){
System.out.println("我是eat");
}
public static void play(){
System.out.println("我是play");
}
}
class Dog extends Animal{
int sum =20;
@Override
public void eat(){
System.out.println("小狗爱吃骨头");
}
// @Override
public static void play(){
System.out.println("小狗喜欢玩皮球");
}
}
