Java基础学习day01

Java基本

JVM不是跨平台的，而java程序是跨平台的

JRE（java runtime environment） java运行环境 = jvm + 核心类库

JDK （java development kit）java程序开发工具包 = JRE + 开发人员使用的工具

JAVA程序开发流程

javac.exe 编译器 java.exe 解释器

编译 javac 类名.java

解释 java 类名 （切记不能有.class后缀）

标识符命名规范

硬性要求

1、由字符、数字、下划线、美元符号组成

2、不能是关键字

3、首字符不能为数字

软性要求

类名: 每个单词首字母大写

方法名：除了第一个单词外首字母大写

变量名：同方法名

常量 ：在程序运行过程中不变的量

1、字符串常量 ： 凡是由双引号“”引起来的部分

2、数字常量： 整数常量、浮点数常量

3、字符常量 ： 由单引号‘’引起来的部分 ‘a’, ‘中’, 单引号之间有且必须只有一个字符，可以是空格，不能为空

4、布尔常量: true false

5、空常量 : null， 不能直接打印输出！！

数据类型

基本数据类型

​ 整数型 byte short int long (在计算机中是以有符号位的二进制补码表示的整数，例如1在计算机中表示为00001,-1表示为11111)

​ 浮点型 float double 3.14F或者3.14f 都可以

​ 字符型 char

​ 布尔型 boolean

类型	字节数/位数	数据范围
byte	1字节/8位	-127~128
short	2字节/16位	-32768~32767
int	4字节/32位	-231**~**231 - 1
long	8字节/64位	-263**~**263 -1
float	4字节/32位
double	8字节/64位
char	2字节/16位	\u0000\uffff（065535）
boolean	1位

引用数据类型

​ 字符串、数组、类、接口等，默认值为null

变量类型

局部变量

• 局部变量声明在方法、构造方法或者语句块中；

• 局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；

• 访问修饰符不能用于局部变量；

  public class Demo{
         
  	public static void main(String[] args){
         
  		public int a = 10;//错误！！！！！！！
  	}    
  }
  

• 局部变量是在栈上分配的。

• 局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用！！！

实例变量

• 实例变量声明在一个类中，但在方法、构造方法和语句块之外；

• 当一个对象被实例化之后，每个实例变量的值就跟着确定；

• 实例变量在对象创建的时候创建，在对象被销毁的时候销毁；

• 访问修饰符可以修饰实例变量；

• 实例变量具有默认值。整型变量的默认值是0，浮点型变量的默认值是0.0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定

  public class Demo{
         
  	public int a = 10;
      private double b; 
  }
  

类变量（静态变量）

• 类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。
• 无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
• 静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。
• 静态变量在第一次被访问时创建，在程序结束时销毁！！
• 默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。

Java修饰符

访问修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

• default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

• private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

• public : 对所有类可见。使用对象：类、接口、变量、方法

• protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

  访问控制表

修饰符	当前类	同一个包内	子孙类（同一个包中）	子孙类（不同包）	其它包	修饰对象
public	Y	Y	Y	Y	Y	类、接口、变量、方法
protected	Y	Y	Y	Y	N	变量、方法
default	Y	Y	Y	N	N	类、接口、变量、方法
private	Y	N	N	N	N	变量、方法

非访问修饰符

为了实现一些其他的功能，Java 也提供了许多非访问修饰符。

static 修饰符，用来修饰类方法和类变量。

final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义（重写），修饰的变量为常量，是不可修改的，无论是类变量、实例变量，还是局部变量，必须初始化。

abstract 修饰符，用来创建抽象类和抽象方法。

synchronized 和 volatile 修饰符，主要用于线程的编程。

Java运算符

算术运算符

​ +、-、*、/、%、++、–

​ 注意a++与a–的区别

关系运算符

​ >、<、>= 、 <= 、 ==、 !=

位运算符

A = 0011 1100 //60
B = 0000 1101  //13
-----------------
A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011

操作符	描述	例子
&	如果相对应位都是1，则结果为1，否则为0	(A＆B)，得到12，即0000 1100
|	如果相对应位都是 0，则结果为 0，否则为 1	(A | B)，得到61，即0011 1101
^	如果相对应位值相同，则结果为0，否则为1	(A ^ B), 得到49，即 0011 0001
~	按位取反运算符翻转操作数的每一位，即0变成1，1变成0。	(〜A), 得到-61，即1100 0011
<<	按位左移运算符。左操作数按位左移右操作数指定的位数。	A << 2得到240，即 1111 0000
>>	按位右移运算符。左操作数按位右移右操作数指定的位数。	A >> 2得到15即 1111
>>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。	A>>>2得到15即0000 1111

---

按位取反计算：（符号位和数值位同时取反）<符号位0为正，1为负>

~1 --> (补码)00001 -->(按位取反后的补码) 11110 -->（反码）11101 -->(原码) 10010 --> （结果） -2

~-9 --> (补码) 10111 --> (按位取反后的补码) 01000 -> (反码) 01000 --> (原码) 01000 --> (结果) 8

System.out.println(~1);//-2
System.out.println(~2);	//-3
System.out.println(~-9);	//8	

---

逻辑运算符

与 && 或 || 非！

boolean ver1 = true;
boolean ver2 = false;
System.out.println(ver1 && ver2);  //false
System.out.println(ver1 || ver2);  //true
System.out.println(!ver1);  //false

赋值运算符

操作符	描述	例子
=	简单的赋值运算符，将右操作数的值赋给左侧操作数	C = A + B将把A + B得到的值赋给C
+ =	加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数	C + = A等价于C = C + A
- =	减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数	C - = A等价于C = C - A
* =	乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数	C * = A等价于C = C * A
/ =	除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数	C / = A，C 与 A 同类型时等价于 C = C / A
（％）=	取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数	C％= A等价于C = C％A
<< =	左移位赋值运算符	C << = 2等价于C = C << 2
>> =	右移位赋值运算符	C >> = 2等价于C = C >> 2
＆=	按位与赋值运算符	C＆= 2等价于C = C＆2
^ =	按位异或赋值操作符	C ^ = 2等价于C = C ^ 2
| =	按位或赋值操作符	C | = 2等价于C = C | 2

条件运算符

格式： variable x = (expression) ? value if true : value if false

int result = 10 > 20 ? 30 : 40;
System.out.println(result);  // result为40

instanceof运算符

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。

格式( Object reference variable ) instanceof (class/interface type)

String name = "James";
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真

Java循环结构

for循环、while循环、do…while循环、 增强后的for循环

while( 布尔表达式 ) {
     
  //循环内容
}
do {
     
       //代码语句
}while(布尔表达式);
for(初始化; 布尔表达式; 更新){
     
	//循环体
}
for(声明语句 : 表达式){
     
	//声明语句，必须重定义一个与数组元素同类型的变量
	//表达式一般为数组
}

Java条件语句

if…else

int num = 10;
if(num == 0){
     
	System.out.println("零分");
}else if( num > 0 && num < 60){
     
	System.out.println("不及格");
}else if( num >= 90 && num < 100){
     
	System.out.println("优秀");
}else{
     
	System.out.println("满分");
}

switch…case

switch(expression){
     
    case value :
       //语句
       break; //可选
    case value :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}

• switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。

• case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。

• switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

  ///特殊情况！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
  String test = "123";
  switch (test){
             
      default:        
          System.out.println("null");    
      case "10":        
          System.out.println(10);        
          break;    
      case "11":        
          System.out.println(11);       
          break;
  }
  //结果是
  //null
  //10
  

Stirng类、StringBuilder类、StringBuffer类

String：字符串常量，字符串长度不可变。Java中String 是immutable（不可变）的。用于存放字符的数组被声明为final的，因此只能赋值一次，不可再更改。

StringBuffer：字符串变量（Synchronized，即线程安全）。如果要频繁对字符串内容进行修改，出于效率考虑最好使用 StringBuffer，如果想转成 String 类型，可以调用 StringBuffer 的 toString() 方法。Java.lang.StringBuffer 线程安全的可变字符序列。在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。可将字符串缓冲区安全地用于多个线程。

StringBuilder：字符串变量（非线程安全）。在内部 StringBuilder 对象被当作是一个包含字符序列的变长数组。性能强于StringBuffer。

基本原则：

• 如果要操作少量的数据用 String ；
• 单线程操作大量数据用StringBuilder ；
• 多线程操作大量数据，用StringBuffer。

java数组

Java语言中数组必须先初始化，然后才可以使用。所谓初始化就是为数组的数组元素分配内存空间，并为每个数组元素附初始值。

注意：数组完成初始化后，内存空间中针对该数组的各个元素就有个一个默认值：

        基本数据类型的整数类型（byte、short、int、long）默认值是0；

        基本数据类型的浮点类型（float、double）默认值是0.0；

        基本数据类型的字符类型（char）默认值是'\u0000'；

        基本数据类型的布尔类型（boolean）默认值是false；

        类型的引用类型（类、数组、接口、String）默认值是null.

java数组初始化分为：静态初始化和动态初始化

静态初始化

初始化时由程序员显式指定每个数组元素的初始值，有系统决定数组的长度；

1、type[] arrayName = new type[]{element1,element2,element3…};

int[] array = new int[]{
     1, 2, 3};

2、type[] arrayName = {element1, element2, element3};

int[] array = new int[]{
     1, 2, 3};

动态初始化

初始化时由程序员指定数组的长度，由系统初始化每个数组元素的默认值。

type[] arrayName = new type[length];

int[] array = new int[3];  //数组array[]默认为[0, 0, 0]
array[0] = 1;

多维数组创建方式

//多维数组创建方式
int[][] arr4 = new int[3][4];
int[][] arr5 = new int[2][];
arr5[0] = new int[3];
arr5[1] = new int[2];
int[][] arr6 = new int[][]{
     {
     1,2}, {
     2}};
int[][] arr7 = {
     {
     1,2}, {
     2}};

！！！不能同时使用动态初始化和静态初始化，即不能同时指定数组的长度和数组的初始化内容。

Java方法参数

1、重载时，必须保证参数列表中要么参数个数不同，要么参数的类型不同，返回类型不要求。

2、可变参数->类似于数组

​ 参数列表中，可变参数至多只有一个，且必须放在列表最右侧。

public class VarargsDemo {
     
    public static void main(String args[]) {
     
        // 调用可变参数的方法
        printMax(34, 3, 3, 2, 56.5);
        printMax(new double[]{
     1, 2, 3});
    }
 
    public static void printMax( double... numbers) {
     
        if (numbers.length == 0) {
     
            System.out.println("No argument passed");
            return;
        }
 
        double 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);
    }
}

Java Scanner类

创建Scanner对象的语法

Scanner sc = new Scanner(System.in);

next()方法

//基本使用Scanner类 
Scanner sc = new Scanner(System.in);  //使用next()不接受非空白字符,以空白字符作为间隔符或结束符 String str1 = sc.next();  //  next time 
System.out.println(str1); 
System.out.println("================="); 
while(sc.hasNext()){
          
    System.out.println(sc.next());     
    System.out.println("================="); 
}
/*
* 输出结果为:
*  next
*  =================
*  time
*  =================
**/

nextLine()方法

String str2 = sc.nextLine();//  next time( 包括空格)
System.out.println(str2);
System.out.println(str2.length());
    /*输出结果为:
     *  next time
     * 10
     **/

next()与nextLine()的区别

next()

• 对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
• 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
• next() 不能得到带有空格的字符串。

nextLine()

• 以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
• 可以得到空白字符串

Scanner对象可以获取其它数据类型的数值，例如int，float，double等

Scanner对象在获取数据之前，最好使用hasNextXxxx()方法判断是否有对应数值的输入

抽象

抽象类

[public|default] abstract class ClassName{
     
    
}

抽象方法

[public|default] abstract class ClassName{
     
	[public|default|protected|private] abstract 返回类型 methodName();
}

注意事项：

• 抽象类不能被实例化，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。

• 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

• 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。

• 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。

• 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。