07-21_01基础复习3

于 2021-07-21 23:02:44 发布
阅读量123 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Coco2cy/article/details/118978819
版权

问题：for循环加深 遍历 源码

static使用

  1. 静态变量（类变量）

    无论实例化多少变量，他的静态变量只有一份拷贝，局部变量不能被声明为static变量

  2. 静态方法

    静态方法不能使用类的非静态变量

final使用

final变量

final 修饰符通常和 static 修饰符一起使用来创建类常量

public class Test{
  final int value = 10;
  // 下面是声明常量的实例
  public static final int BOXWIDTH = 6;
  static final String TITLE = "Manager";
 
  public void changeValue(){
     value = 12; //将输出一个错误
  }
}

final方法

父类中的 final 方法可以被子类继承，但是不能被子类重写

声明 final 方法的主要目的是防止该方法的内容被修改

public class Test{
    public final void changeName(){
       // 方法体
    }
}

final类

final 类不能被继承，没有类能够继承 final 类的任何特性。

public final class Test {
   // 类体
}

抽象类

一个类不能同时被 abstract 和 final 修饰。

抽象类可以包含抽象方法和非抽象方法

条件运算符（?:）

也称三元运算符，该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

public class Test {
   public static void main(String[] args){
      int a , b;
      a = 10;
      // 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
      b = (a == 1) ? 20 : 30;
      System.out.println( "Value of b is : " +  b );
 
      // 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
      b = (a == 10) ? 20 : 30;
      System.out.println( "Value of b is : " + b );
   }
}


/**
Value of b is : 30
Value of b is : 20
*/

instanceof运算符

检查该对象是否是一个特定类型

String name = "James";
boolean result = name instanceof String;

class Vehicle {}
 
public class Car extends Vehicle {
   public static void main(String[] args){
      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      System.out.println( result);
   }
}

//ture

String类

–创建

  1. String str = “Runoob”;

  2. String str2 = new String(“Runoob”);

String 创建的字符串存储在公共池中

而 new 创建的字符串对象在堆上

在这里插入图片描述

数组

一维数组/多维数组

声明：

  1. int [] myList;
  2. int myList[];

创建数组：

  1. dataType[] arrayRefVar = new dataType[arraySize];
  2. dataType[] arrayRefVar = {value0,value1,…,valuek};
public class TestArray {
   public static void main(String[] args) {
      // 数组大小
      int size = 10;
      // 定义数组
      double[] myList = new double[size];
      myList[0] = 5.6;
      myList[1] = 4.5;
      myList[2] = 3.3;
      myList[3] = 13.2;
      myList[4] = 4.0;
      myList[5] = 34.33;
      myList[6] = 34.0;
      myList[7] = 45.45;
      myList[8] = 99.993;
      myList[9] = 11123;
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < size; i++) {
         total += myList[i];
      }
      System.out.println("总和为： " + total);
   }
}

//11367.373

在这里插入图片描述

Arrays工具：

​ sort排序

​ toString打印

package com.soft.demo01;

import java.util.Arrays;

public class Test02 {
    public static void main(String[] args) {
      
        //定义一乱顺序的数组
        int values[] = {3,2,1,4,23,9};
        //排序
        Arrays.sort(values);

        //把数组以字符串进行处理
        System.out.println(Arrays.toString(values));
    }
}

日期

new Date()

字符串与实践进行互转 SimpleDateFormat

时间戳 time-1970/1/1 计算函数执行的时长

Calender

package com.soft.demo01;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test03 {
    public static void main(String[] args) throws ParseException {
        /*//定义时间

        Date date = new Date();
        //打印
        System.out.println(date);*/


        //定义一个时间
        Date date = new Date();

        //定义时间格式化的类
        //ctrl+P:查看参数
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss");

        //把时间进行格式化
        System.out.println(simpleDateFormat.format(date));

        //字符串转成日期类
        //假设前端传过来一个json数据,数据中包括一个时间格式的字符串,把这个字符串转成我们的时间对象
        //定义时间字符串
        String dateStr = "2021-09-10";
        //定义一个时间格式化的类
        SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd");
        //使用时间格式化的类去解析我们的字符串生成一个时间对象
        Date parse = simpleDateFormat1.parse(dateStr);
        System.out.println(parse);


/**
2021年07月21日 10:23:45
Fri Sep 10 00:00:00 CST 2021
*/
    }
}

有关时间

sleep

package com.soft.demo01;

public class Test04 {

    public int addSum(int a, int b) {
        System.out.println("开始计算........");
        try {
            Thread.sleep(3000);//睡眠
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return a + b;
    }

    public static void main(String[] args) {
        //System.out.println("方法执行前"+System.currentTimeMillis());
        //开始时间
        long startTime = System.currentTimeMillis();
        int addSum = new Test04().addSum(100, 200);
       // System.out.println("方法执行后"+System.currentTimeMillis());
        long endTime = System.currentTimeMillis()- startTime;
        System.out.println("当前的方法执行时间:"+endTime/1000.0f);//小数位展示
        System.out.println(addSum);
    }
}

Calendar

package com.soft.demo01;

import java.util.Calendar;

public class Test05 {
    public static void main(String[] args) {
        //日历类
        Calendar instance = Calendar.getInstance();

        //操作我们的时间
        System.out.println(instance.get(Calendar.YEAR));
        System.out.println(instance.get(Calendar.MONTH)+1);//月份要加1
        System.out.println(instance.get(Calendar.DAY_OF_WEEK)-1);//星期日是起始位置

    }
}

正则表达式

作用：

  1. 校验格式是否正确
package com.soft.demo01;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test06 {
    public static void main(String[] args) {
        /*//正则,正则主要的作用是对字符串的操作
        //1.定义需要被匹配的字符串
        String str = "70";
        //2.定义匹配规则
        String regex = "8[0-9]";
        boolean matches = Pattern.matches(regex, str);

        //3.匹配的结果是什么
        System.out.println(matches);*/

        //使用字符串的正则方法去匹配
        //1.字符串

       /* String str = "hellO";
        //2.匹配的规则
        String regex = "[a-zA-Z]{3,5}";
        //3.结果
        boolean matches = str.matches(regex);
        System.out.println(matches);*/



        //使用编译模式
        //1.字符串
        String phoneStr = "13656789123";
        //2.规则第一位是1,第二位3578,后面9位没有四
        String regex = "1[3578][0-35-9]{9}";
        //3.complile进行编译会产生一个对象Pattern
        Pattern compile = Pattern.compile(regex);
        //4.初始化一个匹配器
        Matcher matcher = compile.matcher(phoneStr);
        //5.匹配
        boolean matches = matcher.matches();

        //6.结果处理
        System.out.println(matches);
    }
}


//true
  1. 替换
  2. 切割
package com.soft.demo01;

public class Test07 {
    public static void main(String[] args) {
//        替换全部----数据对象.replaceAll(规则)
        //1.原始数据
        String str = "3931aie1e1e01";
        //2.替换字母的规则
        String regex1 = "[a-zA-Z]+";//至少一个字母
        //3.替换
        System.out.println(str.replaceAll(regex1, ""));

        //String regex2 = "[0-9]+";

        String regex2 = "\\d+";//转义,把\转普通字符串
        System.out.println(str.replaceAll(regex2, ""));

        //进行切割---split
        String str3 = "oneTtowTthreeDfourJfive";

        String[] strings = str3.split("[A-Z]");
        for (String string : strings) {
            System.out.println(string);
        }


    }
}
/**
39311101
aieee
one
tow
three
four
five
*/

把正则规则看一下 [0-9] [\d] [\D] 大写的是取反

​ [1-5]+ +是后面还有

​ {3,4} 出现3次或4次

方法

定义格式

返回值，没有返回值void

形参与实参的关系

package com.soft.demo01;

public class Test10 {
    int a = 100;
    public void demo01(int a){
        a = 200;
    }

    public static void main(String[] args) {

        Test10 test10 = new Test10();
        System.out.println("前:"+test10.a);

        test10.demo01(test10.a);

        System.out.println("后:"+test10.a);


    }
}


/**
前:100
后:100
*/

package com.soft.demo01;

public class Test11 {

    public void demo01(Student student) {

        student.age = 100;
    }

    public static void main(String[] args) {
        Student student = new Student();
        student.age = 1;

        System.out.println(student);
        new Test11().demo01(student);

        System.out.println(student);

    }
}


/**
Student{age=1}
Student{age=100}
*/

可变参数…

package com.soft.demo01;

import java.util.Arrays;

public class Test12 {

    public void demo01(int[] ar) {
        ar[0] = 100;
    }

    //可变参数,当参数不确定的时候
    public void demo02(int... ints) {
        for (int anInt : ints) {
            System.out.println(anInt);
        }
    }

    public static void main(String[] args) {
        new Test12().demo02(1,2,3,4,5);
    }
    //1
    //2
    //3
    //4
    //5



  /*
  public static void main(String[] args) {

        int[] arr = {1, 2, 3};

        new Test12().demo01(arr);

        System.out.println(Arrays.toString(arr));

    }

    //[100, 2, 3]
    */
}

垃圾回收—gc()

package com.soft.demo01;

import java.text.SimpleDateFormat;

public class Test13 {
    public static void main(String[] args) {

        Test13 test13 = new Test13();
        test13 = null;//引用置空,可以更快的让系统回收

        //启动垃圾回收
        System.gc();

    }

    //类被回收的时候会调用的
    @Override
    protected void finalize() throws Throwable {
        super.finalize();

        System.out.println("类销毁回收资源");
    }
}

).demo01(arr);

    System.out.println(Arrays.toString(arr));

}

//[100, 2, 3]
*/

}






垃圾回收---gc()

```java
package com.soft.demo01;

import java.text.SimpleDateFormat;

public class Test13 {
    public static void main(String[] args) {

        Test13 test13 = new Test13();
        test13 = null;//引用置空,可以更快的让系统回收

        //启动垃圾回收
        System.gc();

    }

    //类被回收的时候会调用的
    @Override
    protected void finalize() throws Throwable {
        super.finalize();

        System.out.println("类销毁回收资源");
    }
}
爱因斯蛋
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值