JAVA小白学习日记Day3

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");
    }
}