面向对象思想

  • 面向对象思想
package com.uncle.object_oriented;
/**
 * 面向对象
 *
 * 面向过程的编程思想
 * 	   解决问题的时候按照一定的过程(流程)
 * 	   钟点工--->  大象装冰箱  总共分几步
 * 	   1.开门   2.大象装里面  3.关门
 * 	   以过程为本--复用--增加了很多冗余
 * 	   大段的过程 拆分成小段 --- 到底是哪一个实体来做的
 * 	面向对象的编程思想
 * 	   解决问题的时候按照现实生活中的规律来考虑问题
 * 	   考虑在这个问题的过程中   有几个实体参与进来
 * 	   理解为  实体动作动作的支配者  没有实体动作就发生不了
 * 	   人  冰箱  大象
 * 	   分析每一类个体都有什么特点  做了哪些事情
 * 	   大象   特点 大 体重很重
 * 	   冰箱   特点 有门 容积
 * 	   人      特点 能做事情  做了哪些事情呢 ? 开冰箱门 装大象 关门
 *
 *
 * 	   类和对象
 * 	类----人类    抽象笼统的概念  描述一类事物  肯定是具有相同的特征行为
 * 		人类有名字  有年龄  有性别-----静态描述特征(特征)-----属性
 * 		人类能吃饭  能说话  能学习-----动态动作行为(做事)-----方法
 * 	对象--具体的人    人类中的一个具体的人   郑中拓
 * 		大叔这个具体的人  有名字  有年龄  有性别
 * 			               能吃饭  能说话  能学习
 *
 * 	在现实生活中  对象是先有的  总结出来的概念(类) 后产生的
 * 	在计算机中利用面向对象的思想来做事
 * 		需要先自己定义(描述)一个类(型)
 * 		想要做事情 需要在描述的类中创建一个具体的个体(对象)出来
 * 		个体(对象)来做事
 *
 * 	如何在计算机中创建(描述)一个类
 * 	1.先创建一个类class
 * 	2.类的里面 利用属性或方法去描述这个类
 * 	3.创建一个当前类的对象  让对象调用属性/方法做事
 * 		对象的创建在哪儿都可以
 *
 * 	类中的方法---->做一件事情
 * 	权限修饰符 [特征修饰符] 返回值类型 方法名字 (参数列表) [抛出异常]  [{
 * 		方法体
 *        }]
 * 	权限修饰符 返回值类型 方法名字 (参数列表) {
 *
 *    }
 * 	1.无参数无返回值
 * 	2.无参数有返回值
 * 	3.有参数无返回值
 * 	4.有参数有返回值
 *
 * 		人类有名字 有年龄 有性别----属性
 * 		人类能吃饭 能说话 能学习----方法
 *
 * 	可以理解为方法是做了一件事情
 * 	可以理解为返回值是这件事情做完了  留下的一个结果
 * 	可以理解为参数是做事情之前  必须提供的条件
 *
 * 	形参和实参
 *         	形参可以理解为是方法执行时的临时变量空间  x
 *         	实参可以理解为是方法调用时传递进去的参数  a
 *         	方法调用时会将实参的内容传递给形参
 *         	如果内容是基本类型  传递的 是值    形参改变  实参不变
 *         	如果内容是引用类型  传递的 是引用  形参改变  实参跟着改变
 *
 *
 *         	命名规则和规约
 * 	规则
 * 	   字母 数字 符号 中文
 * 	   字母 区分大小写
 * 	   数字 不能开头
 * 	   符号 _ $
 * 	   中文 不推荐使用
 * 	规约
 * 	   类名字   首字母大写  两个单词以上  每一个首字母都大写
 * 		Test    TestOne   TestOneTwo
 * 	   属性/方法/变量  驼峰式命名规约  首字母小写 两个单词以上  第二个以后的每一个首字母大写
 * 		test     testOne   testOneTwo
 * 	   构造方法   与类名一致  类中唯一的大写字母开头的方法
 * 	   静态常量   全部字母大写  通过_做具体说明    BOOKSTORE_ADMIN
 * 	   包名         全部字母小写  Java关键字都是小写  注意与关键字不要冲突
 * 	所有的名字最好--->见名知意(增强可读性   层次关系缩进  见名知意  注释)
 */
public class ObjectOriented {
    //这个文件是在计算机内 画的一张图纸
    //描述计算机里的人类长成什么样子

    //属性--静态描述特点
    //  必要的组成部分
    //  修饰符  数据类型  属性名字 [= 值];
    public String name;
    public String sex;

    public ObjectOriented() {
    }

    public ObjectOriented(String name, String sex) {
        this.name = name;
        this.sex = sex;
    }

    //重写toString方法 为了方便打印 后面会讲
    @Override
    public String toString() {
        return "ObjectOriented{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }


    public String eat(String food) {
        System.out.println(name+"吃了"+food);
        return "方法调用成功";
    }


    class Person {
        //这个文件是在计算机内 画的一张图纸
        //描述计算机里的人类长成什么样子

        //属性--静态描述特点
        //  必要的组成部分
        //  权限修饰符 [特征修饰符] 数据类型 属性名字 [= 值];
        public String name;//全局变量
        public int age;
        public String sex;//

        //*方法--描述可以做什么事情(动作)
        //设计一个方法  用来描述人类可以做吃饭这件事情
        public void eat(){
            System.out.println("吃了一碗大米饭");
        }

        //设计一个方法  用来告诉别人我的名字  "郑中拓"
        //若方法的设计规定了返回值类型  方法内必须通过return关键字返回一个值
        public String tellName(){
            System.out.println("你们问我叫什么呀?勉强告诉你们一下");
            return "郑中拓";//只有一个
        }

        //设计一个新的吃饭方法
        //描述人类可以做吃饭饭这件事情
        public void chiFanFan(int count,String something){
            System.out.println("吃了"+count+"碗"+something);
        }

        //设计一个方法  买饮料   1.需不需要提供条件  2.需不需要给别人留下什么结果
        //      需要提供条件   钱
        //      需要返回值     买到的饮料 名字
        public String buyDrink(int money){
            if(money>5){
                return "红牛";
            }else{
                return "矿泉水";
            }
        }

        //设计一个方法  用来画星星  4*4
        //f-->表示方向的意思   f==true 偏左 没有空格   f==false 偏右 带空格
        public void drawStar(int line,boolean f){
            for(int i=1;i<=line;i++){
                if(!f){//f==false  偏右 带空格
                    for(int j=1;j<=line-i;j++){
                        System.out.print(" ");
                    }
                }
                for(int j=1;j<=i;j++){
                    System.out.print("*");
                }
                System.out.println();
            }
        }


    }

    public static void main(String[] args) {
        ObjectOriented objectOriented = new ObjectOriented();
        objectOriented.name = "步尔斯特";
        objectOriented.sex = "男";

        System.out.println(objectOriented.toString());

        objectOriented.eat("米饭");

        }

}



/*----抽象笼统的概念	Person
		具有一组相同的特征或行为
		属性---静态描述类的特征
		权限修饰符 [特征修饰符] 属性类型 属性名字 [=];
		方法---动态描述类的行为
		权限修饰符 [特征修饰符] 返回值类型 方法名字 (参数列表) [抛出异常] [{
			方法执行体
		}]
		方法中最主要的两个结构  方法的参数列表 方法的返回值类型
		   参数列表可以理解为方法做事情之前需要提供的条件(可以多个)
		   返回值可以理解为方法做事情之后得到的一个结果(只有一个)
	类描述好了以后是不可以直接做事情
	   需要创建当前类的对象  通过new的方式
		Person p = new Person();
	   通过p.调用啦  调用属性(存值/取值)   调用方法(执行一次)
 */
  • 练习
package com.uncle.object_oriented;

public class TestFunctions {

    //8.设计一个方法  用来存储给定范围内的素数(2-100) 素数在自然数之内
    //      是否需要提供条件  begin end   返回值一个装满了素数的数组
    public int[] findPrimeNum(int begin,int end){
        if(begin<0 || end<0){
            System.out.println("素数没有负数 不给你找啦");
            return null;//自定义一个异常  认为规定的一种不正常的现象
        }
        if(begin>=end){
            System.out.println("您提供的范围有误 begin应该比end要小");
            return null;//自定义一个异常  认为规定的一种不正常的现象
        }
        //创建一个足够长的数组
        int[] array = new int[(end-begin)/2];
        int index = 0;//记录新数组的索引变化   同时记录个数
        for(int num=begin;num<=end;num++){
            boolean b = false;//标记
            for(int i=2;i<=num/2;i++){
                if(num%i==0){
                    b = true;
                    break;
                }
            }
            if(!b){
                array[index++] = num;
            }
        }
        //将数组后面的多余的0去掉
        int[] primeArray = new int[index];
        for(int i=0;i<primeArray.length;i++){
            primeArray[i] = array[i];
        }
        array = null;
        return primeArray;
    }

    //扩展 设计一个方法  将给定的元素插入数组的某一个位置
    //7.设计一个方法  用来去掉数组中的0元素
    //      需要提供参数一个数组  需要提供删除的元素是什么    返回值 一个新的数组
    public int[] removeElementFromArray(int[] array,int element){
        //找寻原数组中去掉被删除元素后的长度
        int count = 0;//记录非删除元素的个数
        for(int i=0;i<array.length;i++){
            if(array[i]!=element){
                count++;
            }
        }
        //通过找到的count创建一个新数组
        int[] newArray = new int[count];
        int index = 0;//控制新数组的索引变化
        //将原来数组中非删除的元素存入新数组中
        for(int i=0;i<array.length;i++){
            if(array[i]!=0){
                newArray[index++] = array[i];
            }
        }
        //将新数组返回
        return newArray;
    }

    //5.设计一个方法  用来合并两个数组
    //      是否需要参数  需要提供两个数组   需要返回一个大的数组
    public int[] mergeArray(int[] a,int[] b){
        //创建一个新的数组
        int[] newArray = new int[a.length+b.length];
        //分别将a和b数组的元素存入新数组内
        for(int i=0;i<a.length;i++){
            newArray[i] = a[i];
        }
        for(int i=0;i<b.length;i++){
            newArray[a.length+i] = b[i];
        }
        //将新数组返回
        return newArray;
    }

    //6.设计一个方法  用来将一个数组按照最大值位置拆分
    //      需要提供一个大的数组  需要返回值二维数组
    public int[][] splitArray(int[] array){// 1 2 3 9 4 5
        //找寻最大值索引位置
        int max = array[0];//记录最大值
        int index = 0;//记录最大值的索引位置
        for(int i=1;i<array.length;i++){
            if(array[i]>max){
                max = array[i];
                index = i;
            }
        }
        //通过找寻到的index判定数组拆分后的前后长度
        int[] newa = new int[index];
        int[] newb = new int[array.length-index-1];
        //分别将两个小数组填满
        for(int i=0;i<newa.length;i++){
            newa[i] = array[i];
        }
        for(int i=0;i<newb.length;i++){
            newb[i] = array[(index+1)+i];
        }
        //将两个新的小数组一起返回
        return new int[][]{newa,newb};
    }

    //4.设计一个方法  用来找寻给定的元素是否在数组内存在(Scanner输入一个)
    //      是否需要参数及返回值   需要提供一个数组  需要一个目标元素   返回值告诉你是否找到啦
    // 方法设计了返回值类型  就必须给返回值  编译检测的悲观性原则
    public String isExist(int[] array,int element){
        //循环方式找寻是否存在
        String result = "对不起 您要的值在数组中没有";
        for(int i=0;i<array.length;i++){
            if(array[i]==element){
                result = "恭喜您 您要的值在数组中存在";
                break;
            }
        }
        return result;
    }

    //3.设计一个方法  用来寻找数组中的极值(最大值 或 最小值)
    //      是否需要参数及返回值   需要提供一个数组  需要提供一个值(最大 最小)   返回值肯定需要一个值
    public int findMaxOrMinNum(int[] array,boolean flag){//flag==true最大值  flag==false最小值
        //2.找一个变量
        int temp = array[0];
        //3.利用遍历数组的方式挨个与max比较
        for(int i=1;i<array.length;i++){
            if(flag && array[i]>temp){//找寻最大值
                    temp = array[i];
            }else if(!flag && array[i]<temp){//找寻最小值
                    temp = array[i];
            }
        }
        //3.将找到的值返回
        return temp;
    }

    //*2.设计一个方法  用来交换一个数组(头尾互换)
    //      是否需要参数及返回值   需要提供一个数组   不需要返回值
    public void changeArrayElements(int[] array){
        //2.数组内部的元素头尾对应互换
        for(int i=0;i<array.length/2;i++){
            int temp = array[i];
            array[i] = array[array.length-1-i];
            array[array.length-1-i] = temp;
        }
    }

}
package com.uncle.object_oriented;

public class Test {

    public static void main(String[] args){
        //隐藏的过程  加载类
        //0.创建一个对象
        TestFunctions tf = new TestFunctions();

        int[] x = tf.findPrimeNum(100,10);
        for(int v:x){
            System.out.println(v);
        }


        //找寻给定元素是否在数组中存在
//        int[] x = new int[]{1,2,3,4,5,6};
//        String result = tf.isExist(x,14);
//        System.out.println(result);

        //找寻最大值或最小值
//        //1.有一个数组
//        int[] array = new int[]{1,3,5,7,9,0,8,6,4,2};
//        //2.调用tf中的方法  做事
//        int result = tf.findMaxOrMinNum(array,false);//array数组中找寻最大值
//        //4.验证一下
//        System.out.println("数组中的最大值为:"+result);


        //交换数组内部元素
//        //1.有一个数组
//        int[] x = new int[]{1,2,3,4,5,6,7,8,9};
//        //2.利用tf对象调用方法执行操作
//        tf.changeArrayElements(x);//x--->array
//        //3.验证看一看结果
//        for(int v:x){
//            System.out.println(v);
//        }
    }

}
  • 类加载及创建(基本类型)在这里插入图片描述
  • 方法参数及返回值传递在这里插入图片描述
  • 类加载及创建(引用类型)在这里插入图片描述
  • 数组互换方式一在这里插入图片描述
  • 数组互换方式二
    在这里插入图片描述
已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 技术工厂 设计师:CSDN官方博客 返回首页