面向对象

一、面向对象
　　1、什么是面向对象、什么是面向过程
　　　　面向对象是基于面向过程优化而来的。
　　　　面向过程：强调的是过程，也就是完成功能的每一个步骤都需要自己来实现！
　　　　面向对象：强调的是对象，由对象帮助我们完成具体的功能！
　　举例：吃烤鸭
　　面向过程：买一只小鸭子--买一些饲料--开始养--养大了--杀死--拔毛--煮熟--烤一烤--开吃
　　面向对象：去全聚德买一份烤鸭--开吃

　　2、通过举例总结面向对象的特点：
　　　　A.更符合人们思想习惯的思想(懒人思想)
　　　　B.将复杂的事情简单化
　　　　C.将程序员由执行者变成了指挥者

二、类与对象
1、　　A：什么是类：
　　　　物以类聚，类是一种抽象的泛泛的概念
　　　　　比如说：动物类、水果类、汽车类~~
　 　B：什么是对象：
　　　　对象是某一类事物的一个具体的体现
　　　　比如说：动物类中的猫就是一个动物中的具体的对象
 　　C：属性：
　　　　属性对应成员变量
　　　　属性就是某一个事物中的具体描述信息
　 　D：行为：
　　　　行为对应成员方法
　　　　行为就是某一个事物中可以做哪些事情

2、使用类：

　　　　A：创建对象
　　　　　　类名 对象名 = new 类名();
　　　　B：使用成员变量
　　　　　　对象名.成员变量;
　　　　C：使用成员方法
　　　　　　对象名.成员方法();

3、内部类

　　　　分类：成员内部类 局部内部类 匿名内部类

　　　　1、成员内部类：一个类的内部再创建一个类(Outer.Inner i = new Outer().new Inner();)

public static void main(String[] args) {
        Person.Hert h = new Person().new Hert();
        h.jump();
    }
}
class Person{
    String name = "王外";
    class Hert{
        String name = "晨内";
        public void jump(){
            String name="张内法";
            System.out.println(Person.this.name+" 心脏在跳动！");//王外
            System.out.println(this.name+" 心脏在跳动");//晨内
            System.out.println(name+" 心脏在跳动");//张内法
        }
    }

　　　　2、局部内部类:一个类的方法里再创建一个类(出了这个方法这个局部内部类就消失了)

　　　　3、匿名内部类：一个没有名字的局部内部类(new 类/接口(){//重写方法};可将匿名内部类看成一个对象来处理。

　　

public class NinameTest03 {

    public static void main(String[] args) {
　　//创建匿名内部类
        new Inter(){
            @Override
            public void print() {
                System.out.println("打印");
            }
        }.print();

        创建匿名内部类
        Abclass a = new Abclass() {
            @Override
            public void eat() {
                System.out.println("eat");
            } 
            @Override
            public void drink() {
                System.out.println("drink");
            }
        };
        a.eat();
        a.drink();        
    }

}
//创建接口
interface Inter{
    public abstract void print();
}
//创建抽象类
abstract class Abclass{
    public abstract void eat();
    public abstract void drink();
}

结果：

三、构造方法
　　1.空参构造方法的格式：
　　public 方法名() {
　　}
　　2.构造方法的注意事项：
　　　　A：如果构造方法不写，那么系统会提供一个默认的空参构造方法
　　　　B：如果我们给出任意的有参构造方法，那么系统就不再提供空参构造了
　　3.两种方式为成员变量赋值
　　　　A:setXxx();
　　　　B:有参构造方法;

四、面向对象的三大特征：
　　1.封装
　　　　封装就是将不需要对外开放的成员隐藏起来。仅对外提供公共的访问方式。
　　　　封装可以提高代码的安全性和维护性
　　2.继承
　　　　继承就是让类与类之间产生了子父类关系。
　　　　java中继承的特点：只支持单继承，但是可以多层继承！

　　　　继承的好处和弊端：
　　　　　　好处就是提高了代码的复用性。如果发现问题了，直接将父类进行修改。那么所有的子类中的问题也会随之解决
　　　　　　弊端就是耦合性太强了。如果父类中出现了一个子类不需要的功能，那么根据继承的特点，子类也会具备该功能

　　　　继承也属于封装的一种体现形式
　　　　　　子类只能继承父类中的非私有成员。对于子类中成员访问的顺序。要根据就近原则来使用
　　　　　　　　如果子类中有局部变量，优先使用子类的局部变量。
　　　　　　　　如果子类中没有局部变量，但是有成员变量，那就使用子类成员变量
　　　　　　　　如果子类中既没有局部变量，也没有成员变量。那么就使用父类的成员变量。如果父类也没有，就报错了

　　　抽取父类的原则：将子类中的共性功能进行向上抽取。然后由子类去继承父类
　　　　　　但是有的时候，向上抽取出的共性功能，并不能满足具体的需求，所以父类中的功能就不能有方法体。
　　　如果没有方法体的方法，我们就要声明为抽象的，从而这个类也必须声明为抽象类。由子类继承父类，去强制重写抽象方法。重写后的就可以满足具体的需求了
　　　　　　但是抽象类的设计初衷，是抽取一些共性的功能，但是还有一些子类中的特性功能，这个时候我们就可以使用接口来定义这些特性的功能

　　　接口可以打破java中单继承的弊端，因为接口可以多实现。还可以在继承一个类的同时，实现多个接口。

注：接口和抽象类的区别：
                成员区别
                    成员变量：
                        接口中只有常量
                        抽象类中既可以有常量，也可以有变量
                    成员方法：
                        接口中只有抽象方法
                        抽象类中既可以有抽象方法，也可以有非抽象方法
                    构造方法：
                        接口中没有构造方法
                        抽象类中有构造方法
                        接口和抽象类都不能创建对象
                关系区别：
                    接口和类之间是实现关系。一个类可以实现多个接口，还可以在继承一个类的同时实现多个接口
                    接口和接口之间是继承关系，既可以单继承、也可以多继承
                    抽象类也属于类，类与类之间是单继承关系。不能多继承、可以多层继承
                设计思想：
                    抽象类完成的是一些共性的功能
                    接口完成的是一些特性中的共性的功能

　　3.多态
　　　　A:多态的前提：
　　　　　　继承或者实现关系
　　　　　　要有方法的重写
　　　　　　要有父类引用指向子类对象
　　　　B:多态的成员特点：
　　　　　　成员变量：编译看父类，运行也看父类
　　　　　　成员方法：编译看父类，运行看子类
　　　　　　静态方法：编译看父类，运行也看父类
　　　　C:多态的好处和弊端：
　　　　　　好处：
　　　　　　　　提高了代码的复用性(由继承来保证)
　　　　　　　　提高了代码的扩展性(由多态本身保证)
　　　　　　弊端：
　　　　　　　　不能使用子类特有的成员。如果想使用，需要使用instaceOf关键字进行类型匹配，从而向下转型使用子类特有功能
　　　　D:多态的使用场景：
　　　　　　一般用于方法的参数传递或者方法的返回值使用。
　　　　　　如果一个方法中参数使用的是父类类型，那么调用该方法，就可以传递任意该父类的子类类型对象
　　　　　　如果一个方法中返回值使用的是父类类型，那么调用该方法，方法中就可以返回任意该父类的子类类型对象

　　

public class Duo {
    
    public static void main(String[] args) {
        Dad d = new Kid();
        System.out.println(d.num);
        
        d.method();
        d.function();
    }
}
    //创建父类
    class Dad{
        int num=12;
        
        public void method(){
            System.out.println("我是父类的方法");
        }
        
        public static void function(){
            System.out.println("我的父类的静态方法");
        }
    }
    
    //子类继承父类
    class Kid extends Dad{
        int num=11;
        public void method(){
            System.out.println("我是子类的方法");
        }
        
        public static void function(){
            System.out.println("我是子类的静态方法");
        }
    }

　结果：