面向对象【三大特性】

封装

 安全隐患:

属性不私有化(可以直接操作成员属性,就有可能出现不合规范[不安全]的情况)  

{ Student01 stu=new Student01("张三",10,"男");

      //直接操作成员属性-->赋值

      stu.name="季凤萍";

      //stu.age=-5;}  

属性私有化关键字:

          Private私有的---à成员修饰符

      如果一个成员属性一旦私有,只能在当前类中使用,其他的类无权访问|操作    [private int age;]

  属性一旦私有:

需要提供公共的访问方式  设置器(设置私有属性的值)setter  访问器(获取私有属性的值)getter-->(方法)

快捷键: //alt+shift+s-->r-->tab-->enter-->shift+tab-->enter

{ //age的设置器

      //返回值:不需要     参数:需要

      public void setAge(int age){

           if(age>0 && age<=150){

                 this.age = age;

           }else{

                 System.out.println("年龄不合法!!!");

       }

      //age的访问器

      //返回值:需要 返回值int age            参数:不想要

      public int getAge(){

           return age;

      }}

    私有状态下相对较安全:

            1.属性不允许直接操作        2.间接操作在方法中可以进行逻辑判断

    以后定义模板类中所有的属性都私有,提供公共的访问方式

          面向对象的三大特性:

  封装    继承    多态

                     封装:

隐藏内部的实现细节,对外提供公共的访问方式

         私有是封装,(同样方法和类也是封装体现),所以我们可以说私有是封装,但是不能说封装是私有(因为它不仅仅是私有)

          封装的优点:

                    提高代码的安全性

                    提高代码的复用性

 javabean :指代一系列的模板类|实体类

 标准的javabean类符合开发要求:

                     1)类应该是公共的

                     2)至少存在一个空构造

                     3)私有的属性

                    4)提供公共的访问方式 setter  getter

继承:

       子承父业, exteds(继承+扩展)

       类:

一系列对象的共性-->对对象的抽象

父类:

 一些列类的共性 -->对类的抽象

为什么用到继承:

1. 提高代码的复用性
2. 子类一单继承父类,就可以拥有父类中的内容
3. 子类中可以定义自己独有的功能{扩展}

一类父类可以被多个子类继承,但是一个子类只能继承一个父类,java是单继承机制,但是可以多实现

  能够修饰类的修饰符:public | default (默认)

单继承的优点:

  使用简单

缺点:

  不便于后期维护

面向对象的原则之一:

  开闭原则{对修改关闭,对扩展开放}

权限修饰符:

      对访问对象成员权限的限定范围

  本类                 同包类          不同包子类         不同包其它类

ptivate                  Y   

default(默认)        Y           Y

protected              Y           Y                  Y

public                   Y           Y                  Y                  Y

1. 成员修饰符,只能修饰成员,不能修饰局部
2. 类的权限修饰符:public  default(默认的)
3. 私有内容不能被继承,静态内容可以被继承

使用protected修饰的内容:

1. 同包类
2. 不同包的字类中,通过继承关系使用

重写和重载区别:

          都是指的方法 只有方法才有重写和重载的特性

重载:

1. 同一个类中
2. 多个方法名相同
3. 参数列表不同或者也可以说是方法签名(方法名+参数列表:   区分方法的唯一)

重写:

1. 不同的类(才能称为是方法的重写)
2. 方法的重写基于-à类的继承或者是接口的实现
3. 子父类中方法签名相同的情况下(才能称之为方法的重写)

作用:

       继承中自雷拥有自身的特殊功能需要重写父类中的方法,子类一旦重写父类中的方法,子类对象调用的是子类中重写的方法,同时对父类的同名方法进行屏蔽

如何判断方法是否重写:

1. 左侧出现向上的三角形
2. 注解    Override @注解名

不能被重写的情况:

1. 被private修饰的方法不能被重写
2. 被final修饰的方法不能被重写
3. 被static修饰的方法不能被重写

如果子类中定义一个方法,在它的父类中有同名(方法签名)的静态方法,子类中的这个方法也必须是静态的

重写的要求:

         ==:方法签名必须完全相等

         <=:返回值类型: 基本数据类型必须相等, 引用数据类型:子类的返回值类型<=父类的返回值类型

         >=:子类重写方法的权限修饰符必须>=父类中这个方法的权限修饰符

super 和   this 之间的区别:

              this:指代当前new的对象

             super: 指代父类对象

调用父类构造器: 在子类构造器首行调用父类中的某个构造器

       super(参数列表);

       如果没有显示调用,默认在*首行*调用父类空构造,如果一旦显示调用,就不会默认调用父类空构造器了

       为什么要显示调用父类的其他构造器:

                             1.父类没有空构造

                            2.简化代码

首行调用构造器:super和this不能同时存在,因为都要在首行

           如果存在this(),会在this调用的构造器首行调用父类构造器

创建对象:  先父类后子类

 初始化: 先静态后成员

Final:

       final :最终的

       final修饰的变量为常量

       final修饰的方法不能被重写

              final修饰的类不能被继承(太监类)

Object类:

      所有类的父类

              Object:又称父类|超类|基类[被继承的类]

              子类|派生类  : 继承他人的类

             在Java里边所有的类都默认直接或者间接的继承自object类

             Java是单继承,如果没有显式继承其它类,会默认继承object

             关注toStirng()方法,equals()方法

  1.toString() 把对象以字符串的形式打印

             在打印对象的应用时,默认调用这个对象的toString()

         如果打印对象时想要显示对象的基本信息|所有成员属性的值,去对应类中重写toString()方法

 2.equals() 和 ==的区别:

           == 比较值|对象的地址是否相等

            equals 如果使用的是Object类中的方法,比较的还是对象的地址

              public boolean equals(Object obj) {

                      return (this == obj);

            }

                 如果子类有自定义的比较规则,先要根据内容(成员属性的值)比较对象是否相等,可以在子类中重写equals()方法

    String等类已经重写了equals()方法,比较对象的内容,

如果是自定义类,需要程序员自己重写:

                          //重写equals方法,比较对象的年龄,如果年龄相等,就是一个Person对象,应该返回true

             @Override

             public boolean equals(Object obj) {

              //增强程序健壮性  如果对象的地址都相同,就是一个对象

              if (this == obj) {

                                  return true;

                             }

                  return this.id == ((Person)obj).id;

                            }

          //要求根据id,name,age,gender所有成员属性的值比较Person对象是否相等

多态:

          多态:一种事物的多种形态|多种表现形式

            类的多态,接口多态

 多态的最终体现:

                           父类引用指向子类对象

//Student s=new Student();

  多态的前提:

                                         继承关系

                        多态的使用:

                       父类引用会调用子类中重写的内容

                       父类引用对子类新增方法不可见

                         多态的特点:

                        提高代码的复用性,使程序变得更灵活并且开发简单

  多态使用成员:

                        成员变量: 编译运行找父类|看左边|找类型

                        成员方法: 编译看父类|类型|左边,运行找对象|子类|右边

              转型:

                                          基本数据类型:  自动类型提升   强制类型转换-->小范围类型 引用 = (小范围类型 )大范围类型;

                                              引用数据类型:  向上转型         向下转型          大范围: 父类|父接口    小范围:子类|实现类

                        转型:

                                           基本数据类型:  自动类型提升   强制类型转换-->小范围类型 引用 = (小范围类型 )大范围类型;

                                               引用数据类型:  向上转型       向下转型          大范围: 父类|父接口    小范围:子类|实现类

抽象类【abstract】:

                            被abstract修饰的类就是抽象类

                                   被abstract修饰的方法就是抽象方法:{

                                             没有方法体的方法(称之为抽象方法)

                                            // public abstract void work();

                                            如果一个类中存在抽象方法,那么这个类必须为抽象类}

                                   模拟公司开发部门:

                                         java开发工程师    work()

                                        web              work()

                                          Develop 开发部  work()

                                            像这种不知道该如何定义方法体的情况下,我们选用抽象方法!

抽象类的特点:

1. 抽象类不能被实例化
2. 存在抽象方法的类,必然是抽象类
3. 抽象类中不仅仅可以存在抽象方法,同时也可以存在具体方法
4. 抽象方法必须被重写
5. 抽象类中的内容使用:
   1. 具体的子类:重写父类中的所有抽象方法+按需新增
   2. 抽象子类:按需重写抽象方法+按需新增

 6.抽象方法一旦重写不需要再次重写,但是可以      按需重写

7.abstract不能和final ,static, private,native一起使用

选择父类:

    具体父类

    抽象父类

接口***: interface定义接口,实现接口implements
 理解特殊的抽象类

 接口的优点:
                      1.接口可以多实现,只能单继承
                       2.解耦 (高内聚低耦合)
                      3.定义开发规范
                      4.提高代码的复用性

接口的特点:
 　　　　　　1.接口不能实例化,因为有抽象方法
                       2.使用: 接口需要实现,implements实现接口
                        具体的实现类: 重写所有中接口中所有的抽象方法 + 按需新增
                         抽象的实现类: 按需抽象接口中的抽象方法 + 按需新增
                      3.一个类要先继承父类,再实现接口
                      4.一个类只能继承一个父类,但是可以实现多个接口
                      5.类和接口之间,只能用类实现接口,接口不是实现|继承类的
                      6.接口可以多继承接口,接口不能实现接口
                       7.推荐使用接口,不推荐使用抽象类
 8.接口可以发生接口多态,类可以发生类的多态

具体父类:不需要抽象方法,能够定义方法体成员属性,构造器..,子类继承可以直接使用
               抽象父类:能够定义方法体成员属性,构造器..,也有抽象方法
               接口:只有抽象方法,只用来定义规范
               接口可以发生接口多态,类可以发生类的多态