Java入门基础

Java初学，包含使用IDEA创建文件，基本程序等等

创建新的程序

如上图，创建一个JAVA程序的步骤依次向下创建，注意一个工程可以包含多个模块，一个模块可以包含多个包，一个包可以包含多个类。

字面量(数据格式)

字符：用单引号括起来

字符串：用双引号括起来

空值：null

特殊字符：\n:换行符，\t:缩进符

默认整数是Int型，小数是double型，需要改变在数据后加上L/F。

主要结构

public class XXXXXX{

public static void main(String[] args){

System.out.println("")

}

}

原始类型与引用类型

原始类型共8种：char,boolean,byte,short,int,long,float,double

byte：1字节，8位最大值：127
short：2字节，16位，32767
int：4字节，32位，$2^{31}-1$
long：8字节，64位，$2^{63}-1$
float：4字节，32位
double：8字节，64位

剩下的都是引用类型，注意：String是引用类型

局部变量，实例变量，类变量

局部变量

是类方法中的变量，使用之前需要被初始化

实例变量

独立于方法之外的变量，也叫对象变量，也是我们经常定义的变量，对象在内存中该变量才会进入内存中，定义时具有默认值，不需要初始化

类变量（静态变量）

类变量是类中独立于方法之外的变量，用static 修饰，也叫 静态变量，只要程序开始执行就存在于内存中，定义时具有默认值，不需要初始化

实例变量与类变量区别

public class A{
    static  int a = 0; //类变量
    private int b = 0; //实例变量
} 

public class B{
    public void main (String[] args){
        A a1 = new A();
        A a2 = new A();
        a1.a = 3;  // 等同于 A.a = 3;
        a1.b = 4 ;
        System.out.println(a2.a); //结果为3
        //类变量是针对所有对象的，所以a1改变a，a2的a也改变
        System.out.println(a2.b); //结果为0
        //实例只改变自身的，所以a1对象的b改变，不影响对象a2的b变量
    }
}

数据类型转换

数据范围小的变量可以直接赋值给数据范围大的变量

byte a=2;
int b =a;
double c=b;
System.out.println(b)

另外注意在表达式中byte,short,char直接转化为Int型参与运算，因此byte+byte的结果类型必须定义为int。另外double>float>long>int>byte,short,char。一旦表达式有相应数据，则自动转化为大范围数据计算。

逻辑运算符

逻辑与”&”:有一个为false,结果是false。
短路与”&”:一个是false，结果是false。前一个是false，后面的条件就不执行了
逻辑或”|”和短路或”||” 同上解释
逻辑非”!”
逻辑异或”^”:相同时false，不同时true

键盘录入

import java.util.Scanner//导包
    Scanner sc = new Scanner(System.in);//建立对象 
System.out.println("请输入密码：")
int age=sc.nextInt()
System.out.println("你输入的密码是："+age)

关于空格，空行的方法

System.out.println(i+"\t")//数据之间的空格操作
System.out.println()//数据的空行操作

案例小练习：猜数字

package guessnumber;

import java.util.Random;
import java.util.Scanner;

public class func {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        Random r=new Random();

        int num=r.nextInt(100)+1;
        System.out.println("已随机生成1-100的数字\n");
        System.out.println("请输入你猜的数字\n");
        while(true)
        {
            int input=sc.nextInt();
            if(input>num) System.out.println("你猜的数字过大");
            else if(input<num) System.out.println("你猜的数字过小");
            else break;
        }
        System.out.println("正确！");
    }
}

数组

int[] arr=new int[12];
int[] ages=new int[]{1,2,3};//静态初始化
int[]={input};//动态初始化
int[][] arr2={{1,1,1},{1,1,1}};//二维数组
System.out.println(ages.length);//求数组长度

方法重载

同一个类，出现多个方法名称相同，形参列表不同这些方法叫重载方法。

p.s. 返回值类型没关系

如：

public static void(){
	代码段1
}
public static void(String a)
{
	代码段2
}

return单独使用

单写一个return，

可以跳出并立即结束所在方法的执行

生成随机字符

char ch=(char) (ra.nextInt(26)+65);//生成随机大写字母
char ch2=(char) (ra.nextInt(26)+97);//生成随机小写字母

String类常用api

判断相等：在java中字符串内容比较不能使用”==”，因为java字符串表示的是地址。。

如：

string name="zrm";
string password="123456";
string in_name,in_password;
cin>>in_name>>in_password;
if(in_name==name&&in_password==password) cout<<"正确";
else cout<<"错误";

这一段C++代码是可以执行的，但是放在java中即使输入相同的名字密码都无法输出“正确”，因为定义的正确字符串存于常量区，而输入的字符串在堆内存中，两者的地址不一样，比较的结果是不相等。

因此需要用到一个判断内容相等的api：

String name="aaa";
String password="123456"；
Scanner sc=new Scanner(System.in)
//定义接受输入内容的对象....
name.equal(in_name)//判断name字符串和in_name字符串内容是否相等，包括大小写检验
password.equalIgnoreCase(in_password)//判断前后是否相等，忽略大小写

对字符串的操作:

String str="abcdefg";
str.length();//求字符串长度
str.charAt(int num);//求字符串特定位置字符
str.toCharArray();//把字符串转成字符数组
str.substring(int first,int last);//截取，包前不包后
str.substring(int first);//截取，从当前索引一直截取到末尾
str.replace(String before,String new);//替换，把前一个内容全部替换成后一个内容
str.contain(String s);//判断是否包含，是返回true,否则返回false
str.startsWith(String str);//判断是否以此字符串开始
String str2="aaa,bbb,ccc";
str.split(",");//按照","分开，返回字符串数组，需要有一个字符串数组对象接收返回值

生成验证码第二种表达方式

public class special_number {
    public static void main(String[] args) {
        String str="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
        Random ra=new Random();
        String res="";
        for(int i=0;i<5;i++)
        {
            int num=ra.nextInt(str.length());
            char c=str.charAt(num);
            res+=c;
        }
        System.out.println(res);
    }
}

ArrayList类

ArrayList<String> list=new ArrayList<String>();//尖括号内约束数据类型
list.add();//直接添加
list.add(int index,type data);//在指定位置插入元素
list.get(int index);//获得指定位置元素
list.size();//获得元素个数
list.remove(int index);//删除索引位置元素，返回被删除的元素值
list.remove(Object o);//删除容器内元素的值，如有多个相同值则删除第一个
list.set(int index,E element);//修改索引位置的元素为后面的元素

static使用

静态成员变量有static修饰，可以被共享使用，访问格式为：类名.变量 or 对象.变量。一般用在需要被共享的信息中

实例成员变量无static修饰，只属于对象本身，访问格式为：对象.变量。一般用在每个对象共有的信息中

静态成员方法用static修饰时，可以直接使用方法名调用，不需要对象.方法

静态代码块：用于在程序启动时，进行静态资源初始化操作，格式：static{}

静态导入：static import，可以导入类或者接口的静态成员。

单例：保证一个类只有一个对象

Final使用

final 是用来提权的，但是在设计程序时，要注意程序或者方法的权限不可以超过它应有的权限高度，否则可能造成漏洞。final能指定一个变量强制不可被修改。

enum使用

枚举用于一组常数的集合，当这组集合的数包含了所有情况时就可以使用枚举，比如一周当中只能是7天中的一个。

比如：

public enum SexEnum {
    male,female;
}
public enum Color {
    RED,BLUE,GREEN,BLACK;
}

之后便可以通过枚举类型名直接引用常量，如 SexEnum.male、Color.RED。

枚举类

Java 中的每一个枚举都继承自 java.lang.Enum 类。当定义一个枚举类型时，每一个枚举类型成员都可以看作是 Enum 类的实例，这些枚举成员默认都被 final、public, static 修饰，当使用枚举类型成员时，直接使用枚举名称调用成员即可。

另外枚举类可以自己新建方法。

类与方法

方法

非常常见的方法：Set方法和 Get方法，Set methods are commonly called mutator methods.Get methods are commonly called accessor methods or query methods.

抽象类

public abstract class{
	public abstract void run()
}

抽象方法，抽象类由abstract修饰，不用声明具体的方法体。一个方法如果声明为抽象方法，则该类必须为抽象类。使用场景：

一般作为父类，让子类继承
父类得知子类一定完成某种行为，但不知道具体行为，就先定义抽象方法，让子类具体定义

注意：

抽象类不一定有抽象方法，有抽象方法的类一定是抽象类。
一个类继承了抽象类，则它必须重写所有的抽象方法，否则它必须也定义为抽象类
抽象类得到了抽象方法，却失去了创建对象的能力（不能被实例化）

继承 extends

超类（双亲类）：子类继承的来源
子类：继承父类的类

子类

子类构造函数的第一个任务是显式或隐式地调用其直接超类的构造函数
如果代码不包含对超类的构造函数的显式调用，那么Java将隐式地调用超类的默认或无参数构造函数

重写方法

子类重写超类的方法，但如果父类方法带有final关键字，子类就无法重写了

public，private，protected，default

public成员可被子类访问或直接引用成员对象或任何地方访问
private成员只能在该类中被调用，子类无法访问，只能通过本类的public或protected方法来访问
protected成员可以被本类和子类和同一包中其他类访问调用，子类方法可以直接用成员名称来引用，如果超类的protected方法变化，可能需要修改所有子类的方法
default成员，啥都不定义就是这个，不能从包外访问，只能在包内访问

多态

多态允许定义接口并存在多个实现，主要有两种形式：

编译时间多态性（通过方法重载实现的静态多态性）
运行时多态性（通过方法覆盖实现的动态方法调度）

try…catch 抛出异常

编程时可以用try…来处理异常，

最后一段可以使用finally

try {
    setAge(age);
    openFile(filename);
}
    catch age(IllegalArgumentException e) { 
    System.out.println(“Unchecked exception!");
    System.err.println(e);
}
    catch age(IOException e) { 
    System.out.println(“Checked exception!");
    System.err.println(e);
}
finally {
    System.out.println("Print this anyways.");
}