AsllのJava学习笔记

一、Java的类、方法、成员、对象、变量

 类可以看成是创建 Java 对象的模板。

 拿一条狗来举例，它的状态有：名字、品种、颜色，行为有：叫、摇尾巴和跑。  对比现实对象和软件对象，它们之间十分相似。
 软件对象也有状态和行为。软件对象的状态就是属性，行为通过方法体现。
 在软件开发中，方法操作对象内部状态的改变，对象的相互调用也是通过方法来完成。

 于是类中所包含的，应该为这一类对象所包含的特征的集合。
 创建类如下：

public class student{
	public String ID;  //成员变量
	public String name;
	public String age;
	student(){}   //构造器重载
	public student(String ID,String name,String age) {
		this.ID = ID;
		this.name = name;
		this.age = age;
}    //构造函数
	public void setID(String ID) {
		this.ID = ID;
	}  //构造方法
	}

 于是可以总结为，创造一个类的格式为：

[修饰符] class 类名{ 
0到多个构造器 
0到多个成员变量 
0到多个方法 
0到多给初始化块
}

1、修饰符

 可以写public、final、abstract或者不写，java类名要用大驼峰写法。一个java源文件（也就是文件后缀名为.java的文件）可以写多个类，但是里面只能有一个用public修饰的class。

2、构造器

[修饰符]与类名相同的名(形参列表)
{构造器方法体代码 }

1. 构造函数方法

//无参量的构造函数（输入xy）方法
student(){}   //构造Constructor
student Stu = new studnet;   //调用

//有参数的构造函数（输入xy）方法
public student(String ID,String name,String age) {
		this.ID = ID;
		this.name = name;
		this.age = age;
}    
student Stu = new student("a","b","c")  //调用

2. 构造方法
    其中需要返回(return)什么值，就在方法名称前声明，String、int、boolean

public void setID(String ID) {
	this.ID = ID;
}  //有参数的构造方法,私有成员set的方法
(student)a.setID(String xx) //set方法调用

public String getID() {
		return ID;
}  //无参数的构造方法,私有成员get的方法
(student)a.getID();  //get方法调用

public String toString() {
		return ID+" "+name+" "+age;
}
（student)a.toString();  //改写student类私有的toString方法

 一般情况下，在构建一个类的函数方法时，最好1跟2都写上。

3、类的成员变量

 成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。列如：

public class student{
	public String ID;  //成员变量
	public String name;
	public String age;

 类可以访问它的任意成员变量，其中包括私有成员（Private）以及公共成员（Public）。

4、构造方法（Constructor)

 构造方法是一种特殊的、与类名相同的方法，专门用于在创造对象时完成初始化工作。特殊性主要体现在：

1. 构造方法的方法名与类名相同
2. 构造方法没有返回值，但是不能写void
3. 构造方法一般用new来进行调动
4. 一般在创造一个类的时候，系统会自动调动该类的构造方法，为新对象初始化，其中自动生成的默认的构造方法为：

	类名() {}

5、主方法（main）

（1）定义

 在Java中，main()方法是Java应用程序的入口方法，也就是说，程序在运行的时候，第一个执行的方法就是main()方法，这个方法和其他的方法有很大的不同，比如方法的名字必须是main，方法必须是public static void 类型的，方法必须接收一个字符串数组的参数等等。

（2）main()声明方式

 这个main()方法的声明为：

public static void main(String args[])。

 必须这么定义，这是Java的规范。

（3）main()原理

 为什么要这么定义，和JVM的运行有关系。
 当一个类中有main()方法，执行命令“java 类名”则会启动虚拟机执行该类中的main方法。
 由于JVM在运行这个Java应用程序的时候，首先会调用main方法，调用时不实例化这个类的对象，而是通过类名直接调用因此需要是限制为public static。(类名.main())
 对于java中的main方法，jvm有限制，不能有返回值，因此返回值类型为void。
 main方法中还有一个输入参数，类型为String[]，这个也是java的规范，main()方法中必须有一个入参，类型必须String[]，至于字符串数组的名字，这个是可以自己设定的，根据习惯，这个字符串数组的名字一般和sun java规范范例中mian参数名保持一致，取名为args。
 因此，main()方法定义必须是：“public static void main(String 字符串数组参数名[])”。

6、对象的应用

 引用的格式一般为"数据类型 变量名"，如 int a,double b 等

二、Java的继承、抽象类、接口和枚举

1、类的继承

 首先，Java语言中有一个名为java.lang.Object的特殊类，所以的类都是直接或者间接地继承该类而得到的。父类称为（superclass），子类称为（subclass）。一个类只能有一个直接父类。继承格式如下：

	class SubClass extends SuperClass{
	}

1. 子类的构建方式：先写父类，写好后extends，就可以调用父类的方法。
   例如：.set()、.get()、.show() 等等。
2. 在子类中访问父类的成员：

	super.变量名；
	super.方法名()；//一般可以直接".方法名()"的

2、特殊的Object类（java.lang.Object）

 这里主要强调它的几个方法。

1. equals()：求相等
2. toString()：讲Object转换为String的方法
3. getClass()：返回该变量所属的class
   getSuperClass()：返回该变量所属的Supclass

3、抽象类（abstract class）

 抽象类的作用有点类似于“模板”，其目的是根据它的格式来创建和修改新的类抽象类。只能通过该模板派生出的新“子类”，再由其“子类”来创建对象。
 抽象类是以修饰符 abstract 修饰的类。语法格式如下：

	abstract class 类名
	{
		声明成员变量；
		返回值的数据类型 方法名（参数）{
		}
		abstract 返回值的数据类型 方法名（参数）；//组成抽象方法
	}

4、接口（interface)

 它的结构与抽象类非常相似。接口本身也具有数据成员、抽象方法、默认方法和静态方法，但它与抽象类有以下不同：

• 接口的数据成员都是静态的且必须初始化，即数据成员必须是静态常量。
• 接口中除了声明抽象方法外，还可以定义静态方法和默认方法。

（1）接口定义

   语法格式如下：

	[public] interface 接口名称 [extends 父接口名列表]
	{
		[public] [static] [final] 数据类型 常量名 = 常量;   //定义常量

		[public] [abstract] 返回值的数据类型 方法名(参数);  //定义抽象方法

		[public] static 返回值的数据类型 方法名(参数){      //定义静态方法
			方法体
		}
		[public] default 返回值的数据类型 方法名(参数){     //定义默认方法
			方法体
		}
	}

（2）接口的实现与引用

  利用接口创建新类的过程称为接口的实现（implementation）。接口类似于继承，只是不用extends关键字，而是在声明一个类的同时用关键字 implementation 来实现一个接口。语法格式为：

	class 类名称 implements 接口名表{}

  注： 一个类在实现某接口的抽象方法时，必须使用完全相同的方法头，否则只是在定义一个新的方法，而不是实现已有的抽象方法。

5、枚举（enum）

（1）定义

  枚举类型名有两层含义：一是作为枚举名使用；二是表示枚举成员的数据类型，正因为如此，枚举成员也称为枚举实例或枚举对象。
  定义枚举所使用的关键字 enum 与 class 和 interface 的地位相同。与普通类相比，其区别如下：

• enum 关键词声明的枚举默认继承的是 java.lang.Enum< E >类别。
• 构造方式默认修饰为 private 所以不能用 new 来直接引用。
• 成员默认使用 public static final 进行修饰。

  定义方法：

	[修饰符] enum 枚举类型名
	{
	枚举成员
	方法
	}

  预定义方法：

	//返回枚举类型的数组，该数组包含枚举的所有枚举成员，并按它们的声明顺序储存
		public static enumtype[] values()

	//返回名称为str的枚举成员
		public static enumtype valueOf(String str)

（2）常用方法

1. equals() 比较两个枚举对象是否相等，返回Boolean值
2. toString() 返回枚举对象的名称
3. ordinal() 返回成员在枚举中的序号

三、字符串类和日期类&数组

1、定义数组

①一维数组

//数组名 = new 数据类型[个数]
int[] a = new int[5];

//数据类型[] 数组名
int [] sort = {0,1,2,3,4};

②二维数组

//数据类型[][] 数组名
int[][] a;
//数组名 = new 数据类型[行数][列数]
a = new int[3][4];
//数据类型[][] 数组名 = new 数据类型[行数][列数]
int[][] a = new int[3][4]

• 数组的引用参考c和py都是：数组名[index]
• 数组返回行元素个数：数组名[index].length

2、定义列表

 由于列表里面可以存放任意object，且自身具有伸缩性，一般用它来存放类似与sql中的行元素。

ArrayList Stu = new ArrayList();

 列表的引用：

①增添

//序列尾部添加元素
Stu.add(stu1)
//序列的索引位置添加元素
Stu.add(index,stu1)

②删除

//删除
Stu.remove(2) //（index）

3、输出矩阵

• 一是可以直接用for进行迭代；

//一维矩阵
for (i = 2;i < a.length;i++) { }
//多维矩阵
for (i = 1;i <= N;i++) {
	for(j = 1;j <= M;j++){ }
	}

• 二是可以用迭代器（foreach)；

//foreach只需要提供三个数据：元素类型（int），循环变量（element），检索元素的数组（arr)
int[] arr = {1,2,3,4,5};
for(int element : arr){
	system.out.println(element);}

• 三是可以借用Array中定义的方法:
  System.out.println(Arrays.toString(sort));

4、字符串（String类）

 String类在某种程度上等价于char类型，例如：

	String s = new String();
	char a[] = {'h','e','l','l','o'};
	String s = new String(a);
	//等价于
	String s = new String("hello");

①String类的创建

• 格式一：
  String 变量名；
  变量名 = new String("字符串”);
• 格式二：
  String 变量名 = new String(“字符串”);
• 格式三：
  String 变量名 = “字符串”；

②String类的常用方法

引用格式：字符串变量名.方法名();
常用的方法有：

• 返回字符串长度：a.length()
• 判断两个字符串是否相等，返回Boolean值：
  • 不忽略大小写：a.equals(Object)
  • 忽略大小写：a.equalsIgnoreCase(Object)
• 判断两个字符串的数值大小，返回大于/小于/等于0的数：a.compareTo(String b)
• 获取指定索引位置的字符：a.charAt(index)
• 字符串分割：a.split("，") //根据“，”来拆分字符串

5、可追加字符串（StringBuffer类）

 一般情况下用于缓存内容，例如时间，课程等需要随时更新的变量；

1. 追加字符串：
   StringBuffer 对象.append(String str)
2. 举例：

	//创建一个StringBuffer对象
	StringBuffer buffer = new StringBuffer("hellow,");
	String str = "world!";
	buffer.append(str);
	System.out.println(buffer.substring(0));

3. 反转字符串

	StringBuffer a = new StringBuffer("java");
	a.reverse();
	System.out.println(a); 
	//输出：avaj

4. 删除字符串

• deletCharAt()方法
  作用是删除指定位置的字符，然后将剩余的内容形成一个新的字符串。格式为：

  StringBuff 对象.deleteCharAt(index);
  

• delete()方法
  作用为删除指定位置的字符，然后将剩余的内容两边拼接到一起形成一个新的字符串。格式为：

  StringBuff 对象.delete(Start index,End index);
  

6、日期类

需要引用Package：java.time

• LocalData：年月日。格式：2020-01-01
• LocalTime：时分秒。格式：16:39:09:307
• LocalDateTime：年月日 时分秒。格式：2020-01-01 01:01:01:001
• Instant：时间戳类
• Period：计算日期差
• Duration：计算时间差
• long a = System.currentTimeMillis() ：获取开始读取文件的时间

LocalData\Data\Time与String之间的转换

• LocalData\Data\Time转换为String
  
  
• String转换为LocalData\Data\Time
  

四、Java语言的输入输出（IO）

流的定义： 有序的数据序列，将数据从一个地方带到另外一个地方。
流的分类：

• 按照流的方向可分为输入（input）和输出（output）流
• 按照数据单位的不同可分为字节流和字符流

1、Input流

  主要有InputStream类和Reader类

2、Output流

  主要有OutputStream类和Writer类


用法：
  先确定输入文件输出文件的流OS/IS；再使用方法对类成员进行定义使用。

		is = new FileInputStream("路径分级用\\");
		os = new FileOutputStream("路径");
		
		bis = new BufferInputStream(is);
		bos = new BufferOutputStream(os);
		
		while ((a = bis.read(buffer)) != -1){
			bos.write(buffer,0,a);    
			bos.flush();    
		}catch(Exception e)

其他：

注意事项：

1. 用了要及时.close();
2. 使用IO对文件进行处理的指令一般要用try{ } 引起来
3. 一般最后都要回收Exception

	catch (Exception e){          //close的时候是 IOException
	e.printStackTrace();
}

五、JavaFX&图形界面编程（GUI）

六、Java多线程

七、Java的URL编程（Socket）

  Socket之间的连接过程可分为三个步骤：服务器监听，客户端请求，连接确认

1、SeverSocket类

  在客户/服务器通信模式中，ServerSocket 负责接收客户端连接请求，并生成与客户端相连接的Socket。

构造方法：

  SeverSocket(int port,int backlog,InteAddress,bindAddr):使用指定的端口、监听backlog和要绑定到本地的IP地址创建服务器。

常用方法：

• Sever accept()：监听并接收到此套接字的连接。

2、Socket类

  Socket类表示通信双方中的客户端，用于呼叫远端机器上的一个端口，主动向服务器端发送数据（当连接建立后也能接受数据）

构造方法：

  Socket(String host,int port,InteAddress,localAddr,int localPort)：创建一个套接字并将其连接到指定远程地址上的指定远程端口。Socket会通过调用bind()函数来绑定提供的本地地址及端口。

常用方法：

• .getInterAddress()：返回套接字的连接地址。
• .getLocalAddress()：获取套接字绑定的本低地址。
• .getInputStream()：返回此套接字的输入流
• .getOutputStream()：返回此套接字的输出流

八、Java的SQL程序设计

九、Java中的一些问题以及解决方法

1、如何将字符串转换为字符串数组

2、强制转换

使用方式一般为：（欲转换的数据类型）变量名

如果是需要由大类型转换为小类型:

• String转换为int就可以使用parseInt：
  int a = Integer.parseInt(“1234”);
• String转integer：
  Integer x = Integer.valueOf(“1234”);
• int转为String：
  String myString = " " + myInt;
• String转换为Boolean：
  Boolean.parseBoolean(String a);

3、生成随机数

 随机数的产生在一些代码中很常用，也是我们必须要掌握的。而java中产生随机数的方法主要有三种：

• 第一种：new Random()

• 第二种：Math.random()

• 第三种：currentTimeMillis()

①new Random（）

public static void main(String[] args)
{
　　Random r = new Random(1);
　　for(int i=0 ; i<5 ;  i++)
　　{
　　　　int ran1 = r.nextInt(100);
　　　　System.out.println(ran1);
　　}
}

②Math.Random

public static void main(String[] args)
{    
         int max=100,min=1;
         int ran2 = (int) (Math.random()*(max-min)+min); 
         System.out.println(ran2);
}

③currentTimeMillis()

public static void main(String[] args)
    {
        int max=100,min=1;
        long randomNum = System.currentTimeMillis();
        int ran3 = (int) (randomNum%(max-min)+min);
        System.out.println(ran3);

    }

附录：

1、运算符优先级表

2、Java中常用的Package

导入方式：import 包名.类名

• java.lang：语言包
• java.io：输入输出流的文件包
• java.util：实用包
• java.net：网络功能包
• java.sql：数据库连接包
• java.text：文本包