栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

学习java的第十三天,回顾方法的定义及调用,以及面向对象构造器、类与对象的关系等基础

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

学习java的第十三天,回顾方法的定义及调用,以及面向对象构造器、类与对象的关系等基础

一、方法的定义

在前面的学习中,以及学习过了方法的定义,下面再进行回顾一下加深印象,因为后续面向对象都需要用到这些基础知识的!
主要是注意以下几点:

  1. 修饰符
  2. 返回类型
  3. break:跳出switch,结束循环和return的曲边
  4. 方法名:注意规范,驼峰原则,见名知意
  5. 参数列表:(参数类型,参数名) 以及可变长参数
  6. 异常抛出
//Demo类
public class Demo01 {
    //main方法  启动程序
    public static void main(String[] args) {

        System.out.println("当前方法最大值是:"+max());
        System.out.println("当前方法最大值是:"+sayHello());
    }
    
    public static String sayHello(){
        return "hello,world!";
    }
    // 返回空值
    public void hello(){
        return;
    }
    // 返回最大数值
    public static int max(){
        int[] a = {2,5,9,66,33,2,3,-5};
        int maxs = a[0];
        for (int i = 0; i < a.length; i++) {
                if (a[i]>maxs){
                    maxs = a[i];
            }
        }
        return maxs;
    }
        //比大小
    public int max2(int a , int b){
            //如果a大于b ?那就是a 否则就是b
            return a>b ? a:b;  //三元运算符
    }

}


上面就创建了几个方法,用来实现一些比对或者判断功能,主要是return返回值的调用,一定要熟悉,return跟break是有很大的区别的,return是结束方法,返回一个结果!可以为空,也可以是任意类型!

二、方法的调用

主要难点还是在递归这一块,调用主要使用以下的方法

1. 静态方法跟非静态方法
  • 我先定义了一个学生类,方便进行调用
 //学生类
public class Student {
     //静态方法 static
    public static  void say(){
        System.out.println("学生开始说话啦!");
    }
    //非静态方法
     public void say2(){
         System.out.println("学生又说话了!");
     }
     
}
  • 然后再定义一个Demo02的类,用来执行调用
    public static void main(String[] args) {
        //调用静态方法(有static)
        Student.say();
        //调用非静态方法
        //实例化这个类 也就是  对象类型 对象名 = 对象值
        Student student = new Student();
        student.say2();
        //实例化Demo02这个类  方便调用自身的方法!
        Demo02 demo02 = new Demo02();
        //调用了自身的a()方法,而a方法中又调用了b()方法,所以实际输出的是b方法的输出内容
        demo02.a();
    }
        //static是和类一起加载的 , static静态修饰符可以调用非静态的方法,但是反之不能调用静态的方法
        public  void a(){
            b();
        }
    //类实例化之后才会存在
    public  void b(){
        System.out.println("我是三弟");

    }
2. 形参和实参

在调用形参跟实参时,需要注意的是实际参数跟形式参数的类型一定要对应!

    public static void main(String[] aegs){
        //非静态的方法,需要通过实例化类来完成调用
        int add = new Demo03().add(1,8); //需要赋等同类型的值
        System.out.println(add);

        //静态的方法可以直接调用赋值即可

        int add1 = add(2, 8);  //需要赋等同类型的值
        System.out.println(add1);
    }
    //这个是静态的方法
    public static int add(int a,int b){
        //返回a+b的结果
        return a+b;
    }
3. 值传递和引用传递

在java中都是值传递

  • 首先创建一个演示值传递的类方法
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a); // 结果也是1;
        Demo04.change(a);
        System.out.println(a); //结果为1
    }
    // 返回值为空
    public static void change(int a){
        a = 10;
    }
  • 下面创建一个演示引用传递的类
//值传递
public class Demo04 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a); // 结果也是1;

        Demo04.change(a);
        System.out.println(a); //结果为1
    }
    // 返回值为空
    public static void change(int a){
        a = 10;
    }


总结:还是那句话,java中的传递还是值传递,引用传递是一个对象,但本质还是值传递!

4. this关键字
  • 这里后续继承封装时再做讲解!
二、面向对象 1、什么是面向对象?
  • 面向对象编程(Object-Oriented Programmi,OOP)

  • 面向对象编程的本质就是:以类的方式组织代码,以对象的方式组织(封装)数据!

  • 对象是抽象的

  • 三大特性:封装、继承、多态

  • 从知识论角度考虑是先有对象后有类!对象,是具体的事物,类,是抽象的,是对对象的抽象!

  • 从代码运行角度考虑是先有类后又对象,类是对象的模板!

2、面向过程与面向对象
  • 面向过程思想
  1. 步骤清晰简单,第一步要做什么,第二步要做什么…
  2. 面向过程适合处理一些较为简单的问题
  • 面向对象思想
  1. 物以类聚,分类的思维模式,思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后,才对某个分类下的细节进行面向过程的思索!
  2. 面向对象适合处理复杂的问题,适合处理需要多人协作的问题!

总结: 对于描述复杂的事物,为了从宏观上把握,从整体上合理分析,我们需要使用面向对象的思路来分析整个系统,但是,具体到微观操作,仍然需要面向过程的思路去处理!

3、类与对象的关系
  • 类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物!
    比如:动物、植物、手机、电脑…
    Person类、Pet类、car类等,这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为

  • 对象是抽象概念的具体实例
    比如:张三就是人的一个具体实例,张三家里的旺财就是狗的一个具体实例。
    能够体现出特点,展现出功能的是具体的实例,而不是一个抽象的概念!

下面将这些思想转换为代码实现!!!

  • 创建一个学生类,用来代表抽象的数据类型
//学生类
public class Student {

    String name; //默认为null
    int age;  //默认为0
    String sex;

    //人的方法
    public void person() {
        System.out.println(this.name + "在认真学习!");

    }
}

  • 创建一个Application类,用来实例以及输出对象
 public static void main(String[] args) {
    //类:抽象的,实例化
    //类实例化后会返回一个自己的对象!
    //xiaoming对象就是一个Student类的具体实例
    //新建对象名 对象值
    Student xiaoming = new Student();
    Student feifei = new Student();
    //给xiaoming这个对象中调用到的name赋值
    xiaoming.name="小明";
    xiaoming.age=13;
    feifei.name = "小菲菲";
    feifei.age=20;
        System.out.println(xiaoming.name+xiaoming.age);
        xiaoming.person(); //会输出空值+在认真学习,因为下面的方法并没有进行赋值,调用的是学生类的默认值!
}
4、创建与初始化对象
  • 使用new关键字创建对象
  • 使用new关键字创建的时候,除了分配内存空间之外,还会给创建好的对象进行默认的初始化,以及对类中构造器的调用!
  • 类中的构造器也成为构造方法,是在进行创建对象的时候必须要调用的,并且构造器有以下两个特点:
  1. 必须和类的名字相同!
  2. 必须没有返回类型,也不能写void(默认返回空值类型)
  • 构造器必须是需要掌握的!!!

我在这里先创建了一个Person的类,没有定义任何方法的时候,在Application类中也可以调用方法

public class Person {
    //一个类即使什么都不写。他也会存在一个方法
    String name;
    int age;
    //1、使用一个new关键字。本质是在调用构造器
    //2、用来初始化值
    //这里是自动显示出来的无参构造器
    public Person() {
    }


    //这个是有参构造:一旦定义了有参构造,无参就必须显示定义!否则构造器那边会提示没有有效的参数
    public  Person(String name){
        //this的意思是在类中的类,后面定义的name是方法中的nema
        this.name = name;

    }
    // 这个是使用ALT+insScrlk快捷键生成的一个有参构造
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

}

这里是Application类,用来创建对象以及输出对象的。

//输出类 一个项目尽量只有一个main输出方法
public class Application {
    public static void main(String[] args) {
        //这个是调用无参构造器,如果删除上面的无参构造方法,会报错!
        Person person1 = new Person();

        //这个是实例化了一个有参构造器,定义了一个参数
        Person person2 = new Person("大哥大");
        System.out.println(person2.name);
        //这个是实例化了一个有参构造器,定义了两个参数
        Person person3 = new Person("小菲菲",20);  //目前是有参构造
        System.out.println(person3.name+person3.age);
    }

}

综上,得出了几个总结:

  • 构造器:
  1. 和类名形同
  2. 没有返回值
  • 作用:
  1. new本质在调用构造方法
  2. 初始化对象的值
  • 注意点
  1. 定义有参构造之后,如果想使用无参构造,先是得定义一个无参的构造!
  2. 使用Alt + InsScrlk健可以快速创建
  3. this. = name; 这里写的是使用当前对象的某一个变量名,如果是在类中定义,那就是使用当前类的某一个变量名,比如this.name = name ,当在类变量中存在name时,那它调用的便是类中的this,然后后面等于的name,如果name在方法中,则this.name 就会变成方法中的name,因为已经赋值了!

以上就是今天所学习的内容,一定要多加练习,每一项都必须要掌握!不然后面很难继续下去的 !


注:文章仅做个人学习日记,不做学习建议,学习来源:狂神说

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/964770.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号