JAVA小白学习日记Day3

吕秃秃

已于 2024-07-16 18:55:22 修改

阅读量335

点赞数 9

文章标签： java 学习开发语言

于 2024-07-16 18:50:21 首次发布

本文链接：https://blog.csdn.net/m0_63367052/article/details/140472106

版权

1.方法

方法的定义,调用形参实参返回值类型 void return 可变参数递归重载

package com.text1;

public class TextA1 {
    public static void main(String[] args) {
        System.out.println(sum(1,2,3,5,4,6,8,9));
        int num=jiecheng(5);
        System.out.println(num);
    }
    //方法   函数   过程
    //语法
        /*
        返回值类型   方法名（要见名知意）  （参数列表） {
        方法体
        }；
        */
    //返回值类型  该方法必须返回一个这个类型的对象
    //当一个方法不需要返回值   返回值类型就定义为void
    //void中不能return null
    //void可以return但是不能接其他的
    public static int max(int a,int b){
        //return 返回数据
        int max=a>b?a:b;
        return max;
    }
    //定义一个sum方法，接收两个int  返回和
    public static int sum(int a,int b){
        return a+b;
    }
    public static void printMax(int a,int b){
        System.out.println(a>b?a:b);
        return;//终止方法的作用
    }
    public static  void printMaxA(int a,int b){
        //得到最大值
        //调用本类中已经定义好的方法
        int result=max(a,b);
        //打印
        System.out.println(result);
    }
    //形参  定义方法时，参数列表的参数名  printMax中的ab
    //实参  调用方法时实际传入的参数  如printMax中调用max中的ab
    //重载
    //在一个类中，方法名相同，参数列表不同为重载
    //参数列表要素 1.参数类型不同 2.参数个数不同 3.参数顺序不同（是参数不同类型时的前后顺序，与形参名无关）
    //定义一个方法，返回一个数组的最大值
    public static int arr_max(int[] a){
        int max=a[0];
        for (int i=0;i<a.length;i++){
            if (a[i]>max){
                max=a[i];
            }
        }
        return max;
    }


    //可变参数  声明参数后跟...  将可变参数当数组使用
    //注意：
    // 1.一个方法中最多只能有一个可变参数
    // 2.可变参数必须放在参数列表的最后一个  （double a，int b，int... c)可以但是（double a，int... c,int b)不可以
    // 3.数量可变类型不可变
    // 4.调用可变参数方法可以使用数组代替
    // 5.可变参数可以不传
    public static int sum(int... a){
        int sum=0;
        for(int item:a){
            sum+=item;
        }
        return sum;
    }


    //递归
    //阶乘
    public static int jiecheng(int num){
        if (num==1){
            return 1;
        }
        return num*jiecheng(num-1);
    }


}

2.冒泡排序

（外加1.方法中的在其他类中调用方法）

package com.text1;

import java.util.Arrays;

public class TextB1 {
    public static void main(String[] args) {
        //在其他类中调用TextA1类的方法
        //写明方法名和参数
        TextA1.printMax(12,34);
        int[] arr={45,31,88,71,43};
        maopaopaixu(arr);
        System.out.println(Arrays.toString(arr));

    }
    //冒泡排序
    public static void maopaopaixu(int[] arr){
        for (int j = 0; j <arr.length-1 ; j++) {
            //比较一趟  最大值到数组最后
            for (int i = 0; i <arr.length-1-j ; i++) {
                //前后两个相邻的元素比较
                //如果前面的元素大，就交换位置
                //要考虑数组越界问题，arr.length-1
                //内部-1-j避免重复冗余
                if (arr[i]>arr[i+1]){
                    int temp=arr[i];
                    arr[i]=arr[i+1];
                    arr[i+1]=temp;
                }
            }
        }
    }
}

3.类

类的定义属性方法实例化对象调用属性和方法构造方法默认构造方法

以staff为例：

package com.text1;

import java.math.BigDecimal;

public class Staff {
    //在类中定义属性
    //也叫全局变量
    String code;
    String sex;
    String name;
    double salary;
    //类中的方法可以直接调用本类中的属性
    public void work(){
        System.out.println(name+"正在工作");
    }
    //定义构造方法（重载）
    //1.没有返回值类型
    //2.方法名与类名一样
    //3.如果一个类没有定义任何一个构造方法，系统会给予一个默认的空的构造方法
    //4.类中一旦自定义了任意的构造方法，系统默认的构造方法就消失了
    Staff(){

    }
    //通过构造方法设置属性
    Staff(String name,String sex,String code ,double salary){
        //将参数name设置给name属性
        //就近原则 还是方法内的name
        //局部变量：在方法体或者代码块中声明的变量
        //全局变量：在类中定义的变量
        //在局部变量和全局变量重名的情况下，可以使用this关键字标注全局变量
        this.name=name;
        this.sex=sex;
        this.code=code;
        this.salary=salary;


    }


}

package com.text1;

public class TextStaff {
    public static void main(String[] args) {
        //实例化对象  开辟内存空间
        Staff staff = new Staff();
        //设置对象的属性   类中声明了哪些属性，对象中就有哪些属性
        staff.code="YG001";
        staff.name="张三";
        staff.sex="男";
        staff.salary=10000;
        Staff staffA = new Staff();
        staffA.code="YG002";
        staffA.name="李四";
        staffA.sex="女";
        staffA.salary=12000;
        //调用对象的方法
        staff.work();
        staffA.work();

    }
}

4.三大特性

封装继承多态
访问权限修饰符 extends 单继承方法重写 this super 子父类间构造方法调用
向上转型

package com.text1;

public class TextD1 {
    //继承   一个类继承父类，子类具有父类中定义好的属性和方法
    //不是所有的属性和方法都能调用到  public，protected 本包下的父类default可以
    //1.实现代码重用
    //2.多态实现的基础
    //注意：一个子类只能继承一个直接父类，java支持多重继承

    //向上转型
    public static void main(String[] args) {
        BigPlane bp=new BigPlane("1212","red");
        bp.code="1111";
        bp.fly();
        //调用方法看对象，调用属性看变量的声明
        Plane p=new BigPlane("1511","yellow");//向上转型,看p后面是哪个类，就执行哪个类的方法
        p.fly();//调用子类的方法

    }
}

class Plane{
    public Plane(String code,String color){
        this.code=code;
        this.color=color;
    }

    protected String code;//protected  子类  本包下可以访问到
    String color;
    public void fly(){
        System.out.println("飞机起飞");
    }

}
class BigPlane extends Plane {
    //子类继承父类

    //子类对父类中继承过来的方法重新定义----重写
    //属性不能重写
    //可以使用@override注解，来验证方法是否是重新的方法
    //注意：返回值，方法名，参数列表不能发生变化
    //重新的方法的访问权限只能更开放，不能更闭塞
    @Override
    public void fly(){//只能重写方法体，这一行不变
        System.out.println("大飞机起飞");

    }
    //子父类之间的构造方法
    public BigPlane(String code,String color){
        //子类的构造方法中，首行必须调用父类的构造方法，默认调用父类的无参构造方法
        //如果父类中没有无参构造方法，子类构造方法中必须明文声明调用父类哪一个构造方法
        //使用super关键字调用父类的构造方法
        super(code,color);
    }
}

静态多态
动态多态

package com.text1;

public class TextE1 {
    public static void main(String[] args) {
        int num=1;
        Parent p=getObj(num);//p这个变量可能指向任意一个子类的对象
        p.method();//多态调用方法时可能会出现多种结果
        //多态分类：
        //静态多态：重载造成，在类编译时就可以确定调用的时哪一个方法
        //动态多态：重写造成，只有在执行到该行代码，才能确定执行的是哪个类的方法
    }
    public static Parent getObj(int a){
        if (a==1){
            return new SonA();
        }else if (a==2){
            return new SonB();
        }else{
            return new Parent();
        }
    }
}
class Parent{
    public void method(){
        System.out.println("parent");
    }
}
class SonA extends Parent{
    public void method(){
        System.out.println("sonA");
    }
}
class SonB extends Parent{
    public void method(){
        System.out.println("sonB");
    }
}