对象与类

程序员文章站 2022-04-24 14:04:10

...

1.1 面向过程与面向对象

它们都是解决问题的思路大致的方向

面向过程：执行者凡事都要自己做亲力亲为

弊端：费时间费精力做出来的结果也不一定是最优的

面向对象：指挥者凡事都要找别人

面向过程和面向对象一定是互斥的吗？肯定不是
我们在处理问题时可以完全的面向过程但是不能完全面向对象解决一个事最终要被处理-面向过程

所以面向过程其实是最基本的思路而面向对象是基于面向过程的思路

1.2 对象与类

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

什么是对象？但凡是真实存在的且具体的事物都称之为对象
就是由某一个类所描述出来的具体的事物

什么是类？具有相同行为和特征的一些具体事物的总称

类相当于大楼设计图纸
对象就是由该图纸所建成的具体的大楼

类就是用于描述事物的，包括以下两个：

属性-数据-成员变量

行为-函数-成员函数

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

以上都是在描述这个事物的行为可以用函数来表示

比如我们要描述一个坐标点类，一个三角形类，

行为 getDistance(Point other) 返回当前点和传入点other之间的距离

getArea() 返回当前三角形的面积

getLength() 返回当前三角形的周长

对象与类

class Point{
    double x;
    double y;
    public double getDistance(Point other){
        return Math.hypot(x-other.x,y-other.y);
    }
}

class Test03{
    /* 
    点类Point
        数据 x横坐标 y纵坐标
        行为 getDistance(Point other) 返回当前点和传入点other之间的距离

    三角形类Triangle
        数据 Point p1,p2,p3
        行为 getArea() 返回当前三角形的面积
             getLength() 返回当前三角形的周长
    */
    public static void main(String[] args){
        Triangle t=new Triangle();
        Point p1=new Point();
        p1.x=0;
        p1.y=10;
        Point p2=new Point();
        p2.x=0;
        p2.y=0;
        Point p3=new Point();
        p3.x=10;
        p3.y=0;
        t.p1=p1;
        t.p2=p2;
        t.p3=p3;
        System.out.println(t.getLength());
        System.out.println(t.getArea());
    }
}

/*
三角形类Triangle
        数据 Point p1,p2,p3
        行为 getArea() 返回当前三角形的面积
             getLength() 返回当前三角形的周长
*/
class Triangle{
    Point p1;
    Point p2;
    Point p3;
    public double getArea(){
        double side1=p1.getDistance(p2);
        double side2=p1.getDistance(p3);
        double side3=p2.getDistance(p3);
        double s=(side1+side2+side3)/2;
        return Math.sqrt(s*(s-side1)*(s-side2)*(s-side3));
    }
    public double getLength(){
        return p1.getDistance(p2)+p1.getDistance(p3)+p2.getDistance(p3);
    }
}

1.3 对象的内存图解I

对象与类

步骤：

    1.在堆内存中开辟一个空间并分配地址
    2.按照类的描述，在该空间中定义成员变量并且有默认初始化值
    3.加载成员函数进入方法区(只加载一次)
    4.对象创建完毕将空间地址赋值给相应的变量
    5.变量(p1/p2)调用成员变量
        先通过该变量所存储的地址去堆空间中找
        然后在该空间中找相应的成员变量
    6.变量(p1/p2)调用成员函数
        直接去方法区中找该成员函数
        将该函数加载进栈内存开始运行
        为了方便区分哪个对象调用的该成员函数
        由this这个关键字段来区分 this主要存的是当前对象的地址
        注意：当成员函数在操作变量的时候
            先在当前函数的空间里找局部变量
            如果没有找到，再去this所指向的堆内存中对象所属空间里去找

1.4 封装与private关键字

private关键字─── 就是一个权限关键字；public ，protected 默认不写
private关键字表示私有权限，该成员变量或成员函数只能够在类中被访问，外界不可访问

目前发现的两个问题
1.我们可以通过对象直接修改对象中的成员变量
弊端：如果赋予了一个错误的值那么势必回导致程序后期的运行结果

就是说我们对象的成员变量并不是完全需要向外界可访问的
如果能够被外界访问那么势必也能被外界修改

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

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

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

封装：面向对象三大特征之一（封装，继承，多态）

从字面意义上来看封装就是将一些杂七杂八的东西进行统一的管理

最大的好处就是节约代码方便管理降低耦合性

在代码中有什么体现：

    循环：主要解决有规律且重复性执行的代码
    函数：主要解决具有独立功能的一段代码后期进行复用即可
    数组：主要解决多种同类型数据的操作统一操作方便类管理
    类：主要将数据和行为进行统一方便操作仿真现实中的事物

1.5 成员变量与局部变量的区别

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

1.6 构造函数

我们只能将对象创建完毕之后，再进行对成员变量的赋值
        对于一个人而言是出生后才有的性别还是出生前就有性别
        有些人出生前就有姓名了有些人出生后才有的姓名
        隐喻的对象
                有些对象创建之前成员变量就有值（不含默认初始化）
                有些对象创建之后成员变量才有值
        所以就有一个问题了如何在创建对象之前之中对我们的成员变量进行赋值呢？

class Person{
    private String name="小明"; //每一个Person对象创建之前都叫小明
    private int age=5;      //每一个Person对象创建之前都是5岁
    //private int wheelNum=4; //轮胎的个数
    
    /* 
    隐藏默认的
    public Person(){

    }
    */
    public Person(){    //无名 无年龄
        System.out.println("姓名："+this.name+",年龄:"+this.age);
    }
    public Person(int age){//无名 有年龄
        this.age=age;
        System.out.println("姓名："+this.name+",年龄:"+this.age);
    }
    public Person(String name,int age){ //有名 有年龄
        this.name=name;
        this.age=age;
        System.out.println("姓名："+this.name+",年龄:"+this.age);
    }
    void show(){
        System.out.println("今年"+age+"岁");
    }
    public void setAge(int age){
        if(age<0||age>150){     //局部变量age
            this.age=0;          //成员变量age
        }else{
            this.age=age;        //左边成员 右边局部
        }
    }
    public int getAge(){
        return age;
    }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return this.name;
    }
}

class Test01{
    public static void main(String[] args){
        Person p1=new Person();//new 构造函数();
        /*
        p1.setAge(10);
        System.out.println(p1.getAge());
        */
        Person p2=new Person(10);
        Person p3=new Person("旺财",30);
    }
}

    构造函数的主要作用：在创建对象之时对成员变量进行赋值操作
    构造函数的格式：
    权限修饰符函数名(参数列表){
        函数体;
    }
    对比和之前学过的函数来说
    构造函数：没有函数类型关键字
       没有返回值类型（并不意味着没有return）
                      函数名必须是类名
    但凡创建一个对象构造函数就执行一次
    问题：我们之前并没有写构造函数
            如果类中没有定义任何构造函数的情况下，则会有一个默认无参的构造函数
            public ClassName(){}
            如果类中有明显定义的构造函数则默认无参的构造函数不存在了
        所以一般而言我们最好将那个无参的构造函数写出来！！！！！！！
    成员变量的赋值其实经历了三个阶段
        默认初始化-    显式初始化 -      针对性初始化
                  类中成员变量被赋值        构造函数

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

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

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

1.7 对象的内存图解II

对象与类

步骤：

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

需求：实现一个简单的栈结构Stack

//需求：实现一个简单的栈结构Stack
class Test01{
    public static void main(String[] args){
        Stack stack=new Stack(20);
        for(int e=1;e<=20;e++){
            stack.push(e);
        }
        stack.push(21);
        System.out.println(stack.size());
        System.out.println(stack.toString());
        System.out.println(stack.peek());
        System.out.println(stack.pop());
        System.out.println(stack.toString());
        System.out.println(stack.isEmpty());
        stack.clear();
        System.out.println(stack.toString());
        System.out.println(stack.pop());
    }
}

/**
Stack是一个简单的由一维数组实现的栈结构
支持入栈出栈等常见操作,但不支持动态扩容操作
为了方便简化代码，默认此Stack中只能存储int型数据
@author HENG
@version 1.0
*/
public class Stack{
    private int[] data; // 容器 用于存储栈元素 data.length表示栈的最大容量
    private int top=-1;    // 栈顶标记 用于标记栈顶元素的位置 当栈为空时 top=-1 栈中有效元素的个数top+1
    private int capacity=10;    //默认最大容量为10
    /**
    创建一个默认容量为10的栈
    */
    public Stack(){
        this(capacity);
    }
    /**
    创建一个指定容量为capacity的栈
    @param capacity 由调用者传入的指定容量
                    如果capacity<0 则容量置为0
                    如果capacity>100 则容量置为100 
    */
    public Stack(int capacity){
        if(capacity<0){
            capacity=0;
        }
        if(capacity>100){
            capacity=100;
        }
        this.data=new int[capacity];
    }
    /**
    将元素e入栈，如果栈当前已满，则无法加入
    @param e 用户指定入栈的元素
    */
    public void push(int e){
        if(size()==data.length){
            System.out.println(">>>栈已满，无法添加元素"+e);
            return;
        }
        data[++top]=e;
    }
    /**
    从栈中弹出一个元素，如果栈已经是空，则返回-1即可(没有学异常 -1表示错误)
    @return 返回当前栈顶的元素，如果栈为空则返回-1
    */
    public int pop(){
        if(isEmpty()){
            System.out.println(">>>栈为空，无法弹栈元素");
            return -1;
        }
        return data[top--];
    }
    /** 
    获取当前栈顶元素(不出栈)，如果栈已经是空，则返回-1即可
    @return 返回当前栈顶的元素，如果栈为空则返回-1
    */
    public int peek(){
        if(isEmpty()){
            System.out.println(">>>栈为空，无法获取栈顶元素");
            return -1;
        }
        return data[top];
    }
    /**
    判断当前栈是否为空
    @return true表示栈空 否则栈不为空
    */
    public boolean isEmpty(){
        return top==-1;
    }
    /**
    清空当前的栈
    */
    public void clear(){
        top=-1;
    }
    /**
    获取栈中有效元素的个数
    */
    public int size(){
        return top+1;
    }
    /**
    返回栈的字符串表现形式
    */
    public String toString(){
        if(isEmpty()){
            return "[]";
        }
        String s="[";
        for(int i=0;i<size();i++){
            s+=data[i];
            if(i==size()-1){
                s+="]";
            }else{
                s+=",";
            }
        }
        return s;
    }
}

需求：模仿String自定义MyString

//需求：模仿String自定义MyString
class Test03{
    public static void main(String[] args){
        MyString s1=new MyString(); //""
        MyString s2=new MyString(new byte[]{97,98,99});//"abc"
        MyString s3=new MyString(new char[]{'a','b','c'});//"abc"
        MyString ms1=new MyString("abcdefgh".toCharArray());
        MyString ms2=new MyString("def".toCharArray());
        System.out.println(ms1.charAt(3));//d
        System.out.println(ms1.indexOf('b'));//1
        System.out.println(ms1.length());//8
        System.out.println(ms1.compareTo(ms2));//-3
        System.out.println(ms1.contains(ms2));//true

    }
}

只写了MyString的一部分；

/** 
仿照Java自带的String类 写一个自己的MyString类，
基本支持String中大部分的功能。
其实String的本质就是一个一维的字符数组，然后再加上其相关的操作
数组的长度一旦确定 则不可更改；
String的长度一旦确定 也不可更改；
更重要的是，String的内容一旦确定 也不可更改；
String是一个不可变对象 意味着我们不能在原地修改String的内容 只能重新创建一份进行修改。
@author HENG
@version 1.0
*/
class MyString{
    private char[] value;
    /**
    创建一个空串"",也就是说字符串长度为0
    */
    public MyString(){
        this.value=new char[0];
    }
    /**
    创建一个由指定字符编码组成的字符串
    */
    public MyString(byte[] bytes){
        this.value=new char[bytes.length];
        for(int i=0;i<value.length;i++){
            value[i]=(char)bytes[i];
        }
    }
    /**
    创建一个由指定字符组成的字符串
    */
    public MyString(char[] value){
        this.value=new char[value.length];
        for(int i=0;i<value.length;i++){
            this.value[i]=value[i];
        }
    }
    public char charAt(int index){
        if(index<0||index>=value.length){
            System.out.println(">>>角标越界"+index);
            return (char)-1;
        }
        return value[index];
    }
    public int indexOf(int ch){
        for(int i=0;i<value.length;i++){
            if(value[i]==ch){
                return i;
            }
        }
        return -1;
    }
    public int length(){
        return value.length;
    }
    //比较两个字符串之间的大小
    //两个字符数组从左到右挨个比较元素 如果出现第一个不相等的元素 返回差值即可
    //如果某一个数组遍历完了也没有发现不相等的 返回长度的差值即可
    public int compareTo(MyString other){
        int min=Math.min(length(),other.length());
        for(int i=0;i<min;i++){
            if(value[i]!=other.value[i]){
                return value[i]-other.value[i];
            }
        }
        return length()-other.length();
    }
    public boolean contains(MyString other){
        char[] c1=value;
        char[] c2=other.value;
        if(c2.length>c1.length){
            return false;
        }
        for(int i=0;i<c1.length;i++){
            boolean flag=true;
            for(int j=0;j<c2.length;j++){
                if(c2[j]!=c1[i+j]){
                    flag=false;
                    break;
                }
            }
            if(flag){
                return true;
            }
        }
        return false;
    }
}

对象与类

1.1 面向过程与面向对象

1.2 对象与类

1.3 对象的内存图解I

1.4 封装与private关键字

1.5 成员变量与局部变量的区别

1.6 构造函数

1.7 对象的内存图解II

入门:CorelDRAW12中对象轮廓的设定教程

谈谈sqlserver自定义函数与存储过程的区别

RR与RC隔离级别下索引和锁的测试脚本示例代码

PHP单元测试配置与使用方法详解

c#进程之间对象传递方法

用Newtonsoft将json串转为对象的方法(详解)

C# 快速高效率复制对象（表达式树）

必须会的SQL语句(一) 创建数据库与删除数据库

虚拟主机MySQL数据库的备份与还原的方法

PHP使用正则表达式获取微博中的话题和对象名