java学习笔记3(datawhale教程)

Posted 临风而眠

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java学习笔记3(datawhale教程)相关的知识，希望对你有一定的参考价值。

java学习笔记3(datawhale教程):类与方法,继承与多态,抽象类与接口

文章目录

一.类与方法

1.类与对象

  • JAVA源程序由若干个类组成，类是用来创建对象的模板

  • 类的实现包括：类声明class 类名和类体(大括号里的内容)

    class 类名 {
	//类的成员变量
	//类的成员方法
	//类体的内容等
}

2.成员变量

  • Java中对象属性也称为成员变量

    • 定义语法与普通变量一样

      package com.apache.test;
public class Bird {
    String wing;
    String claw; //爪子
    String beal; //喙
    String feather; //羽毛
}

      成员变量可以赋值初始化，也可以不设置，不设置的话会有默认值

3.成员方法

语法格式

[权限修饰符] [返回值类型]方法名([参数类型 参数名])[throws 异常类型]{
    //方法体
    return 返回值;
}
  • 选线修饰符：private、public、protected
  • 返回值类型
    • 无返回值 void
    • 有返回值：返回值类型用于指定方法返回数据的类型
  • 参数
    • 有参数
      • 可以是对象
      • 也可以是基本数据类型的变量
    • 无参数

来看例子

注意方法的定义必须在类中，如果没有指定权限修饰符，方法默认访问权限为缺省（即只能在本类及同一个包中的类中进行访问）

来个商店类

package com.apache.test;

public class Store {
    public void showGoods(){
        System.out.println("库存商品信息:");
    }
    public int showGoods2(){
        System.out.println("库存商品信息:");
        return 1;
    }
}

成员方法的参数

  • 传给方法的是实参，方法内部接收实参变量的是形参

    形参声明语法与变量声明语法一样

值参数

  • 按值传递，方法中对形参的改变不影响实参

  • 例：计算箱子里书的数量

    • 书架上有30本书，箱子里有40本书，把书架上的书全部放进箱子后，使用带参数的成员方法计算箱子里
      书的总数

      package com.apache.test;

public class Book {
    public static void main(String[] args) {
        Book book1 = new Book(); //创建书类对象
        int shelf = 30; //实参：书架上书的本数
        int box = 40; //实参：箱子里书的本数

        System.out.println("把书架上的书全部放进箱子后，箱子里一共有"
+ book1.add(shelf, box) + "本书。\\n明细如下：书架上"
+ shelf + "本书，箱子里原有" + box + "本书。");

    }
    private int add(int shelf,int box){ //把书架和箱子里的书相加求和
        box = box + shelf;
        return box; //返回箱子里的书
    }
}

      可以看出实参box没有被改变

引用参数

  • 如果在给方法传递参数时，参数的类型是数组或者其他引用类型，那么，在方法中对参数的修改会
    反映到原有的数组或者其他引用类型上，这种类型的方法参数被称之为引用参数。

  • 例：汇率转换

    package com.apache.test;

public class ExchangeRate {
    public static void main(String[] args) {
        ExchangeRate rate = new ExchangeRate();
        double[] denomination = {1,10,100}; //面额
        //输出数组中元素
        System.out.print("美元:");
        for(int i = 0; i<denomination.length;i++){
            System.out.print(denomination[i]+"美元 ");
        }

        rate.change(denomination);

        System.out.print("\\n人民币：");
        for(int i = 0; i<denomination.length;i++){
            System.out.print(denomination[i]+"元 ");
        }
    }
    //形参为一维数组
    public void change(double[] arr){
        for(int j = 0; j < arr.length; j++) { //for循环遍历数组
            arr[j] = arr[j] * 6.903; //数组中元素汇率转换
        }

    }
}

不定长参数

4.构造方法

  • 构造方法是一种特殊类型方法 与类同名

  • 对象的创建就是通过构造方法完成的

  • 类实例化一个对象时，类都会自动调用构造方法

  • 构造方法的特点

    • 无返回类型，但不能定义为void
    • 主要作用是完成对象初始化工作，把能定义对象的参数传给对象成员

  • 无参构造：

    public class Book {
    public Book() {
        //无参构造

    }
}

  • 有参构造

    package com.apache.test;

public class Store {
    public Store(int args) {
        //有参构造

    }
    public void showGoods(){
        System.out.println("库存商品信息:");
    }
    public int showGoods2(){
        System.out.println("库存商品信息:");
        return 1;
    }
}

  • 如果类中没有明确定义构造方法，则编译器会自动创建一个不带参数的默认构造方法

  • 如果在类中都是有参构造方法，则编译器不会为类自动生成一个默认的无参构造方法，当试图调用无参构造方法实例化一个对象时，编译器会报错。

    所以只有在类中没有定义任何
    构造方法时，编译器才会在该类中自动创建一个不带参数的构造方法。

  • 例子：借一本经典Java教程：《Java编程思想》

    package com.apache.test;

public class BorrowABook {
    public BorrowABook() {
        //无参构造
    }
    public void borrow(String name) { //参数为借的书名
        System.out.println("您已借阅"+name);

    }
    public static void main(String[] args) {
        BorrowABook book2 = new BorrowABook();
        book2.borrow("《Java编程思想》");
    }
}

5.this关键字

  • 如果类的成员变量与成员方法中的参数重名时，会发生啥问题捏？

    看看这个例子，输出的是abc还是123

    package com.apache.test;

public class Book {
    String name = "abc";
    public void showName(String name) {
        System.out.println(name);
    }
    public static void main(String[] args) {
        Book book = new Book();
        book.showName("123");
    }
}

    输出的是123，说明方法中如果出现了与局部变量同名的参数，会使得方法无法直接使用成员变量

  • 因此需要有区分的途径

    Java规定使用this关键字代表本类对象的引用，this关键字被隐式地用于引用对象的成员变量和方法

  • 例：调用书名属性

    package com.apache.test;

public class BorrowABook {
    String name;
    public BorrowABook(String name){
        this.name = name; // 将参数name的值付给属性name
    }
    public void borrow() { //参数为借的书名
        //下面这个地方name或this.name都能输出
//        System.out.println("您已借阅"+name+"。 ");
        System.out.println("您已借阅"+this.name+"。 ");
    }
    public static void main(String[] args) {
        BorrowABook book2 = new BorrowABook("《Java编程思想》");
        book2.borrow();
    }
}

  • this关键字引用的是本类的一个对象，在局部变量或方法参数覆盖了成员变量时，就需要添加this关键字明确引用的是类成员还是局部变量或方法参数

  • this关键字除了可以调用成员变量或成员方法之外，还可以作为方法的返回值

    package com.apache.test;

public class Book {
    public Book getBook(){
        return this;
    }
}

    在 getBook()方法中，方法的返回值为Book类，所以方法体中使用return this 这种形式将Book类的对象进行返回

6.static关键字

静态关键字可以与类、变量、方法和块一起使用。静态成员属于类而不是特定实例，这意味着如果将成员设为静态，则无需对象即可访问它

  • 类的静态成员

    • static修饰的变量：静态变量
    • static修饰的常量：静态常量
    • static修饰的方法：静态方法

  • 举个小栗子

    package com.apache.test;

import java.util.Arrays; //导入java.util.Arrays类

public class HelloWorld {
    /**
     * @paramargs
     */
    static void myMethod() {
        System.out.println("myMethod");
    }

    public static void main(String[] args)
    {

        myMethod();
    }
}

  • 实例

    package com.apache.test;

public class Pool {
    public static int water = 0;//初始化静态变量水池中的水量为0

    public static void outlet() {
        //放水,一次放出两个单位
        if (water >= 2) {
            //如果水池中的水量大于等于2个单位
            water = water - 2;
        } else {
            water = 0;
        }
    }

    public static void inlet() {
        water += 3;
    }

    public static void main(String[] args) {
//        Pool Pool1 = new Pool();
//        Pool Pool2 = new Pool();
        System.out.println("水池的水量：" + Pool.water); // 输出水池当前水量
        System.out.println("水池注水两次。");
        Pool.inlet(); // 调用静态的注水方法
        Pool.inlet(); // 调用静态的注水方法
        System.out.println("水池的水量：" + Pool.water); // 输出水池当前水量
        System.out.println("水池放水一次。");
        Pool.outlet(); // 调用静态的放水方法
        System.out.println("水池的水量：" + Pool.water); // 输出水池当前水量
    }
}

静态代码块

  • 在类的成员方法之外，用static修饰代码区域可以称之为静态代码块

    定义一块静态代码块，可以完成类的初始化操作，在类声明时就会运行，语法如下：

    public class StaticTest {
    static {// 此处编辑执行语句
    }
}

  • 实例：代码块执行顺序

    创建静态代码块、非静态代码块、构造方法、成员方法，看看这几处代码的调用顺序，代码如下

    package com.apache.test;

public class StaticTest {
    static String name;

    //静态代码块
    static {
        System.out.println(name + "静态代码块");
    }

    //非静态代码块
    {
        System.out.println(name + "非静态代码块");
    }

    public StaticTest(String a) {
        name = a;
        System.out.println(name + "构造方法");
    }

    public void method() {
        System.out.println(name + "成员方法");
    }

    public static void main(String[] args) {
        StaticTest s1;  //声明的时候就开始运行静态代码块了
        StaticTest s2 = new StaticTest("s2"); //new的时候才会运行构造方法
        StaticTest s3 = new StaticTest("s3");
        s3.method(); //只有调用才运行

    }
}

    关于各代码块之间的执行顺序，可以看这位大佬的博客👉here

类的主方法

  • 之前一直在用，但还没有研究过那个到底是啥意思

    可以看看这个public static void main(String[] args) 是什么意思?

  • 主方法的语法：

    public static void main(String[] args) {
    	//方法体
}

  • 主方法特性

    • 主方法是静态的，如果要直接在主方法中调用其他方法，那么被调用的方法也要是静态的
    • 主方法无返回值
    • 主方法的形参为数组，其中args[0]~args[n]分别代表程序的第一个参数到第n+1个参数，可以用 args.length 获取参数的个数

二.继承与多态

继承

1.继承的基本语法

  • 学过C++，了解概念，来看看Java里面的格式要求

    class 父类 {

}

class 子类 extends 父类 {

}

  • 看个例子

    公共父类动物类

    package com.apache.test;

public class Animal {
    private String name;
    private int id;

    public Animal(String myName) {
        name = myName;
    }

    public void eat() {
        System.out.println(name + "正在吃");

    }

    public void sleep() {
        System.out.println(name + "正在睡");
    }

    public void introduction() {
        System.out.println("我是" + name + ".");
    }
}

    子类兔子类

    package com.apache.test;

public class rabbit extends Animal {
    public rabbit(String myName) {
        super(myName);
    }
}

    子类老虎类

    package com.apache.test;

public class tiger extends Animal {
    public tiger(String myName) {
        super(myName);
    }
}

    tips:InteliJ IDEA 如何创建子类？

2.继承类型

  • Java支持下面几种

    • 单继承

      public class A {
	...
}
public class B extends A {
	...
}

    • 多重继承

      • 子类还有子类

        public class A { ... }
public class B extends A { ... }
public class C extends B { ... }

    • 不同类继承同一个类

      • 多个子类继承一个父类

  • Java不支持多继承

    • 即一个类继承多个类

3.继承关键字

extends

前面所示

implements

Java不支持多继承，但用implements可以实现多个接口，相当于使得Java有多继承的特性

public interface if1 {
    public void method1();
}
public interface if2 {
    public void method2();
}
public class if3 implements if1,if2 {
    @Override
    public void method1() {
        
    }

    @Override
    public void method2() {

    }
}

参考：在IDEA中创建接口

  • 创建接口

  • 选中，然后按alt+enter可以快捷继承

super与this

  • super : 引用当前对象的父类成员
  • this ：指向当前类的引用
public class Father {
    void method() {
        System.out.println("父类");
    }

}
class Son extends Father {
    void method() {
        System.out.println("子类");
    }

    void diff_method() {
        this.method()java学习笔记1(datawhale教程):基本数据类型与变量


 强化学习教程来啦！贡献者来自中科院清华北大3位男神！


 吃瓜教程——datawhale10月组队学习


 吃瓜教程——datawhale10月组队学习


 吃瓜教程——datawhale10月组队学习


 Datawhale powerful-numpy《从小白到入门》学习笔记