MISAMISAのjava

(((((((((((っ•ω•)っ Σ(σ｀•ω•´)σ

DOS命令☆

窗口+R打开cmd或powershell

●常用的DOS命令

dir:列出当前目录下的文件以及文件夹
md:创建目录
rd:删除目录
cd:进入指定目录 
cd..:退回到上一级目录
cd\: 退回到根目录
del:删除文件
exit:退出dos命令行
---
d: 进入d盘
cd java 进入java文件夹

固定结构

public class 文件名 {

 public static void main(String[] args) {
     ……//在此处调用其他方法函数
  }
 // 其他方法函数要写在static void main外，方法内不可定义方法
 //输出一定在方法内，而不是类内方法外
}

Error：编码gbk的不可映射字符∑(っ°Д°;)っ

当javac 文件名.java出现错误:
javac -encoding utf-8 文件名.java
之后直接java 文件名就可运行

数据类型

java中默认数据类型是int、double
long a = 3l;  long声明的变量后要加l，short则不用
float a = 1.22f;   float声明的变量后要加f

1
2
3

// 字符型：
char a = 'a';
char a = '\'';      \将'转变为特殊字符型常量

// 字符串型：
string a = "hello world";
string a = "hello"+" world";
System.out.println(a);    //输出相同

数据类型转化

●有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
●short,char之间不会相互转换，他们三者在计算时首先转换为int类型。
●当把任何基本类型的值和字符串值进行连接运算时(+)，基本类型的值将自动转化为字符串类型。

//转化举例
char a = 'a';
int b = 1;
string str = "abc";
System.out.print(a+b); //输出98
System.out.print(str+1); //输出abc1
System.out.print(a+b+"a"); //输出98a 
System.out.print("a"+b+a); //输出a1a

快捷键 ☆

alt+shift+↓：向下连续复制
alt+方向：带着上下移动
Ctrl+P+>：换主题
Ctrl+S：保存笔记
Ctrl+L：选中一行
选中+Ctrl+/：加注释
alt+shift+F：格式化

换行

System.out.print("打印\n");
System.out.println("打印");

自动格式转换

位运算符 System.out.print();函数自动根据变量类型打印变量（不需要%d和双引号,etc.)

int a = 1;
System.out.print(a);

输出1

运算符

a = b = c = 0; (√)

System.out.println(4 == 5);//输出false
System.out.println(4 != 5);//输出true

●逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6， 应该写成x>3 & x<6。
●“&”和“&&"的区别:
单&时，左边无论真假，右边都进行运算;
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
●"|”和“||”的区别同理，||表示: 当左边为真，右边不参与运算。

位运算符

<<左移3<<2= 12 --> 3*2*2=12, m<n→m*2^n
>>右移3>>1=1 --> 3/2=1. m>>n→m*2^-n
>>>无符号右移3>>>1=1 --> 3/2=1.（正数的>>和>>>一致）
&与运算6&3=2
|或运算6|3=7
^异或运算6^3=5反码~6=-7 
●位运算是直接对二进制进行运算

三目运算符

（条件表达式）？表达式1 ；表达式2；
条件表达式为真→表达式1
条件表达式为假→表达式2

一维数组

动态初始化:

数组声明且为数组元素分配空间与赋值的操作分开进行int[]arr = new int[3];
arr[0] = 3; arr[1] = 9; arr[2] = 8;
//若不分配，默认值是0

静态初始化:

在定义数组的同时就为数组元素分配空间并赋值。
int a[] =new int[]{ 3, 9, 8};
int[] a = {3,9,8};//二者相同
字符串数组：
String[] arr = new String[]{"misa","beauty"};

数组长度

int []a = {1,3,5,7,9};
System.out.print("数组长度是"+a.length);
输出：
数组长度是5

数组赋值：直接a[]=b[]; a获得b内存地址，改变b[]中的值则a[]也跟着改变。

数组复制：循环a[i]=b[i]; a获得b的值，改变b[]中的值a[]不会改变。

二维数组 (可以是不规则矩阵)

动态初始化:

格式一：int a [][] = new int[3][2];
格式二：int a [][] = new int[3][];
       a[0]=new int[2];
       a[1]=new int[3];
       a[2]=new int[2];//即每行长度不一

静态初始化:

int [][] b = {{1,2},{3,4,5}};

数组长度

System.out.print(b[1].length);
输出：3 
System.out.print(b.length);
输出：2 // 一维长度，即行

类

/*public是修饰符，private则不可被该类以外方法访问*/
    public class Person//类名{
        //成员变量
        String name;
        int age;
        //方法函数/方法体
        public void showName(){
            System.out.println("name:"+name);
            //无返回值
        }
        public int showAge(){
            return age;//成员变量有的则形参中不用定义
        }
    }

主类中则这样写

public class Test{

    public static void main(String[] args) {
        Person person = new Person();//实例化Person类
        person.name = "MISA";
        person.showName();
        int a = person.showAge(12);
        System.out.println("age:" + a);
  }
    }
    /*输出：
    name:MISA
    age:12*/

变量

●成员变量：在方法体外，类体内声明的变量。

实例变量(不以static修饰)
    public int a;//在类外需要实例化后才可调用

类变量(以static修饰)
    public static int b;//在类外不用实例化，直接类名.b调用

●局部变量：在方法体内部声明的变量。

形参(方法签名中定义的变量)//形参可以有多个，逗号隔开
方法局部变量(在方法内定义)
代码块局部变量(在代码块内定义)

匿名对象 (disposable)

一个对象只需要进行一次调用的时候就可以用匿名对象
，即直接

new 类名().方法
//创建匿名对象并调用类内方法

方法的重载 (overload)

同一类中允许存在多个同名方法，只要他们的参数个数或参数数据类型不一样即可

以下构成重载：
int add(int x,int y,char z){return x+y+z};
int add(int x,int y,int z){return x+y+z};
int add(int x,int y){return x+y};
int add(int x,char z, int y){return x+y+z};

int add(int a,int b,char c){return a+b+c};//不构成

可变个数的参数传递

方法1

在类中：
public class ls{
    public void in(String[] args){
        for(int i = 0;i<args.length;i++)
            System.out.print(args[i]);
    }
}
在主类中：
public class Test {

  public static void main(String[] args) {
    ls test = new ls();
    String[] arr = new String[]{"misa"," nice"};//可有多个字符串，字符串之间用逗号隔开
    test.in(arr);
  }//输出misa nice
}

方法2

在类中：
public class ls{
    public void in(String... args){
        for(int i = 0;i<args.length;i++)
            System.out.print(args[i]);
    }
}
在主类中：
public class Test {

  public static void main(String[] args) {
    ls test = new ls();
    // String[] arr = new String[]{"misa"," nice"};
    // test.in(arr);一样可以用数组的办法调用
    test.in("misa"," nice");
  }//输出misa nice
}

在类中可以public void in(int… a){} 即数据类型可变

也可以public void in(int a,String… args){}多个形参时，可变形参一定放在最后

如果类中类型[]名称没有参数，则调用的时候要写**实例对象.名称(null)**，…则不用写

方法调用问题

类方法（static）不能直接调用实例方法（非static）

public static void main(String[] args) {
    int b = getA(2, 3);
    System.out.println(b);
}
public static int getA(int x, int y) {
    return x * y; }//static直接调用static

public static void main(String[] args) {
    Test list = new Test();
    int b = list.getA(2, 3);
    System.out.println(b);
}
public int getA(int x, int y) {
return x * y;}//static实例化对象后调用非static

JVM内存模型

栈（stack）：基本数据类型的值、对象在堆中的地址
堆（heap）：所有对象的值（包括自己定义的对象和字符串对象）
方法区（method）：所有class和static变量

Azus

Notes Of MISAMISA