day09_自我总结

一、回顾

1.成员变量与局部变量区别
  A.定义的位置不同  B.生命周期不同  C.存储的位置不同  D.是否有默认值
2.封装
  概念: 隐藏属性内部实现的细节(锁) 提供对外访问的方法(钥匙)
  好处: A.提高代码的安全性   B.提高代码的可扩展与可维护性
  体现: A.对属性的封装  B.封装工具类
  步骤:
    A.私有化属性
    B.提供set(用于设置值)与get(用于获取值)方法
  问题:
    成员变量名与局部变量名相同的时候 优先访问局部变量 获取成员 通过this来获取
3.静态
   关键字: static 
   静态方法:静态方法不能访问非静态的资源
   静态变量与成员变量的比较
   a.所属不同  b.生命周期不同  c.存储位置不同  d.调用方式不同
4.继承:
   关键字: extends
   场景: 满足 is   a 条件的时候
   继承:共性的抽取
   注意点:
     A.子类不能继承父类私有的资源 
     B.子类不能继承父类的构造方法 但是可以进行调用
   java单继承问题:
     java只支持单继承 多层继承  不支持多继承
   继承中方法成员变量特点:
      优先获取子类成员变量 子类没有 则向上查找  一直查找Object  如果没有 则报错
   this与super
   this 获取自身的成员变量  也可以父类的成员变量  super 只能获取父类的成员变量
   this 获取自身的成员方法  也可以获取父类的成员方法 super  只能获取父类的成员方法
   this 调用自身的构造方法  super 调用父类的构造方法

二、继承

2.1 继承访问构造方法的特点

1.调用自身的构造方法 this()  调用父类的构造方法 super()
2.this()与super 只能编写在构造方法中第一行  this()与super()不能同时存在
3.构造方法不能出现相互调用或者是递归调用
4.其它方法都不调用构造方法

2.2 继承访问成员方法特点

特点：优先访问子类的方法 如果子类没有 则向上进行查找 一直查找到Object 如果没有则报错

2.3 方法重写

*方法重写规则: 在继承中   方法名相同 参数相同 与返回值与访问修饰符有关

*方法重载规则:在同一个类中 方法名相同 参数不同(数据类型或者个数不同) 与返回值与访问修饰符无关

1.方法重写的注解: @Override 用于检查是否是重写的方法
2.使用场景: 在继承中 将共性的资源抽取到父类中 在将共性方法抽取到父类中的时候 需要使用父类的资源
           但还需要在父类的基础进行功能的扩展 就可以使用重写
3.注意点:
   A.重写方法的返回值类型 不能超过父类的返回值类型的访问
   B.重写方法的访问修饰符不能严于父类的访问修饰符权限

2.4继承的优缺点

优点:提高代码的可复用性 以及可扩展性
缺点: 代码与代码的耦合度比较高(代码与代码之间的关系比较紧密)

三、final

* 不能被继承(类) 、 不能被重写(方法) 、 只能赋值一次(变量)

1.final 最终 最后
2.修饰成员
  a.类 使用final修饰的类 是不能被继承
  b.方法:使用final修饰的方法是不能被重写
  c.变量:使用final修饰的变量一般称为是常量 只能赋值一次
3.说明
   A.在实际开发中final一般与static来进行搭配使用  final修饰的数据不会发生改变 
     使用static 可以直接使用类名来进行访问  操作比较方便
   B.使用final修饰的引用数据类型的对象 不能改变的是对象的地址值 可以改变的是对象的属性值

四、包

1.包:用于来管理源代码文件 类似电脑中文件夹
2.作用:
   A.用于来管理源代码文件
   B.避免类名冲突 在不同包中 可以创建相同的类名
3.组成:
   A.包名全部都是小写
   B.不同的包是以.进行分割
   C.组成:域名+公司的名称+项目的名称+包的具体的含义  
         例如: com.qf.oa.utils工具包  com.qf.oa.dao操作数据库包
4.声明包:
    package +完整包名【idea自动声明包】例如: package com.qf.test08;
5.导包
   A.在使用其它包下类的资源的时候 就需要进行导包 例如:Scanner  Math....
     语法: import + 完整的包名+类名 例如:import java.util.Scanner;
   B.使用java.lang包 下的资源不需要进行导包
6.注意点:
    A.如果使用其它包的下类的资源 不想进行导包 那么必须使用完整的包名+类名
       例子: java.util.Scanner input  = new java.util.Scanner(System.in);
    B.如果自定义的类名与jdk的提供的类冲突之后 优先使用自定义类

五、访问修饰符

	public	protected	default（空的）	private
同一类中	√	√	√	√
同一包中（子类与无关类）	√	√	√
不同包的子类	√	√
不同包中的无关类	√

1.范围从大到小  public  ==>protected  ==>default  ==>private
2.在实际开发中 如果需要对外提供访问的时候使用public  如果不需要对外进行访问的时候 使用private

六、多态

6.1 多态的概念

1.概念:一个事物或者是一个对象多种形态 就是多态
2.前提:必须在继承或者是实现接口的前提下
3.特点:父类对象的引用指向子类对象
4.语法: 父类类名 对象名 = new  子类类名

6.2 多态访问成员变量的特点

只能从父类的成员变量，中获取
（哪怕重名“重写”的也只调用父类）

也称做（特点）:编译看左边 运行看左边

step01-定义父类

package com.qf.test12;

public class Fu {
    int numFu=10;
    int num =20;
}

step02-定义子类

package com.qf.test12;

public class Zi extends  Fu {
    int numZi=30;
    int num=40;
}

step03-定义测试类

package com.qf.test12;

public class Test {
    public static void main(String[] args) {
        //多态实例化对象
        Fu fu = new Zi();
        //编译看左边 运行看左边
        //fu.numFu
        //fu.numZi;
        //运行看左边
        System.out.println(fu.num);
        System.out.println(fu.numFu);
    }
}

6.3 多态访问方法的特点

从子类开始查找方法名对应的方法，如果子类没找到就去父类找。
（重名的方法，只调用子类的；不能直接调用子类的方法）
（意思是：可以调用所有父类方法，但是遇到该子类和父类同名“重写”方法的时候，只调用子类的方法）

或是

编译看左边，运行看右边
：
编译的时候看（等号左边的父类）是否有该方法，有就表示可以下一步；
（下一步）运行的时候看（等号右边的子类）是否有该方法（方法变量名一样），有就表示优先运行子类中的该方法。

step01-定义父类

package com.qf.test13;

public class Fu {

    public  void showFu(){
        System.out.println("我是父类的方法");
    }

    public  void show(){
        System.out.println("我是父类的show方法");
    }
}

step02-定义子类

package com.qf.test13;

public class Zi extends  Fu {

    public  void showZi(){
        System.out.println("我是子类的方法");
    }

    public  void  show(){
        System.out.println("我是子类show方法");
    }
}

step03 -测试类

package com.qf.test13;

public class Test {
    public static void main(String[] args) {
        //利用多态实例化对象
        Fu fu  = new Zi();
        //编译看左边
        //fu.showFu();
        //fu.showZi();
        //运行看右边
        //fu.show();
        fu.showFu();
    }
}

七、多态

7.1 多态向上转型

1.语法:
   父类类名 对象名 = new  子类类名()
   例如:Fu fu = new Zi()
2.解释
3.问题:不能获取到子类独有的资源

7.2 多态向下转型

1.语法: 
   子类类名 对象名=(需要转换的子类类名)父类对象的引用
  例如: Zi  zi =(Zi)fu;
2.解释
3.问题:
   ClassCastException 强制类型转换错误
4.解决:
   判断是否可以还原成本身子类对象  instanceof
   例如: p instanceof  Dog

7.3 案例：（以父类作为方法的参数）

以父类作为方法的参数

step01 需求

step02-代码-动物类

package com.qf.test16;

public class Pet {
    private  String name;
    private  int age;
    private  int  health;
    private  int  love;

    public Pet() {
    }

    public Pet(String name, int age, int health, int love) {
        this.name = name;
        this.age = age;
        this.health = health;
        this.love = love;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getHealth() {
        return health;
    }

    public void setHealth(int health) {
        this.health = health;
    }

    public int getLove() {
        return love;
    }

    public void setLove(int love) {
        this.love = love;
    }

    public  void  eat(){
        System.out.println("我是父类吃的方法");

    }
}

step03-狗类

package com.qf.test16;

public class Dog extends  Pet {

    public Dog() {
    }

    public Dog(String name, int age, int health, int love) {
        super(name, age, health, love);
    }

    @Override
    public void eat() {
        System.out.println("吃狗粮.....");
    }
}

step04- 企鹅类

package com.qf.test16;

public class Penguin  extends  Pet {
    public Penguin() {
    }

    public Penguin(String name, int age, int health, int love) {
        super(name, age, health, love);
    }

    @Override
    public void eat() {
        System.out.println("吃鱼......");
    }
}

step05 主人类

package com.qf.test16;

public class Master {

//    //定义一个方法给狗喂食
//    public  void  feed(Dog d){
//        d.eat();
//
//    }
//    //定义一个方法给企鹅喂食
//    public  void   feed(Penguin p){
//        p.eat();
//    }
//
    public  void  feed(Pet p){
        p.eat();
    }

}

step06-测试类

package com.qf.test16;

public class Test {
    public static void main(String[] args) {
        //实例化主人类对象
        Master m = new Master();
        //利用多态实例化对象
        //Pet p  = new Dog();
        Pet p  = new Penguin();
        m.feed(p);
    }
}

7.4 案例升级：（以父类作为方法的返回值）

简单工厂（方法）

以父类（父类具体化的对象）作为返回值

不想通过实例化对象调用方法，只有把该方法放在方法区的静态存储区内（因为静态的，可以通过类名直接访问）————How to 放到方法区的静态存储区内：在控制范围词 后面 加上 static

step01-新建Master01类

package com.qf.test16;

public class Master01 {

    //获取所有的动物的对象
    public  static Pet getPet(String type){
        Pet p=null;
        if ("dog".equals(type)) {
            //实例化
            p = new Dog();
        }else  if ("penguin".equals(type)) {
            //实例化企鹅
           p= new Penguin();
        }
        return  p;
    }
}

step02-测试类

package com.qf.test16;

public class Test02 {
    public static void main(String[] args) {
      Pet p =  Master01.getPet("dog");
      p.eat();
      Pet p1 = Master01.getPet("penguin");
      p1.eat();
    }
}

标签：总结,day09,int,子类,void,自我,父类,方法,public
来源： https://www.cnblogs.com/zhenglyz/p/16503349.html