Java学习笔记20200107

最新推荐文章于 2022-06-17 23:11:32 发布

「已注销」

最新推荐文章于 2022-06-17 23:11:32 发布

阅读量110

点赞数

分类专栏：笔记

本文链接：https://blog.csdn.net/Anxon/article/details/103865862

版权

笔记专栏收录该内容

7 篇文章 0 订阅

订阅专栏

Static

/*
如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类。多个对象共享同一份数据。
 */
	public class Demo01StaticField {

    public static void main(String[] args) {

        Student two = new Student("黄蓉", 16);
        two.room = "101教室";
        System.out.println("姓名：" + two.getName()
                + "，年龄：" + two.getAge() + "，教室：" + two.room
                + "，学号：" + two.getId());

        Student one = new Student("郭靖", 19);
        System.out.println("姓名：" + one.getName()
                + "，年龄：" + one.getAge() + "，教室：" + one.room
                + "，学号：" + one.getId());
    }
}

===================
	private int id; // 学号
    private String name; // 姓名
    private int age; // 年龄
    static String room; // 所在教室
    private static int idCounter = 0; // 学号计数器，每当new了一个新对象的时候，计数器++

    public Student() {
        this.id = ++idCounter;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.id = ++idCounter;
    }

/*
一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。

如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。

无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用。
静态变量：类名称.静态变量
静态方法：类名称.静态方法()

注意事项：
1. 静态不能直接访问非静态。
原因：因为在内存当中是【先】有的静态内容，【后】有的非静态内容。
“先人不知道后人，但是后人知道先人。”
2. 静态方法当中不能用this。
原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。
 */
	public class Demo02StaticMethod {

    public static void main(String[] args) {
        MyClass obj = new MyClass(); // 首先创建对象
        // 然后才能使用没有static关键字的内容
        obj.method();

        // 对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用。
        obj.methodStatic(); // 正确，不推荐，这种写法在编译之后也会被javac翻译成为“类名称.静态方法名”
        MyClass.methodStatic(); // 正确，推荐

        // 对于本来当中的静态方法，可以省略类名称
        myMethod();
        Demo02StaticMethod.myMethod(); // 完全等效
    }

    public static void myMethod() {
        System.out.println("自己的方法！");
    }
}

静态static的内存图
在这里插入图片描述
静态代码块

Arrays

/*
java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。
public static String toString(数组)：将参数数组变成字符串（按照默认格式：[元素1, 元素2, 元素3...]）
public static void sort(数组)：按照默认升序（从小到大）对数组的元素进行排序。
备注：
1. 如果是数值，sort默认按照升序从小到大
2. 如果是字符串，sort默认按照字母升序
3. 如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。（今后学习）
 */
	public class Demo01Arrays {
    public static void main(String[] args) {
        int[] intArray = {10, 20, 30};
        // 将int[]数组按照默认格式变成字符串
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr); // [10, 20, 30]
        int[] array1 = {2, 1, 3, 10, 6};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1)); // [1, 2, 3, 6, 10]
        String[] array2 = {"bbb", "aaa", "ccc"};
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2)); // [aaa, bbb, ccc]
    }
}

字符串倒序
在这里插入图片描述

Math

在这里插入图片描述
练习题

/*
题目：
计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个？
分析：
1. 既然已经确定了范围，for循环
2. 起点位置-10.8应该转换成为-10，两种办法：
    2.1 可以使用Math.ceil方法，向上（向正方向）取整
    2.2 强转成为int，自动舍弃所有小数位
3. 每一个数字都是整数，所以步进表达式应该是num++，这样每次都是+1的。
4. 如何拿到绝对值：Math.abs方法。
5. 一旦发现了一个数字，需要让计数器++进行统计。

备注：如果使用Math.ceil方法，-10.8可以变成-10.0。注意double也是可以进行++的。
 */
public class DemoMathPractise {
    public static void main(String[] args) {
        int count = 0;
        double min = -10.8;
        double max = 5.9;
        for (int i = (int)min; i <= (int)max; i++) {
            int abs = Math.abs(i);
            if (abs > 6 || abs < 2.1) {
                count++;
            }
        }
        System.out.println(count);
    }
}

继承 extends

/*
在继承的关系中，“子类就是一个父类”。也就是说，子类可以被当做父类看待。
例如父类是员工，子类是讲师，那么“讲师就是一个员工”。关系：is-a。

定义父类的格式：（一个普通的类定义）
public class 父类名称 {
    // ...
}

定义子类的格式：
public class 子类名称 extends 父类名称 {
    // ...
}
*/
	public class Demo01Extends {
    public static void main(String[] args) {
        // 创建了一个子类对象
        Teacher teacher = new Teacher();
        // Teacher类当中虽然什么都没写，但是会继承来自父类的method方法。
        teacher.method();
        // 创建另一个子类助教的对象
        Assistant assistant = new Assistant();
        assistant.method();
    }
}

成员变量访问特点

/*
在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：

直接通过子类对象访问成员变量：
    等号左边是谁，就优先用谁，没有则向上找。
间接通过成员方法访问成员变量：
    该方法属于谁，就优先用谁，没有则向上找。
 */
	public class Demo01ExtendsField {
    public static void main(String[] args) {
        Fu fu = new Fu(); // 创建父类对象
        System.out.println(fu.numFu); // 只能使用父类的东西，没有任何子类内容
        System.out.println("===========");
        Zi zi = new Zi();
        System.out.println(zi.numFu); // 10
        System.out.println(zi.numZi); // 20
        System.out.println("===========");
        // 等号左边是谁，就优先用谁
        System.out.println(zi.num); // 优先子类，200
//        System.out.println(zi.abc); // 到处都没有，编译报错！
        System.out.println("===========");
        // 这个方法是子类的，优先用子类的，没有再向上找
        zi.methodZi(); // 200
        // 这个方法是在父类当中定义的，
        zi.methodFu(); // 100
    }
}

类方法中重名的处理

/*
局部变量：         直接写成员变量名
本类的成员变量：    this.成员变量名
父类的成员变量：    super.成员变量名
 */
	public class ExtendsField {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();
    }
}
//===============================
	public class Fu {
    int num = 30;
    public void methodFu(){
        int num = 99;
        System.out.println(num);
    }
}
//===============================
	public class Zi extends Fu {
    int num = 10;
    public void method() {
        int num = 20;
        System.out.println(num); //20,局部变量
        System.out.println(this.num); //10,类成员变量
        System.out.println(super.num); //30,父类成员变量
        methodFu();
    }
}

覆盖重写

/*
在父子类的继承关系当中，创建子类对象，访问成员方法的规则：
    创建的对象是谁，就优先用谁，如果没有则向上找。

注意事项：
无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。
重写（Override）
概念：在继承关系当中，方法的名称一样，参数列表也一样。
重写（Override）：方法的名称一样，参数列表【也一样】。覆盖、覆写。
重载（Overload）：方法的名称一样，参数列表【不一样】。
方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。

方法覆盖重写的注意事项：

1. 必须保证父子类之间方法的名称相同，参数列表也相同。
@Override：写在方法前面，用来检测是不是有效的正确覆盖重写。
这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。

2. 子类方法的返回值必须【小于等于】父类方法的返回值范围。
小扩展提示：java.lang.Object类是所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类。

3. 子类方法的权限必须【大于等于】父类方法的权限修饰符。
小扩展提示：public > protected > (default) > private
备注：(default)不是关键字default，而是什么都不写，留空。
*/
	public class Demo01ExtendsMethod {

    public static void main(String[] args) {
        Zi zi = new Zi();

        zi.methodFu();
        zi.methodZi();

        // 创建的是new了子类对象，所以优先用子类方法
        zi.method();
    }
}
=============================
	public class Fu {
    public void methodFu() {
        System.out.println("父类方法执行！");
    }
    void method() {
   		System.out.println("功能");
        System.out.println("父类重名方法执行！");
    }
==============================
	public class Zi extends Fu {
    
     public void methodZi() {
        System.out.println("子类方法执行！");
    }
    @Override
    public void method() {
    	super.method();
        System.out.println("子类重名方法执行！");
    }
    }
}
/*
继承关系中,父子类构造方法的访问特点
1.子类构造方法中有一个默认隐含的"super()"调用,所以一定是先调用
    父类构造
2.可子类构造通过super关键字调用父类重载构造
3.super的父类构造调用,必须是子类构造方法的第一个语句
    不能一个子类构造调用多次super构造
总结:
子类必须调用父类构造方法,不写则赠送super();写了则用写的指定的super调用,
super只能有一个,必须是第一个
 */

/*
 super关键字的用法有三种:
 1. 在子类的成员方法中,访问父类的成员变量
 2. 在子类的成员方法中,访问父类的成员方法
 3. 在子类的构造方法中,访问父类的构造方法
 */
/*
super关键字用来访问父类内容,而this关键字用来访问本类内容
用法有三种
1.在本类的成员方法中,访问本类的成员变量
2.在本类中的成员方法中,访问本类的另一个成员方法
3.在本类的构造方法中,访问本类的另一个构造方法
在第三种用法当中注意:
A.this(...)调用也必须是构造方法的第一个语句,唯一一个
B.super 和 this 两种构造调用,不能同时使用
 */
public class Zi extends Fu {
    int num = 20;

    public Zi() {
//        super();  //这一行不在赠送
         
          this(123); //本类的无参构造,调用本类的有参构造
//        this(1,2); // 错误写法
    }
    public Zi(int n) {
    }
    public Zi(int n, int m) {
    }

在这里插入图片描述

/*
抽象方法:就是加上abstract关键字,然后去掉大括号,直接分号结束
抽象类:抽象方法所在的类,必须是抽象类才行
在class之前写上abstract即可
如何使用抽象类和抽象方法:
1.不能直接创建new抽象类对象
2.必须用一个子类继承抽象父类
3.子类必须覆盖重写抽象父类当中所有的抽象方法
覆盖重写(实现):子类去掉抽象方法的abstract关键字,然后补上方法体
大括号
4.创建子类对象进行使用
 */
public abstract class Animal {
    // 这是一个抽象方法,代表吃东西,但是具体吃什么不确定
    public abstract void eat();
    //普通的成员方法
    public void normalMethod(){
    }
}

Alt + 回车 -->实现方法快速填充子类重写方法

public class DemoMain {
    public static void main(String[] args) {
        DogGolden golden = new DogGolden();
        golden.sleep();//呼呼呼...
        golden.eat();//吃骨头
    }
}
======================================
public abstract class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("吃骨头");
    }
}
======================================
public class DogGolden extends Dog{
    @Override
    public void sleep() {
        System.out.println("呼呼呼...");
    }
}
======================================
public class Dog2Ha extends Dog {

    @Override
    public void sleep() {
        System.out.println("偶偶偶...");
    }
}

// 主程序
public static void main(String[] args) {
        Manager manager = new Manager("群主",99);
        Member one =  new Member("成员A",0);
        Member two =  new Member("成员B",0);
        Member three =  new Member("成员C",0);

        manager.show();
        one.show();
        two.show();
        three.show();
        System.out.println("===============");

        ArrayList<Integer> redList =  manager.send(9,6);

        one.receive(redList);
        two.receive(redList);
        three.receive(redList);

        manager.show();
        one.show();
        two.show();
        three.show();
    }

//User
public class User {
    private String name;//姓名
    private double money;//余额

    public User() {
    }

    public User(String name, double money) {
        this.name = name;
        this.money = money;
    }
    //展示一下当前用户多少钱
    public void show(){
        System.out.println("我叫"+this.name+",我有" +this.money+"钱");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

//群主
public class Manager extends User {
    public Manager() {

    }

    public Manager(String name, double money) {
        super(name, money);
    }

    public ArrayList<Integer> send(int totalMoney, int count) {
        //需要一个集合,存储若干个红包的金额
        ArrayList<Integer> redList = new ArrayList<>();
        //查看余额有多少钱,判断发送金额是否超过余额
        double leftMoney = super.getMoney(); //群主当前余额
        if (totalMoney > leftMoney) {
            System.out.println("余额不足");
            return redList;//返回空集合
        }
        //扣钱,设置余额
        super.setMoney(leftMoney - totalMoney);
        //发红包,拆分成count份
        int avg =totalMoney / count;
        int mod =totalMoney % count;//余数

        for (int i = 0; i < count-1; i++) {
            redList.add(avg);
        }
        redList.add(avg+mod);
        return redList;//返回这个集合
    }
}
//成员
public class Member extends User {
    public Member(){
    }
    public Member(String name, double money) {
        super(name, money);
    }
    public void receive(ArrayList<Integer> list){
        //从多个红包中抽取一个
        int index =  new Random().nextInt(list.size());
        //根据索引,从集合中删除,并且得到删除的红包
        int delta = list.remove(index);
        //设置金额
        super.setMoney(delta+super.getMoney(););
    }
}

「已注销」

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习笔记20200107

Static/*如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类。多个对象共享同一份数据。 */ public class Demo01StaticField { public static void main(String[] args) { Student two = new Student("黄蓉", 16); ...
复制链接

扫一扫