美文网首页IT技术篇
Java基础——面向对象编程(二)

Java基础——面向对象编程(二)

作者: 游戏原画设计 | 来源:发表于2019-01-04 10:57 被阅读0次

    8.final可以修饰类、方法、变量

    特点:

    final可以修饰类,该类就无法被继承

    final可以修饰方法,该方法就不能被重写(覆盖)

    final可以修饰变量,该变量就变成了常量。

    常量:

    a.字面值常量

    "龙爸爸" 10 true

    b.自定义常量

    final int x = 10;

    9.final修饰局部变量的问题:

    基本数据类型:基本数据类型的值不能改变

    引用数据类型:引用类型的地址值不能发生改变,但是,该对象的堆内存的值是可以改变的

    10.final修饰变量的初始化时机:

    a.被final修饰的变量只能赋值一次

    b.在构造方法完毕前(非静态)

    c.构造方法不能被final修饰

    11.我们在学习面向对象的继承思想的时候,说过,继承一种体现"is A"的关系,也就是子类是父类的一种特殊的情况

    狗是一种动物。猫也是一种动物。一条狗或者一只猫也是动物的这种类型

    class Animal{

    public void eat(){

    System.out.println("吃一般的食物");

    }

    }

    class Dog extends Animal{

    public void eat(){

    System.out.println("喝啤酒,吃炸鸡。");

    }

    }

    class Cat extends Animal{

    public void eat(){

    System.out.println("吃鱼摆摆..");

    }

    }

    创建了一个狗的对象,此时将子类对象赋值给父类对象

    Animal a = new Dog();

    a = new Cat();

    对象a应该是一个多态,有两种类型

    编译多态:把a的对象当做什么什么类型:Animal

    运行多态:对象a的真正类型

    多态:同一个对象(事务),在不同时刻体现出来的不同状态

    举例:

    酒--剑南春-XO-二锅头-白兰地

    多态的前提:

    a.必须存在继承的关系

    b.要有方法的重写

    其实你也是可以不重写方法,但是这样就没有任何意义

    动物 d = new 猫();

    d.eat();

    动物 d = new 狗();

    d.eat();

    c.要有父类的引用指向子类的对象

    父 f = new 子();

    多态中的成员访问的特点:

    a.成员变量

    编译看左边,运行看左边

    b.构造方法

    创建子类对象的时候,访问父类的构造方法,对父类数据进行初始化

    c.成员方法

    编译看左边,运行看右边

    d.静态方法

    编译看左边,运行看左边

    (静态和类相关的,其实算不上重写,访问的都是左边)

    由于成员方法存在方法的重写,所以他的运行是看的你右边

    12.多态的好处:

    从我们之前举的例子,可以得知多态的一部分的作用。当不同的子类对象都当成父类类型来看,可以屏蔽不同子类对象之间的差异,从而

    可以实现写出通用代码的编程,以适应不同的需求。

    a.提高了代码的维护性(继承)

    b.提高了代码的扩展性(多态)

    13.多态的弊端:

    不能够使用子类的特有功能

    14.多态的弊端:

    不能直接使用子类的特有的功能

    我就想使用,你有么有办法?

    怎么用呢?

    a.创建子类对象的方法即可(跟我们的多态没毛线关系)、

    b.把父类的引用强制的转换为子类的引用(向下转型(造型))

    对象间的转型的问题:

    向上转型:

    Fu f = new Zi();

    把子类对象赋值给父类引用(系统默认转换)

    向下转型:

    Zi z = (Zi)f//要求f必须是能够转为Zi的

    15.ClassCastException:类型转换异常

    一般都是在多态向下转型中引起的异常

    1.抽象类的概述:

    动物不应该是一个具体的东西,而且动物中有吃、睡、玩呀等等也不应该是具体的

    我们应该把一个不是具体的功能称为抽象功能,而一个类中如果有抽象的功能,那么该类就应该是一个抽象类。

    抽象类的特点:

    a.抽象类和抽象方法必须用abstract关键字来进行修饰

    b.抽象类中不一定有抽象方法,但是有抽象方法的类必须定义为抽象类

    c.抽象类不能实例化

    因为不是具体的存在

    抽象类中是有构造方法,但是也不能实例化,那么构造方法有啥作用?

    就用于子类访问父类的数据

    d.抽象类的子类

    a.如果不想重写抽象方法,该子类也是一个抽象类

    b.如果说你重写了父类的所有的抽象方法,那么该子类就是一个具体的类

    c.抽象的子类必须重写父类的抽象方法

    抽象类的实例化其实是靠具体的子类来实现的,也就是多态的方式

    Animal a = new Dog();

    抽象类的成员的特点:

    成员变量:既可以是变量也可以是常量

    成员方法:可以是抽象,也可是非抽象的

    构造方法:有

    用于子类访问父类的初始化数据

    抽象类的成员方法的特性:

    a.抽象方法:可以强制要求具体化的子类必须要做的什么事情

    b.非抽象方法:可以用于子类继承,提高代码的复用性

    如果说一个类没有抽象方法,可不可以定义为抽象类?如果可以 意义何在?

    A.可以

    B.不可以创建对象,实现多态

    abstract不能和哪些关键字共存?

    private 冲突

    final 冲突

    static 冲突

    2.猫狗案例

    具体事物:猫,狗

    共性:姓名,年龄,吃饭

    分析:

    从具体到抽象

    猫:

    成员变量:姓名,年龄

    成员方法:吃饭(猫吃鱼)

    构造方法:无参构造,带参构造

    狗:

    成员变量:姓名,年龄

    成员方法:吃饭(狗吃班长)

    构造方法:无参构造,带参构造

    因为存在共性。所以我们需要提取出一个父类。动物类、

    但是有由于吃饭的行为不一致,所以吃饭应该是一个抽象的

    因为父类存在抽象的方法,所以父类就必须是一个抽象类

    抽象的动物类:

    成员变量:姓名,年龄

    成员方法:吃饭(猫吃鱼)

    构造方法:吃法()

    3.单例设计模式:

    在某一个类中,且有一个实例(对象),一般在开发中,工具类都应该是单例的设计模式

    好处:

    被单例设计的类只能创建一次对象,避免了对象的重复创建和销毁

    节省内存空间

    单例设计模式的设计方法有N种,老师这种写法叫做饿汉式写法()

    单例的设计模式是最简单的设计模式,面试必问

    单例设计也是最常用的设计的模式,知道我们后面学到Spring。其实本质上也是采用单例(超级对象工厂)

    */

    public class SingletonDemo {

    //让对象无法创建

    private SingletonDemo() {}

    //保持对象能够创建一次

    private static final SingletonDemo instance = new SingletonDemo();

    //提供公共返回返回

    public static SingletonDemo getiInstance() {

    return instance;

    }

    public void show() {

    System.out.println("hello world");

    }

    }

    class Dmeo{

    public static void main(String[] args) {

    SingletonDemo.getiInstance().show();

    }

    }

    4. 接口的特点:

    a.接口用interface来进行表示

    interface 接口名{}

    b.类实现接口使用implements 接口名

    class 类名 implements 接口名{}

    c.接口不能实例化

    那么,接口如何实例化?

    按照多态的方式就OK了

    d.接口的子类

    a.可以是抽象类,但是没必要

    b.可以是具体类,但是要重新接口所有抽象方法(一般都是这么用)

    由此可见:

    a.具体类的多态(几乎没有)

    b.抽象类多态(常用)

    c.接口多态(用的炒鸡多)

    5.接口成员变量的特点:

    成员变量:只能是常量。并且是静态

    默认的修饰:public static final

    建议自己手动给出,因为你太闲了

    构造方法:

    接口不是类,所以没有构造方法

    成员方法:只能是抽象方法

    默认的修饰:public abstract

    建议自己手动给出,因为你太闲了

    7. 类与类:

    继承关系,只能单根继承 但是可以多层继承

    类与接口:

    实现关系,可以单实现,也可以多实现

    接口与接口:

    继承关系,可以单继承也可以多继承

    接口和抽象类的区别:

    相同点:

    a.都不能实例化

    b.都可以定义抽象方法,其子类也必须实现(重新)该抽象方法

    c.都位于继承层次的顶端,用于被继承或者实现

    成员:

    抽象类:

    成员变量:可以是变量也可以是常量

    成员方法:可以是抽象,也可以是非抽象

    构造方法:有

    接口:

    成员变量:没有变量,只有常量

    成员方法:只能是抽象方法

    构造方法:没有

    设计理念的区别:

    抽象类其实是一个继承的体系:"is a"的关系。抽象类中的定义是该继承体系的共同特性

    接口 被实现的其实是:"like a"的关系。接口中定义的其实是该继承体系的扩展功能(其实定义的也是一种规范)

    二者的选用:

    优先选用的是接口。尽量少用抽象(因为的抽象继承关系存在耦合度过高的问题,也违背了单一原则)。若需要定义子类的功能,又要为子类提供共性的功能的时候

    就选用抽象,在选用抽象的时候,尽量判别你的业务是不是一个抽象的存在。

    9.形参和返回值的深入讲解

    引用类型:

    类:要的其实是该类的具体的对象

    接口:要的其实是该接口的实现类的对象

    抽象类:其实要的是该抽象的子类的对象

    返回值:

    类:要的其实是该类的具体的对象

    接口:要的其实是该接口的实现类的对象

    抽象类:其实要的是该抽象的子类的对象

    1. 字符串:就是由多个字符组成遗传字符,其实也可以看成一个字符串数组

    通过查看API,我们可以知道

    a.字符串字面值"abc"也可以看成是一个字符串对象

    b.字符串是常量,一旦赋值,就不能发生改变

    Java。大家都知道,我们是学Java全栈的,大家就肯定以为我有全套的Java系统教程。没错,我是有Java全套系统教程,进扣裙【47】974【9726】所示,今天小编就免费送!~

    “我们相信人人都可以成为一个程序员,现在开始,找个师兄,带你入门,学习的路上不再迷茫。这里是ja+va修真院,初学者转行到互联网行业的聚集地。"

    相关文章

      网友评论

        本文标题:Java基础——面向对象编程(二)

        本文链接:https://www.haomeiwen.com/subject/omrhrqtx.html