JAVA学习笔记1-变量和工具类

最新推荐文章于 2022-09-03 16:08:30 发布

王木木~~

最新推荐文章于 2022-09-03 16:08:30 发布

阅读量166

点赞数

分类专栏： JAVA 文章标签： java eclipse

本文链接：https://blog.csdn.net/qq_39008113/article/details/119460887

版权

JAVA 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

Txt修改为java文件问题解决办法：查看中：文件扩展名勾选，再修改
编码问题，我们可以使用javac -encoding UTF-8 HelloWorld.java
编写 Java 程序时，应注意以下几点：大小写敏感；类名的首字母应该大写；所有的方法名都应该以小写字母开头；源文件名必须和类名相同；所有的 Java 程序由 public static void main(String[] args) 方法开始执行；
Java 标识符：所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始；首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合
Java修饰符：修饰类中方法和属性。主要有两类修饰符：访问控制修饰符 : default, public , protected, private；非访问控制修饰符 : final, abstract, static, synchronized
Java 中主要有如下几种类型的变量局部变量、类变量（静态变量）、成员变量（非静态变量）

枚举

Calss FreshJuice{
Enum FrechJuiceSize{Small,Medium,Large}

FreshJuiceSize size;

}

Public class FreshJuice{

Public static void main(String[] args){

FreshJuice juice=new FreshJuice();

Juice.size=FreshJuice.FreshJuiceSize.Medium;

}
}

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。
每个类都有构造方法。如果没有显式地为类定义构造方法，Java 编译器将会为该类提供一个默认构造方法。在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。
创建对象声明：对象类型对象名实例化：new 类型(参数) 初始化:new调用构造方法初始化对象
import java.io.*; 编译器载入 java_installation/java/io 路径下的所有类
变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间。Java 的两大数据类型:内置数据类型、引用数据类型
八种基本类型。六种数字类型（四个整数型byte\short\long\int，两个浮点型double\float），一种字符类型char，还有一种布尔型boolean
变量声明：type identifier
实例变量public对子类可见；private 仅在该类中可见；
静态变量初始化后不可改变。
数值型变量默认值是 0，布尔型默认值是 false，引用类型默认值是 null。
静态变量可以通过：ClassName.VariableName的方式访问。
类变量被声明为 public static final 类型时，类变量名称一般建议使用大写字母。如果静态变量不是 public 和 final 类型，其命名方式与实例变量以及局部变量的命名方式一致。
访问修饰符：Default:在同一包中可见；Private:在同一类中可见，不可修饰类；Public:对所有类可见；Proteced:对同一包内的类和所有子类可见，不可修饰类；
接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。变量和方法的声明可以不使用任何修饰符。
类和接口不能声明为 private; 声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。get~() （返回值）set~(String)（设置值）
Java 程序的 main() 方法必须设置成公有的，否则，Java 解释器将不能运行该类。
protected 子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。
protected 可以修饰数据成员，构造方法，方法成员，不能修饰类（内部类除外）。接口及接口的成员变量和成员方法不能声明为 protected。
protected方法是否可见：首先确定方法是来自哪个类，以确定方法对此类的同一包和其子类可见，若子类与基类不在同一包中，那么下一步区分方法是通过谁来访问，不能通过基类实例访问。
static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。
父类中的 final 方法可以被子类继承，但是不能被子类重写。
final 类不能被继承。
abstract：抽象类不能用来实例化; 一个类不能同时被 abstract 和 final 修饰;抽象类可以包含抽象方法和非抽象方法。
抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。抽象方法的声明以分号结尾。

抽象方法不能被声明成 final 和 static。

任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。

抽象类中不一定包含抽象方法，但抽象方法必须在抽象类中。
transient:序列化的对象包含被 transient 修饰的实例变量时，JVM跳过该特定的变量。该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。修饰的变量不会持久化（持久化：将数据持久化，比如存在数据库，写入硬盘的文件中，可以相对永久保存。）
volatile：保证原子性，即当数据变量发生变化时，会强制线程将值写到共享内存。
instanceof 运算符：变量名 instanceof 类名/接口名返回boolean
循环：while(){} do{}while{} for(;;){} 增强for循环：for(局部变量:数组){}
break;//跳出整个语句块 continue;//转到下一次循环
条件语句：if(){}else if{}else{}
switch(){case value1: 语句 break; case value2: 语句 break; default:语句 }
包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类(java.lang包中);Boolean、Character属于Object;
floor//返回最小整数 round//四舍五入 ceil//最大整数
String 创建的字符串存储在公共池中，而 new 创建的字符串对象在堆上：String s = ""; //公共池 String s = new String("");//堆

String 类是不可改变的，所以一旦创建了 String 对象，无法改变； StringBuffer & StringBuilder 类可以改变（ StringBuffer类对对象本身进行操作，不生成新的对象，对字符串进行修改推荐使用 StringBuffer。
StringBuilder 的方法不是线程安全的（不能同步访问），有速度优势，所以多数情况下建议使用 StringBuilder 类。）

public class test{
public static void main(String[] args){     
       StringBuffer sbf = new StringBuffer("原字符串");
       sbf.append("追加的字符串");
       System.out.println("追加后:"+sbf); 
       System.out.println(sbf.length()); 
       sbf.delete(4,10) ;
       System.out.println("删除后:"+sbf); 
       sbf.insert(4, "插入的字符串");
       System.out.println("插入后:"+sbf); 
}
}
结果:追加后:原字符串追加的字符串
删除后:原字符串
插入后:原字符串插入的字符串

二位数组的增强for循环遍历：

public class Tautog{
  public static void main(String[] args){
    int arr[][]=new int [][]{{1,2,3},{4,5}};
    int i=0;
    for(int x[]:arr){
       for(int y:x){
         System.out.print(y);
     }
       System.out.println();
   }
  }
}
结果：
123
45

Arrays 类（java.util.Arrays）:fill（）//赋值；sort（）//排序; equals()//比较；binarySearch()//二分查找；注：binarySearch()需要先sort,否则当数组中存在多个目标时，无法确定找到的是哪一个目标的位置索引。

import java.util.Arrays;
public class test{
public static void main(String[] args){     

      int [] array={2,5,1,5,6,4};
      int result0=Arrays.binarySearch(array, 5);
      System.out.println("二分查找位置:"+result0); 
      Arrays.sort(array);
      System.out.println("排序后的数组:"+Arrays.toString(array)); 
      result0=Arrays.binarySearch(array, 5);
      System.out.println("二分查找位置:"+result0); 
      int result1=Arrays.binarySearch(array, 3,6,5);
      System.out.println("范围内二分查找位置:"+result1); 

}
}
结果：
二分查找位置:3
排序后的数组:[1, 2, 4, 5, 5, 6]
二分查找位置:4
范围内二分查找位置:4

Date 类（java.util.Date）来封装当前的日期和时间。SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");// yyyy 是完整的公元年，MM 是月份，dd 是日期，HH:mm:ss 是时、分、秒。MM 是月份，mm 是分；HH 是 24 小时制，而 hh 是 12 小时制。
printf 方法可以很轻松地格式化时间和日期。%tc//包括全部日期和时间信息;%tF"年-月-日"格式；%tD"月/日/年"格式;%tr//"HH:MM:SS PM"格式（12时制）;%tT// "HH:MM:SS"格式（24时制）;%tR//"HH:MM"格式（24时制）

import java.util.*;
import java.text.*;
public class DateDemo{
  public static void main(String[] args){
     
    Date date=new Date();
    System.out.println("当前时间为: " + date.toString());// 使用 toString() 函数显示日期时间
    SimpleDateFormat ft=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//SimpleDateFormat 自定义日期时间格式
    System.out.println("自定义ft格式为: " + ft.format(date));
    System.out.printf("c:%tc%n",date);  //全部日期和时间信息 
    System.out.printf("F:%tF%n",date);  //年-月-日格式
    System.out.printf("D:%tD%n",date);  //月/日/年格式 
    System.out.printf("r:%tr%n",date);  //HH:MM:SS PM格式 12时制  
    System.out.printf("T:%tT%n",date);  //HH:MM:SS格式24时制
    System.out.printf("R:%tR%n",date);    //HH:MM格式（4时制 

   }
}
结果:
当前时间为: Mon Aug 09 14:37:43 CST 2021
自定义ft格式为: 2021-08-09 14:37:43
c:星期一 八月 09 14:37:43 CST 2021
F:2021-08-09
D:08/09/21
r:02:37:43 下午
T:14:37:43
R:14:37

sleep()使当前线程进入停滞状态,阻塞当前线程，让出CPU。Thread.sleep(num);// Thread调用；

Calendar类实现了公历日历，GregorianCalendar是Calendar类的一个具体实现。Calendar 的getInstance（）方法返回一个默认用当前的语言环境和时区初始化的GregorianCalendar对象。

import java.util.*;
public class CalendarDemo{
    public static void main(String [] args){
    Calendar c1 = Calendar.getInstance();
    int year = c1.get(Calendar.YEAR);
    int month = c1.get(Calendar.MONTH) + 1;
    int date = c1.get(Calendar.DATE);
    int hour = c1.get(Calendar.HOUR_OF_DAY);
    int minute = c1.get(Calendar.MINUTE);
    int second = c1.get(Calendar.SECOND);
    int day = c1.get(Calendar.DAY_OF_WEEK);
    System.out.println(year+"-"+month+"-"+date);
    System.out.println(hour+":"+minute+":"+second);
    //GregorianCalendar 类
    String months[] = {
      "Jan", "Feb", "Mar", "Apr",
      "May", "Jun", "Jul", "Aug",
      "Sep", "Oct", "Nov", "Dec"};
    GregorianCalendar gcalendar = new GregorianCalendar();
    System.out.print(months[gcalendar.get(Calendar.MONTH)]);
    System.out.print(" " + gcalendar.get(Calendar.DATE) + " ");
    System.out.println(gcalendar.get(Calendar.YEAR));
    System.out.print(gcalendar.get(Calendar.HOUR) + ":");
    System.out.print(gcalendar.get(Calendar.MINUTE) + ":");
    System.out.println(gcalendar.get(Calendar.SECOND));
   }
}
结果:
2021-8-9
15:59:0
Aug 9 2021
3:59:0

Java支持传递同类型的可变参数给一个方法，即参数包含数量可不同。声明：在指定参数类型后加一个省略号(...) 。

public class VarargsDemo {
    public static void main(String args[]) {
        // 调用可变参数的方法
        printMax(1,2,3,5,5,8);
        printMax(new int[]{24,41,55});
    }
 
    public static void printMax( int... numbers) {
       
        int result = numbers[0];
 
        for (int i = 1; i <  numbers.length; i++){
            if (numbers[i] >  result) {
                result = numbers[i];
            }
        }
        System.out.println("The max value is " + result);
    }
}
结果:
The max value is 8
The max value is 55