面向对象基本概念

最新推荐文章于 2020-03-03 17:47:28 发布

weixin_45091028

最新推荐文章于 2020-03-03 17:47:28 发布

阅读量183

点赞数

本文链接：https://blog.csdn.net/weixin_45091028/article/details/104621281

版权

三大特性是：封装,继承,多态

所谓封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。封装是面向对象的特征之一，是对象和类概念的主要特性。简单的说，一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部，某些代码或某些数据可以是私有的，不能被外界访问。通过这种方式，对象对内部数据提供了不同级别的保护，以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。

所谓继承是指可以让某个类型的对象获得另一个类型的对象的属性的方法。它支持按级分类的概念。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”。继承的过程，就是从一般到特殊的过程。要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。继承概念的实现方式有二类：实现继承与接口继承。实现继承是指直接使用基类的属性和方法而无需额外编码的能力；接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；

所谓多态就是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用。

面向过程：
“面向过程”(Procedure Oriented)是一种以过程为中心的编程思想。这些都是以什么正在发生为主要目标进行编程，不同于面向对象的是谁在受影响。与面向对象明显的不同就是封装、继承、类。

面向对象：

我们去new一个对象，并且调用这个对象的方法，就可以实现我们的业务，而对于这个这个对象具体做了做了什么，具体过程就不关注了。

对象与类
面向对象有什么样的好处呢？
可以仿真的模拟现实生活中的事物，可以实现更加复杂的业务逻辑

那我们如何描述一个坐标呢？

如果用面向过程的思想 int x,y;
int[] point={1,2};
额外的如果是一组坐标
int x1,y1,x2,y2,x3,y3....
int[][] points={{1,2},{3,4},{5,6}};
其次对于他们之间的操作
getDistance(p1,p2) 求两点间的距离
会发现数据和操作是分开的
弊端就是不方便统一管理
在面向对象的思想里面:
p1=创建一个Point对象并且制定x=1,y=2
p2=创建一个Point对象并且指定x=3,y=4
p1.x p1.y
p1.getDistance(p2) 让p1自己去和p2之间计算距离
好处在于将数据和操作统一起来了
意味着将点拟人化该事物的数据和操作就可以统一起来了！

什么是对象？但凡是真实存在的且具体的事物都称之为对象,就是由某一个类所描述出来的具体的事物
一个打火机一根烟一个手机一台电脑....

什么是类？具有相同行为和特征的一些具体事物的总称
类相当于大楼设计图纸
对象就是由该图纸所建成的具体的大楼

类就是用于描述事物的
类主要描述事物的那些方面呢？

属性-数据-成员变量
行为-函数-成员函数

比如我们要描述一个坐标
        属性 x y
        行为 getDistance()
class Point{
    double x;
    double y;

    public double getDistance(Point other){
        ...
    }
}

注意：建议一个类一个.java文件方便类管理
也就意味着当我们在创建一个类的时候其实就是在自定义一个数据类型

对象就是由一个类所描述的内容从而产生的一个具体的事物
目前而言但凡创建对象用new关键字
格式：类名/数据类型变量名=new 类名();
如何访问对象中的成员呢变量名.成员

对象的内存图解I

1.在堆内存中开辟一个空间并分配地址

2.按照类的描述，在该空间中定义成员变量并且有默认初始化值

3.加载成员函数进入方法区(只加载一次)

4.对象创建完毕将空间地址赋值给相应的变量

5.变量(p1/p2)调用成员变量

先通过该变量所存储的地址去堆空间中找

然后在该空间中找相应的成员变量

6.变量(p1/p2)调用成员函数

直接去方法区中找该成员函数

将该函数加载进栈内存开始运行

为了方便区分哪个对象调用的该成员函数

由this这个关键字段来区分 this主要存的是当前对象的地址

注意：当成员函数在操作变量的时候

先在当前函数的空间里找局部变量

如果没有找到，再去this所指向的堆内存中对象所属空间里去找

6.4 封装与private关键字
private关键字就是一个权限关键字 public protected 默认不写
private关键字表示私有权限该成员变量或成员函数只能够在类中被访问外界不可访问
目前发现的两个问题
1.我们可以通过对象直接修改对象中的成员变量
弊端：如果赋予了一个错误的值那么势必回导致程序后期的运行结果
如何解决呢？
就是说我们对象的成员变量并不是完全需要向外界可访问的
如果能够被外界访问那么势必也能被外界修改
class Person{
int age;
}
Person p=new Person();
System.out.println(p.age); //只是访问并打印
p.age=-10; //不符合现实业务逻辑给出的是一个错误的数据
//访问并修改
我了防范外界直接修改对象的成员变量？
private私有化关键字
成员变量加了private的话修改不行了获取也不行了

本质上而言我们应该防范的是什么？无条件强制的给成员变量修改
就是说修改是可以修改的但是你不能忽略对象的感受万一给一个错误的值怎么办？
不能直接修改的意思就是间接修改(是不是应该加上相应的对值的判断语句if-else)
顾客给收营员100块钱
对于这个100块钱的真假由谁来鉴别？收营员自己

setter 是一个Java当中的规范修改器主要负责修改成员变量
本身就是一个成员函数命名方式一般为 setXxx:setAge setName

getter 访问器主要负责访问成员变量(返回成员变量) getter看需求

建议：今后的代码中成员变量一律私有然后再去设置访问器和修改器
注意：如果成员变量和局部变量重名了如何区分呢？只需要在成员变量之前加this.即可

6.5 成员变量与局部变量的区别
1.存储位置
局部变量存储在栈内存中函数的所属空间里
成员变量存储在堆内存中对象的所属空间里
2.生命周期
局部变量随着函数的进栈而存在，随着函数的弹栈而消失
成员变量随着对象的创建而存在，随着对象的销毁而消失
3.访问范围
局部变量的访问范围仅仅在函数当中
成员变量的访问范围在当前类中
4.初始化值
局部变量必须先进行初始化之后再能被调用
成员变量在创建时有默认初始化

6.6 构造函数

有些对象创建之前成员变量就有值（不含默认初始化）

有些对象创建之后成员变量才有值
所以就有一个问题了如何在创建对象之前之中对我们的成员变量进行赋值呢？

构造函数的主要作用：在创建对象之时对成员变量进行赋值操作
构造函数的格式：
权限修饰符函数名(参数列表){
函数体;
}
对比和之前学过的函数来说
构造函数

没有函数类型关键字
没有返回值类型（并不意味着没有return）
函数名必须是类名

但凡创建一个对象构造函数就执行一次
问题：我们之前并没有写构造函数
如果类中没有定义任何构造函数的情况下，则会有一个默认无参的构造函数
public ClassName(){}
如果类中有明显定义的构造函数则默认无参的构造函数不存在了
所以一般而言我们最好将那个无参的构造函数写出来！！！！！！！
成员变量的赋值其实经历了三个阶段
默认初始化- 显式初始化 - 针对性初始化
类中成员变量被赋值构造函数

构造函数和成员函数有什么样的区别

构造函数只在创建对象的时候调用而且仅仅调用一次
成员函数在创建对象之后调动可以调用任意次数

成员函数能否调用成员函数可以
成员函数能否调用构造函数不可以的
构造函数能否调用成员函数可以只不过此时的成员函数不应该当做对象的特有行为而向外界提供的
仅仅是构造函数中的代码略多从而分出来的函数本质上这个函数还是构造函数的内容
那么该函数一般被定义为private
构造函数能否调用构造函数可以适当减少代码的冗余提高构造函数的利用率
原则上一般是参数较少的构造函数调用参数较多的构造函数
具体的调用方式并不像成员函数一样写个方法名
注意：成员函数劲量和构造函数别重名
this(...) 对this的调用必须是构造器中的第一个语句
在注意一点：构造函数可以调用构造函数但是不能产生回调
ERROR:递归构造器调用

那么有了构造函数是否还需要Setter和Getter吗？
不一定看需求如果确定数据后期要被修改则添加

6.7 对象的内存图解II
1.在堆内存中开辟一个空间并分配地址
2.对成员变量进行【默认初始化】
3.相应的构造函数进栈刚开始就对成员变量进行【显式初始化】
4.接着再去执行构造函数中的内容【针对性初始化】
5.构造函数执行完毕弹栈将对象的地址赋值给相应变量即可

单例模式
设计模式：就是我们的前辈们总结出来的一些编码技巧
它并不是随着Java的诞生而诞生的
它是由Java的广大使用者总结出来的一套编码经验
常见26种

单例模式：使用场景是某一个类只能创建一个对象
比如某一个朝代的皇帝只能是唯一的
1.既然只能创建一个对象的话就得不能让外界去创建对象
限制使用new不现实
只能从对象的创建流程中考虑只要有一个步骤不行对象就创建不出来
开辟空间分配地址是由计算机底层决定我们也控制不了
构造函数执行只需要将构造函数私有化即可
2.既然外界不能创建对象我们还得保证对象的创建
所以我们只能在类内部创建对象
Single s=new Single();
能否写成成员变量的形式？
所以private static
3.内部创建出对象还得向外界提供
因为private 外界不能直接访问
所以见解向外界提供一个函数外界通过调用函数获取对象

//饿汉式 比较急 所以直接返回对象

class Single{
    private static Single s=new Single();
    private Single(){}
    public static Single getInstance(){
        return s;
    }
}

//饱汗式 比交满 不急 判断一下
class Single{
    private static Single s;
    private Single(){}
    public static Single getInstance(){
        if(s==null){
            s=new Single();
        }
        return s;
    }
}

class SingleTest{
    public static void main(String[] args){
        Single s1=Single.getInstance();
        Single s2=Single.getInstance();
        //s2=null;
        Single s3=Single.getInstance();
        System.out.println(s1==s2);
        System.out.println(s2==s3);
    }
}

如果这里s2置为空，不影响别的(s1,s3) 这里s2拿的是地址，改变只是改变它所拿到的地址。

class CodeBlock{
    {
        System.out.println("构造代码块");
    }
    static{
        System.out.println("静态代码块");
    }
    public static void main(String[] args){
        CodeBlock c1=new CodeBlock();
        CodeBlock c2=new CodeBlock();
        CodeBlock c3=new CodeBlock();
    }
}

运行结果：

静态最先执行，并且只执行一次。

class StaticDemo{
    public static void main(String[] args){
        Chinese c1=new Chinese();
        Chinese c2=new Chinese();
        Chinese c3=new Chinese();
        //通过 对象.变量  
        //1.先去堆内存中对象的所属空间里找
        System.out.println(c1.name);    //成员变量
        //2.再去静态方法区中该对象所属类的空间里找
        System.out.println(c1.country); //静态变量

        //通过 对象.函数
        //1.先去非静态方法区中该对象所属类的空间里找
        c1.show();
        //2.再去静态方法区中该对象所属类的空间里找
        c1.haha();

        System.out.println(Chinese.country);
        Chinese.haha();
        //Chinese.show();
        System.out.println(Chinese.momo);
        System.out.println(Chinese.kaka);
    }
}
class Chinese{
    static int momo;
    static boolean kaka;
    String name;    //姓名
    String age;     //年龄
    static String country="China"; //国籍
    //无法从静态上下文中引用非静态
    public void show(){
        String name="旺财";
        /*
        成员函数内部在调用变量时的顺序：
        1.先找局部变量
        2.去堆中对象空间中找
        3.去静态区该对象所属类的空间里找
        
        我要喝水 水从哪里来
        1.如果你的嘴里已经有水 直接喝
        2.如果你的嘴里没水 杯子里有水 拿杯子喝 
        3.如果你的嘴里没水 杯子没水 去饮水机 
        (先不考虑继承的情况下)
        */
        System.out.println(name+age+country);
    }
    public static void haha(){
        System.out.println("哈哈");
    }
    public static void main(String[] args){

    }
}

class Test01{
    public static void main(String[] args){
        /*
        A a=new A();
        System.out.println(a==a.a);
        System.out.println(a.a==a.a.a);
        */
        
        B b=new B();
        //0x456 
        System.out.println(b==b.b);//false
        System.out.println(b.b==b.b.b);//true
        System.out.println(b.b.b==b.b.b.b.b.b.b.b.b.b);
    }
}
class B{
    static B b=new B();
}
class A{
    //StackOverflowError 栈溢出错误
    A a=new A();
}

这里A a会一直创建新对象然后调用构造函数，造成栈溢出。

weixin_45091028

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象基本概念

三大特性是：封装,继承,多态所谓封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。封装是面向对象的特征之一，是对象和类概念的主要特性。简单的说，一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部，某些代码或某些数据可以是私有的，不能被外界访问。通过这种方式，对象对内部数据提供了不同级别的保护，以防止程序...
复制链接

扫一扫