小白记事本--JAVA入门

JAVA的安装与环境配置

Windows传送门 java开发环境搭建与eclipse安装教程

win10环境配置传送门：win10java环境配置
2021/6/8补充：java系统学习传送门：bilibili韩顺平老师

2020.7.17记录

这里是helloworld！

• 
• 

这里是JAVA符号集
可分为五类：标识符、关键字、运算符、分隔符、常量
标识符（name）：
以字母、下划线或美元符号 开头；区分大小写

• 合法：age、_value、_1value
• 非法：123abc、-salary

关键字（保留字）：
不能用关键字作为标识符
//不能用关键字起名字

• 关键字：if while class int float 等等

运算符与分隔符

• 运算符：+ - * / % ++ += –
• 分隔符： () {} [] , ;

数据类型常量与变量

• 数据类型
  

• 常量

• 

这里是变量
变量要 先声明后使用；变量声明后，在使用前没有赋值则编译报错

package vicomigo;

public class Text {

	public static void main(String[] args) {
		char ch1='a';
		int i=10;
		float x1=2.3f;
		System.out.println(ch1);
		System.out.println(i);
		System.out.println(x1);
	}
}

• 

2020.7.18记录

这里是表达式与语句

• 算术运算-自增自减

package vicomigo;

public class Text {

	public static void main(String[] args) {
		int a1=2,a2=2;
		System.out.println((a1++)*2);  // a1*2+1;
		System.out.println((++a2)*2);  // (a2+1)*2;
		System.out.println(a1);        // a1=3;
		System.out.println(a2);        // a2=3;   
	}

}

4
6
3
3

• 赋值表达式-强制类型转换
• 

显示类型转换：把高精度变成低精度，暂时性的改变高精度

package vicomigo;

public class Text {

	public static void main(String[] args) {
		int i;
		double d=2.5;
		i=(int)d;
		System.out.println(i);
		System.out.println(d);
	}
}

2 //显示类型转换
2.5 //本体没改变

• 逻辑表达式（布尔型值）
  
• 条件运算符（？：）

package vicomigo;

public class Text {

	public static void main(String[] args) {
		double a,b,d=2.5;
		b=(d==2)?20:30;  //(d==2)成立b=20,反之b=30;
		a=(d==2.5)?20:30;
		System.out.println(b);
		System.out.println(a);
	}
}

30.0
20.0

这里是程序控制结构
3种：顺序、分支和循环结构

• 分支结构（if、switch）

package vicomigo;

public class Text {

	public static void main(String[] args) {
		double a=2.5;
		if(a==1) {
		System.out.println(a+1);}
		else if(a==2) {
		System.out.println(a+2);}
		else System.out.println(a);  //以上条件都不符合
	}
}

2.5

package vicomigo;

public class Text {

	public static void main(String[] args) {
		char grade='B';
		switch(grade)
		{
		case'A':
			System.out.println("优秀");
			break;  //如果没有break则继续判断下一条
		case'B':
			System.out.println("不错");
			break;  //跳出switch语句
		default:    //必须存在且在最后
			System.out.println("不太行");
		}
		
	}
}

不错

• 循环结构（while、do~while 、for）

同c语言
注意do~while

2020.7.19记录

• 今天的下的雨好大！天气预报说明天还会继续下！
• 下雨天总喜欢钻被窝，今天基本上啥也没干…Orz

这里是类和对象
对象是类的一个实例，对象有状态（属性）和行为（方法）
public：类名前面的public是类的修饰符，用于说明对它的访问限制。如果一个类前无修饰符，则这个类只能被同一个程序文件中的类使用。如果一个类的修饰符是public，则这个类是公共类。
Java规定，在一个程序文件中，只能定义一个public类，其余的类可以是无修饰符的类，也可以是用其他修饰符定义的类，那之前我们写的person类就是无修饰符的类，所以它只能被同一个程序文件中的类使用。

• 

用户自定义类的格式：

创建对象，使用对象。

创建对象时，通常首先要为对象的数据成员赋初始值，这被称为对象的初始化，初始化是最常用的操作之一，那为了简化这一操作，Java系统提供了专用的方法——构造方法来完成这一操作。

构造方法是一个类的方法中方法名与类名相同的类方法，每当使用new关键字创建一个对象，Java系统将自动调用构造方法初始化这个新建对象，来看代码

构造方法的特殊性质：

当成员方法的形参名与数据成员名相同，或者成员方法的局部变量名与数据成员名相同时，在方法内借助this来明确表示引用的是类的数据成员，而不是形参或局部变量，从而提高程序的可读性，使用形式如下：this.数据成员、this.成员方法(参数)，来看代码

2020.7.20记录

• 天气预报只管报，不管准。
• 今天没下雨！(╬◣д◢) 哼，然后玩了很久很久的《光·遇》//这玩意儿要是有虚拟头盔配合就好了

这里是java类库
Java的类库是系统提供的已实现的标准类的集合，是Java编程的API(Application Program Interface)，有了类库中的系统类，编写Java程序时就不必一切从头做起，避免了代码的重复和可能的错误，也提高了编程的效率。
系统定义好的类根据实现的功能不同，可以划分成不同的集合。每个集合称为一个包，所有包合称为类库，根据功能的不同，Java类库的每个包中都有若干个具有特定功能和相互关系的类和接口。使用类库中系统定义好的类有三种方式

使用系统类的前提条件——该系统类是用户程序可见的类。
import语句引入系统类所在的包。

//package vicomigo;
import java.awt.event.*;
import java.awt.*;

java修饰符：访问修饰符、非访问修饰符

访问修饰符：保护对类、变量、方法和构造方法的访问，java支持4种访问权限。

• 默认的（default）不使用任何修饰符，只能被同一个包里的类使用
• 私有的，以 private 修饰符指定，在同一类内可见；
• 共有的，以 public 修饰符指定，对所有类可见；
• 受保护的，以 protected 修饰符指定，对同一包内的类和所有子类可见，子类以后我们在讲。可以通过下图来说明访问权限
  

类修饰符：说明对它的访问限制
public修饰符，则这个类是公共类。公共类不但可供它所在包中的其他类使用，也可供其他包中的类使用。在程序中可以用import语句引用其他包中的public类。
final修饰符，用final修饰符修饰的类被称为最终类。最终类是不能被任何其他类所继承的
abstract修饰符，修饰的类称为抽象类，抽象类刻画了研究对象的公有行为特征，并通过继承机制将这些特征传送给它的派生类，这里提到的继承派生以后再讲，先了解就可以了

访问权限控制符（不能修饰 类class，除public）：一个类总能够访问自己的数据成员和成员方法。但是，其他类是否能访问这个类的数据成员或成员方法，是由该类的访问控制符及该类数据成员和成员方法的访问控制符决定的。
数据成员和成员方法的访问控制符有：
public、private、protected和缺省访问控制符等几种，缺省是指默认，下表可以参考

• 公共访问控制符public
  当一个类被声明为public时，只要在其他包的程序中使用import语句引入这个public类，就可以访问和引用这个类，创建这个类的对象，访问这个类内部可见的数据成员和引用它的可见的方法。
  处于不同包中的public类作为整体对其他类是可见的，并不代表该类的所有数据成员和成员方法也同时对其他类是可见的，这得由这些数据成员和成员方法的修饰符来决定。
  只有当public类的数据成员和成员方法的访问控制符也被声明为public时，这个类的所有用public修饰的数据成员和成员方法也同时对其他类是可见的
• 缺省（默认）访问控制符（友好访问）
  如果一个类没有访问控制符，规定只有在同一个包中的对象才能访问和引用这些类，因此，又称为包访问性。同理，类内的数据成员和成员方法如果没有访问控制符来限定，也具有“友好访问”的特性，它们也具有包访问性，可以被同一个包中的其他类所访问和引用，来看个例子吧

package vicomigo;


public class Text {

	public static void main(String[] args) {
		person p=new person();  //引用了类person和类的成员方法run()
		p.run();                //在类person中又引用了类dog和dog成员方法eat()

	}
}

class person{                   //没有访问控制类
	String name;
	void run() {
		System.out.println("人跑步");
		dog d=new dog();
		d.eat();
	}

}
class dog {                     //没有访问控制类
	int age;
	void eat() {
		System.out.println("狗狗吃饭饭");
	}
}

人跑步
狗狗吃饭饭

• 私有访问控制符private
  用private修饰的数据成员或成员方法只能被该类自身所访问和修改，而不能被任何其他类(包括该类的子类)来访问和引用，记住类（class）不能声明为 private。当其他类希望获取或修改私有成员时，需要借助于类的方法来实现，来看例子

package vicomigo;


public class Text {

	public static void main(String[] args) {
		person p=new person();
		p.setname("Ming");
		String name=p.getname();
		System.out.println(name); //无法直接使用p.name
	}
}

class person{
	private String name;     //只可自身用
	public String getname() {//public方法getname(),返回值String类型
		return this.name;
	}
	public void setname(String name) {
		this.name=name;
	}

}

• 保护访问控制符protected
  用protected修饰的成员变量和方法可以被三种类引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类，注意protected 访问修饰符不能修饰类（class）

非访问权限修饰符：（static final）

• static修饰符
  修饰的数据成员是不属于任何一个类的具体对象，而是属于类的静态数据成员，一个类的任何对象访问它时，存取到的都是相同的数值，可以通过类名加点操作符访问它，static类数据成员仍属于类的作用域，还可以使用public static、 private static等进行修饰。

修饰符不同，可访问的层次也不同，可以看到在类y中创建类变量num，然后写了类方法getCount()，返回值为int类型，方法里返回类变量num，主入口方法里调用类的成员方法getCount()，返回值赋给int类型的c，然后打印c

• final修饰符
  如果一个类的数据成员用final修饰符修饰，则这个数据成员就被限定为最终数据成员。最终数据成员可以在声明时进行初始化，也可以通过构造方法赋值，但不能在程序的其他部分赋值，它的值在程序的整个执行过程中是不能改变的，通常和 static 修饰符一起使用来创建类常量，来看个例子

package vicomigo;


public class Text {
	
	final int value=10; //final声明初始化为10
	//下面为声明常量实例
	public static final int Count=6;
	
	public static void main(String[] args) {
		value=9; //报错
	}
}

因为value用final修饰符修饰的，在声明时进行初始化了，在其他地方不能改变它的值

这里是总结提纲：
orz去歇息了

java修饰符	类修饰符
访问修饰符（4种权限）和非访问修饰符	3种（累加注意）

2020.7.21记录

• 今天去赶礼，环境超级好。可惜一天又搭进去了，回来一下午光遇。
• 抓紧时间干点正事ORZ

这里是java的变量类型：类变量、实例变量和局部变量
变量使用前必须声明
类变量是独立于方法之外的变量，用static修饰
实例变量是独立于方法之外的变量，没有static修饰
局部变量是类的方法中的变量

package vicomigo;


public class Text {
	static int a=0;            //类变量
	String str="hello world";  //实例变量
	public void method() {
		int i=0;               //局部变量
	}
}

• 局部变量
  局部变量声明在方法、构造方法或者语句块被执行的时候创建，执行完成后变量销毁。访问修饰符不能用于局部变量。局部变量没有默认值，声明后必须初始化才能使用。

package vicomigo;


public class y {
	public void addAge() {
		int age=0;//局部变量age的初始化
		age=age+7;
		System.out.println("age="+age);
	}
	public static void main(String args[]) {
		y test=new y();//创建对象y
		test.addAge(); //调用成员方法addAge()
	}
	
}

如果局部变量没有初始化就会报错：

• 实例变量
  

package vicomigo;


public class Text {
	//实例变量name
	public String name;
		//私有变量age仅在该类可见
	private int age;
		//在构造器中对name赋值
	public Text(String yname) {
		name=yname;
	}
		//设置age的值
	public void setAge(int age) {
		this.age=age;
	}
	public void printy() {
		System.out.println("名字：" + name);
		System.out.println("年龄：" + age);
	}
	public static void main(String args[]) {
		Text test=new Text("red");//创建对象Text
		test.setAge(100);          //调用传参
		test.printy();			   //调用方法
	}
}

名字：red
年龄：100

• 类变量（静态变量）
  

package vicomigo;


public class Text {
	//age是静态的私有变量
	private static int age;
	//NAME是一个常量
	public static final String NAME="RED";

	public static void main(String args[]) {
		age=100;
		System.out.println(NAME +"年龄"+age);
	}
}

RED年龄100

2020.7.22记录

• 今晚开了个小会，又要被白嫖了，哭泣，暑假有的忙了

这里是数组
访问可以通过数组名+下标

• 声明格式
  
• 初始化

直接指定初值 或 new操作符完成
注意下标也是从0开始，注意初始化不同，使用方法同c

//直接指定
int[] a1= {23,-9,38,8,65};
//关键词new
	//第一种
		int a[];
		a=new int[9];
	//第二种（较常用）
		int[] a=new int[10];

• 测定数组长度

int count=a.length;
System.out.println(count);

• 遍历数组

foreach循环（加强型循环）：不知道下标的情况下遍历数组

package vicomigo;


public class Text {
	public static void main(String args[]) {
		int[ ] a= {1,2,3,4,5};
	for(int element:a) {	//int代表数组中元素类型，element就每个元素，冒号后面是数组
		System.out.println(element);
	}
	}
	
}

2020.7.23记录

• 今天可太忙了，昨晚通宵很累

这里是Character类和String类

character类用于对单个字符进行操作，在对象中包装一个基本类型char的值
包装类character类提供一系列方法来操纵字符，使用构造方法创建一个character类对象
如：

package vicomigo;


public class Text {
	public static void main(String args[]) {
		char ch='a';
		char[] charArray= {'a','b','c'};
		Character ch1=new Chracter('a');//构造方法
	}
	
}

装箱与拆箱
装箱：将char类型参数传递给需要一个Character类型参数的方法时，编译请自动将char转换成Character对象
拆箱：反之。

package vicomigo;


public class Text {
	public static void main(String args[]) {
		//'a'装箱到Character对象ch中
		Character ch='a';
		//'b'用test方法装箱，返回拆箱的值到'c'
		char c=test('b');
	}
	
}

• 转义字符

System.out.println("我是\"酷酷的仔\"");

我是"酷酷的仔"

Character类的方法

package vicomigo;

public class Text {
	public static void main(String args[]) {
		System.out.println(Character.isLetter('a'));
		System.out.println(Character.isLetter('3'));
	}
}

true
false

String类的对象是创建后不能变动的字符串常量

创建String对象
java的任何字符串常量都是String类的对象，未明确命名时，自动创建匿名String类的对象，也被称为匿名String类的对象。
字符串常量必须用双引号括起，如：

System.out.println("OK!!");
String c1='Java';

创建String对象：关键字/构造方法（11种）
如：

package vicomigo;

public class Text {
	public static void main(String args[]) {
		//字符数组 h
		char[]h= {'h','e','l','l','o'};
		//创建String对象 hs
		String hs=new String(h);
		System.out.println(hs);
	}
}

hello

String类的方法
如：计算字符串的长度与字符串的拼接

• 字符串的长度

package vicomigo;

public class Text {
	public static void main(String args[]) {
		String str="HELLO";
		int len=str.length();
		System.out.println("str长度"+len);
	}
}

str长度5

• 字符串的拼接

package vicomigo;

public class Text {
	public static void main(String args[]) {
		System.out.println("Hello"+"World");
	}
}

HelloWorld

2020.7.26记录

• 两天没写了哇！ORZ
• 24看乘风破浪的姐姐，昨天…晚上光遇去了

这里是java方法
Java方法是语句的集合，它们一起执行一个功能，方法包含于类和对象中，在程序中被创建，在其他地方被引用。
命名规则：必须以字母、_ 或$开头，可以包括数字但不能以它开头。

方法的定义：
方法包含一个方法头和一个方法体，以下为一个方法的所有部分

package vicomigo;

public class Text {
	//主方法
	public static void main(String args[]) {
		int i=10,j=20,k=max(i,j);
		System.out.println("最大值是："+k);
	}
	//返回两个整数变量较大的值
	public static int max(int num1,int num2) {
		int result;
		if(num1>num2) {
			result=num1;
		}else result=num2;
		return result; 
	}
}
最大值是：20

方法的重载：
如果让max方法不仅适用于int类型，还想要适用于double类型，则可以创建另一个拥有相同名字但参数不同的方法。
重载的方法必须拥有不同的参数列表，不能只根据修饰符或者返回类型的不同来重载方法。

package vicomigo;

public class Text {
	//主方法
	public static void main(String args[]) {
		double i=10.5,j=20.6,k=max(i,j);
		System.out.println("最大值是："+k);
	}
	//返回两个整数变量较大的值
	public static int max(int num1,int num2) {
		int result;
		if(num1>num2) {
			result=num1;
		}else result=num2;
		return result; 
	}
	//返回两个double类型变量较大的值
	public static double max(double num1,double num2) {
		double result;
		if(num1>num2) {
			result=num1;
		}else result=num2;
		return result; 
	}
	
}

最大值是：20.6

变量的作用域：
变量的范围是程序中该变量可以被引用的部分。
方法内定义的变量称为局部变量，局部变量的作用范围从声明开始，直到包含它的块结束，局部变量必须声明才能使用，方法的参数范围涵盖整个方法。参数实际上是个局部变量。

2020.7.27记录

• 今天是7.29日（周三），补全之前的坑
• 昨天重装了系统令人头秃，明天晚上重新配置环境
• 老弟有点难带…最近玩光遇有点多…这样不好

这里是重载（overload）与重写（override）
重写：子类对父类的允许访问的方法的实现过程进行重新编写，返回值和形参都不能改变。
重载：在一个类里面，方法名字相同，参数不同，返回类型可同可不同，每个重载方法（或构造函数）都必须有一个独一无二的参数类型列表，最常用的是构造器的重载。
==重写与继承有关，重载与改变参数有关 ==

- 重写规则

• 
  - 重载规则
• 

关于重写的例子：

package yyy;

public class y {
    public static void main(String []args) {
		Animal a=new Animal();
		Animal b=new Cat();
		a.move();
		b.move();
       //System.out.println("Hello World!");
    }
}
class Animal{
	public void move(){
		System.out.println("动物可以移动");
	}
}
class Cat extends Animal{    //Cat类继承Animal类
	public void move(){
		System.out.println("猫可以跑走");
	}
}

动物可以移动
猫可以跑走

Cat 类中的bark()方法 没有在Animal中声明，违背重写规则了

关于重载的实例

package yyy;

public class y {
    //名字相同，但参数不同：
    public int test(){
        System.out.println("test1");
        return 1;
    }

    public void test(int a){
        System.out.println("test2");
    }
    //以下两个参数类型顺序不同
    public String test(int a,String s){
        System.out.println("test3");
        return "return-test3";
    }
    public String test(String s,int a){
        System.out.println("test4");
        return "return-test4";
    }
    //主方法：
    public static void main(String []args) {
        y t=new y();
        System.out.println(t.test());
        t.test(1);
        System.out.println(t.test(1,"test3"));
        System.out.println(t.test("test4",1));
    }

}

//运行结果
test1
1
test2
test3
return-test3
test4
return-test4

重写于重载之间的区别

2020.7.29记录

• 继续补前两天的坑，一匹游戏孤狼一天玩一会就好啦
• Adobe全家桶这周末找时间重装上
• 现在是0:39，祈祷自己gkd

这里是Java异常处理机制
目的：为有效及时处理程序运行中的异常错误
Java引入了异常和异常类，并定义了许多异常类，每个异常类代表一类运行错误，类中包含该运行错误的信息和处理错误的方法等。
=分=割=线==
每当Java程序运行过程中发生一个可识别的运行错误时，系统都会产生一个相应异常类的对象，并由系统中相应的机制来处理，以确保不会产生死机、死循环或其他对操作系统有损害的结果，从而保证了整个程序运行的安全性。

异常类都继承自java.lang.Throwable类，Excepetion类（异常类）是其子类，Throwable类的另一个子类是Error类，用来指示运行时环境发生的错误，而异常类包含一般性的异常、

• 睡了睡了搞不动了，明天继续啦晚安

异常类的继承关系：

由于java.lang包是默认加载到所有java程序的，所以大部分从运行时异常类继承而来的异常都可以直接使用。
Exception类分为运行时异常和非运行时的异常：
前者指再Java运行系统执行过程中的异常（已经发生）
后者是由Java编译器在编译时检测是否会发生在方法的执行过程的异常（提前检测）

• 常见运行时的异常类
• 常见非运行的异常类

Error类及其子类
Error类定义了正常情况下不希望捕捉的错误。

• 常见的Error异常类
  

异常处理机制结构
当程序运行过程中发生异常时，可采用两种方式处理异常：
1.由预设处理方法：一旦程序异常，程序会被终止并显示一些错误信息给用户
2.try-catch-finally语句：自行处理异常，最主要的有点是将处理异常的代码与程序代码主线分离，增强程序可读性；其次可减少中途终止程序运行的可能性。
在大多数情况下，系统预设的异常处理方法只是显示信息并结束程序执行，并不能符合我们的需求，因此，提供try-catch-finally语句可以明确捕捉某类型的异常，并按我们要求加以适当处理。

• try-catch-finally结构
  

捕获异常：将代码块放在异常可能发生的地方，代码块中的代码成为保护代码。
语法：

class Main {
	public static void main(String[] args) {
        try{
            int a[]=new int[2];  //声明由两个元素的数组a
            System.out.println(a[3]); 
        }catch(ArroyIndexOutOfBoundsException e){ //捕获异常，接受try语句生成的异常
            System.out.println("异常是："+e);
        }
        
	}
}

多重捕获异常：
一个try后面跟多个catch，所以捕获到一个异常后，后面的catch不做处理直接忽略跳过去。

Java的异常是系统在程序运行时抛出的，但我们也可根据实际情况抛出一个异常。
我们通常使用Throw和Throws语句抛出异常
Throw：明确地抛一个，改变程序的执行流程，是程序调到相应的异常处理语句中执行。
Throws：不要一个方法本身处理异常，把异常向上交给调用这个方法的方法处理。

-Throw实例

• Throws实例

Throw与Throws区别

1. throws出现在方法函数头，而throw出现在函数体
2. throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某种异常对象。

finally关键词：

• java入门基本就结束了，今天是7.31日
• 大致补全前几天剩下的内容，光遇里练琴去了。
• 准备8.1补上一个实例就ok了：）重装系统后没来得及重新配置…心累

2020.8.2记录

• I am OK，重安eclipse好慢a
• ohhhhhhh安装成功！
• 现在是8.3，要开学了…ORZ

计算并显示圆半径、面积、周长、圆柱体的体积

public class program {
	public static void main(String[] args) {
        Circle Ci=new Circle(10.0);
        Ci.disp();
        Cylinder Cyl=new Cylinder(5.0,10.0);
        Cyl.disp();//因为继承了圆类
        Cyl.dispVol();
	}
}

class Circle{
    private double radius;
    Circle(){
        return radius=0.0;
    }
    Circle(double r){
        return radius=r;
    }
    double getPerimeter(){
        return 2*Math.PI*radius;
    }
    double getArea(){
        return Math.PI*radius*radius;
    }
    void disp(){
        System.out.println("半径："+radius);
        System.out.println("周长："+getPerimeter());
        System.out.println("面积"+getArea());
    }
}
class Cylinder extends Circle{
    private double hight;
    Cylinder(double r,double h){
        super(r);//调用父类的构造器
        hight=h;
    }
    public double getVol(){  //注意多了public后可在主函数中直接调用
        return getArea()*hight;
    }
    public void dispVol(){
        System.out.println("圆柱体体积"+getVol());
    }
}

2020.8.3记录

• 呐~ 入门应该就结束啦(#^^.^#)
• 一如光遇深似海，肝的停不下来…88