JavaZoneId有哪些

转载

mob6454cc6cee7e 2024-09-09 17:48:42

文章标签 JavaZoneId有哪些学习超类派生类构造方法 文章分类 Java 后端开发

（九）Java中的方法

方法：所谓方法就是函数、过程，是语句的集合，它们在一起执行一个功能。

封装一段特定的业务逻辑功能
尽可能独立，一个方法只干一件事
方法可以被反复调用多次
可以减少代码重复，有利于代码维护
何时用：假设有一个功能，在很多地方都得使用，就将功能封装到一个方法

方法的定义：五要素

修饰词返回值类型方法名(参数列表){
方法体---具体的业务逻辑功能实现
}

//无参无返回值
public static void say(){
    System.out.println("大家好，我叫zhangsan，今年38岁了");
}

//有参无返回值
public static void sayHi(String name){ //形参
    System.out.println("大家好，我叫"+name+"，今年38岁了");
}

//有参无返回值
public static void sayHello(String name,int age){ //形参
    System.out.println("大家好，我叫"+name+"，今年"+age+"岁了");
}

//无参有返回值
public static double getNum(){
    //若方法有返回值，则在方法中必须出现return关键字
    //并且return后的数的类型必须与返回值类型匹配
    //return "abc"; //编译错误
    return 8.88; //1)结束方法的执行  2)返回结果给调用方
}

//有参有返回值
public static int plus(int num1,int num2){
    int num = num1+num2;
    return num; //返回的是num里面的那个数
    //return num1+num2; //返回的是num1与num2的和
}

//无参有返回值
public static int[] testArray(){
    int[] arr = new int[10];
    for(int i=0;i<arr.length;i++){
        arr[i] = (int)(Math.random()*100);
    }
    return arr;
}

方法的调用：

无返回值：方法名(有参传参)

public class MethodDemo {
    public static void main(String[] args) {
        say(); //调用say()方法

        //sayHi(); //编译错误，有参则必须传参
        //sayHi(250); //编译错误，参数类型必须匹配
        sayHi("zhangsan"); //String name="zhangsan"  //实参
        sayHi("lisi"); //String name="lisi"          //实参
        sayHi("wangwu"); //String name="wangwu"      //实参

        sayHello("zhangsan",25); //实参 String name="zhangsan",int age=25
        sayHello("lisi",24); //实参
    }
}

有返回值：数据类型变量 = 方法名(有参传参);

//方法的演示
public class MethodDemo {
    public static void main(String[] args) {
        double a = getNum(); //getNum()的值就是return后的那个数
        System.out.println(a); //8.88，模拟对返回值的后续操作

        int b = plus(5,6); //plus(5,6)的值就是return后的那个数
        System.out.println(b); //11，模拟对返回值的后续操作

        int m=5,n=6;
        int c = plus(m,n); //传递的是m和n里面的数
        System.out.println(c); //11，模拟对返回值的后续操作

        int[] d = testArray();
        System.out.println("长度为:"+d.length); //10，模拟对返回值的后续操作
        for(int i=0;i<d.length;i++){ //模拟对返回值的后续操作
            System.out.println(d[i]);
        }
    }
}

return

return 值; //1) 结束方法的执行 2) 返回结果给调用方-------用在有返回值的方法中
return; //1) 结束方法的执行--------------用在无返回值的方法

(十）Java中的类和对象

什么是类？什么是对象?

现实生活是由很多很多对象组成的，基于对象抽出了类
对象：软件中真实存在的单个个体/东西
类：类型/类别，代表一类个体
类是对象的模板，对象是类的具体的实例
类中可以包含：

对象的属性/特征-----------------------------成员变量
对象的行为/动作/功能---------------------方法

一个类可以创建多个对象

如何创建类？如何创建对象？如何访问成员？

//创建类:
public class Student {
    //成员变量
    String name;
    int age;
    String address;
    //方法
    void study(){
        System.out.println(name+"在学习...");
    }
    void sayHi(){
        System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);
    }
}

//创建对象:
public class StudentTest {
    public static void main(String[] args) {
        //创建一个学生对象
        Student zs = new Student();
        //访问成员变量
        zs.name = "zhangsan";
        zs.age = 25;
        zs.address = "河北廊坊";
        //调用方法
        zs.study();
        zs.sayHi();

        Student ls = new Student();
        ls.name = "lisi";
        ls.age = 27;
        ls.address = "黑龙江佳木斯";
        ls.study();
        ls.sayHi();

        //1)创建了一个学生对象
        //2)给所有成员变量赋默认值
        Student ww = new Student();
        ww.study();
        ww.sayHi();
    }
}

方法的签名：方法名+参数列表
方法的重载(overload/overloading)：-------------------更方便方法的调用

发生在同一类中，方法名相同，参数列表不同
编译器在编译时会根据方法的签名自动绑定方法

//演示方法的重载
class Aoo{
    void show(){}
    void show(String name){}
    void show(int age){}
    void show(String name,int age){}
    void show(int age,String name){}
    //int show(){ return 1; } //编译错误，重载与返回值类型无关
    //void show(String address){} //编译错误，重载与参数名称无关
}

//演示重载方法的调用
public class OverloadDemo {
    public static void main(String[] args) {
        Aoo o = new Aoo();
        o.show();
        o.show("zhangsan");
        o.show(25);
        o.show("zhangsan",25);
        o.show(25,"zhangsan");
    }
}

（十一）构造方法

构造方法：构造函数、构造器、构建器----------------复用给成员变量初始化代码

作用：给成员变量赋初始值
与类同名，没有返回值类型(连void都没有)
在创建(new)对象时被自动调用
若自己不写构造方法，则编译器默认提供一个无参构造方法
若自己写了构造方法，则不再默认提供
构造方法可以重载

this：指代当前对象，哪个对象调用方法它指的就是哪个对象，只能用在方法中，方法中访问成员变量之前默认有个this

this的用法：

this.成员变量名------访问成员变量

当成员变量和局部变量同名时，若想访问成员变量则this不能省略，其它一般省略

this.方法名()------调用方法(一般不用，了解)
this()------调用构造方法(一般不用，了解)

构造方法和this的演示

class Student {
    //成员变量
    String name;
    int age;
    String address;
    //构造方法
    Student(String name,int age,String address){
        this.name = name;       //zs.name="zhangsan"
        this.age = age;         //zs.age=25
        this.address = address; //zs.address="LF"
    }

    //方法
    void study(){
        System.out.println(name+"在学习...");
    }
    void sayHi(){
        System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);
    }
}

//构造方法和this的演示
public class ConsDemo {
    public static void main(String[] args) {
        //Student zs = new Student(); //编译错误，Student类没有无参构造
        Student zs = new Student("zhangsan",25,"LF");
        Student ls = new Student("lisi",26,"JMS");
        zs.sayHi();
        ls.sayHi();
    }
}

null：表示空，没有指向任何对象。若引用的值为null，则该引用不能再进行任何点操作了，若操作则发生NullPointerException空指针异常。

（十二）Java中的继承

继承的概念：继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

继承：

作用：代码复用，通过extends来实现继承
超类/父类：共有的属性和行为
派生类/子类：特有的属性和行为
派生类可以访问：派生类的+超类的，而超类不能访问派生类的
一个超类可以有多个派生类，但一个派生类只能继承一个超类------即单一继承
继承具有传递性
Java规定：构造派生类之前必须先构造超类

在派生类构造方法中若没有调用超类构造方法，则默认super()调超类无参构造方法
在派生类构造方法中若自己调用了超类构造方法，则不再默认提供

注意：super()调用超类构造方法，必须位于派生类构造方法的第一行

super：指代当前对象的超类对象

super的用法：
super.成员变量名------------------------访问超类的成员变量(一般不用，了解)
super.方法名()----------------------------调用超类的方法
super()--------------------------------------调用超类的构造方法

public class SuperDemo {
    public static void main(String[] args) {
        Boo o = new Boo();
    }
}

class Aoo{
    Aoo(){
        System.out.println("超类构造...");
    }
}
class Boo extends Aoo{
    Boo(){
        //super(); //默认的，写不写都在
        System.out.println("派生类构造...");
    }
}

class Coo{
    Coo(int a){
    }
}
class Doo extends Coo{
    Doo(){
        super(5); //调用超类的有参构造
    }
    /*
    //如下代码为默认的
    Doo(){
        super(); //超类若没有无参构造，则编译错误
    }
     */
}

（十三）向上造型和重写

向上造型：

超类型的引用指向派生类的对象
能点出来什么，看引用的类型

public class UploadDemo {
    public static void main(String[] args) {
        Aoo o1 = new Aoo();
        o1.a = 1;
        o1.show();
        //o1.b = 2;  //编译错误，超类不能访问派生类的
        //o2.test(); //编译错误

        Boo o2 = new Boo();
        o2.b = 1;
        o2.test();
        o2.a = 2;  //正确，派生类可以访问超类的
        o2.show(); //正确

        Aoo o3 = new Boo(); //向上造型
        o3.a = 1;
        o3.show();
        //o3.b = 2;  //编译错误，能点出来什么，看引用的类型
        //o3.test(); //编译错误
    }
}

class Aoo{
    int a;
    void show(){
    }
}
class Boo extends Aoo{
    int b;
    void test(){
    }
}