在C语言基础下学习Java笔记

本篇博客记录笔者在已经学习过C语言的基础下，学习Java内容的笔记。主要用于区别两者的不同，作为补充使用。（个人自用）本篇文章持续更新
因本人的习惯，所以有图能解释理解的，笔者会先将图放在前面，文字放在后面。
使用书籍：《明解Java》
编者：[日]柴田望洋
译者：侯振龙

《明解Java》

第六章：数组

1.数组书写：

//正确：
     int[] a=new int[5];
     int[] b={
     1,2,3};
     int[] c;
     c=new int[3];
     c=new int[]{
     1,2,3，4};
//错误：
	int[] d;
	d={
     1,2,3,4};

c与d的不同：

这里是引用
在使用new运算符创建数组时，"new元素类型[ ]"的后面可以加上初始值。

2.方法间的数组传递：

与指针功能一样，不是新建了个数组进行操作，而是直接引用原先的数组，所以可以改变原来的值。C语言同样如此。

	static void change(int[] a){
     
        a[0]=5;
    }
     public static void main(String[] args) {
     
	     int[] a={
     1,2,3,4};
	     change(a);
	     for(int i=0;i<a.length;i++)
	         System.out.print(a[i]+' ')；
    }
    //输出结果
    5 2 3 4 

3.使用完后就被舍弃的数组

	int[] a={
     1,2,3,4};
    int i=Search(a,3);//Search为查找a数组中是否存在3的函数
    //可以直接写为
    int i=Search(new int[]{
     1,2,3,4},3);

与这个感觉原理一致。

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

4.方法可以返回数组的引用

函数类型应该写成

	int[] 函数名();

如果写成

int 函数名()[]

必须考虑兼容性的问题，所以推荐前一种写法。

第八章：类

1.构造函数

正确的初始化实例
比如正确写法为：

Account cjy = new Account("崔金玉",18,2020);

而不能写成

Acount cjy = new Acount("崔金玉");

2.方法

未加static的称为实例方法。每一个实例均有自己对应的实例方法。
有static的称为类方法。所有实例共用一个方法。（与类整体相关的处理）
同样：
未加static的称为实例对象。每一个实例均有自己对应的实例对象
有static的称为类对象。所有实例共用一个对象。

3.标识符命名

以下仅作推荐使用
类：名词；首字母大写
接口：名词；首字母大写
方法：

• 动词；第一个单词首字母小写，其余单词首字母大写。如：moveTo
• 获取(get)变量v的值：getV
• boolean类型：isInterrupted
• 设置(set)变量v的值：setV

第九章：创建日期类

1.类类型变量的比较

运算符 == 与 ！= 均判断引用是否相等。

Day day1 = new Day(2020,12,1);
Day day2 = new Day(2020,12,1);
if(day1==day2)
	System.out.println("相等");
else
	System.out.println("不相等");
//输出结果
不相等

比较的是引用，两个引用不一样，不管值如何。结果均为不相等

2.类类型实例的数组

需要a[i] = new Day(y,m,d);

Day[] a = new Day[3];
for(int i=0;i<a.length;i++)
	a[i].set(2020,12,1); //错误，a[i]此时只是Day类型的变量，但是还都没有指向实例。所以不能使用set方法。
//正确写法：
for(int i=0;i<a.length;i++)
	a[i] = new Day(2020,12,1);

其他赋初值方式

Day[] a = {
     new Day(1868,9,8),
		   new Day(1912,7,30),
		   };

Day[] a;
a = {
     new Day(1868,9,8),
	 new Day(1912,7,30),
     };

其实和数组一样。

3.调用同一个类中的构造函数

this(…)的调用只限于在构造函数的开头使用。

public Day()							{
      }
public Day(int year)					{
     this.year=year}
public Day(int year,int month)  		{
     this(year); this.month=month;}
public Day(int year,int month,int day)	{
     this(year,month);this.day=day;}

4.类类型–>引用

类类型均为创建了一个引用变量，必须创建实例后，才能对其进行操作。

public class Car{
     
	private Day purchaseDay;	//类类型的字段
	.....
	}

必须

	purchaseDay = new Day();

第一个代码片中Day purchaseDay;不管放在哪里，都得创建实例后，才能操作。和前面数组一样，所以其实都是这样的，核心思想就是这种创建只是创建变量，创建引用，并非创建实例，必须调用构造函数初始化实例才能用。

5.返回引用的方法

Car myCar = new Car(2010,10,15);
Day p = myCar.getpurchaseDay();
p.set(1999,12,31);
Day q=myCar.getPurchaseDay();

第一种：

public Day getPurchaseDay(){
     
	return new Day(purchaseDay);
}

返回的是一个购买日期字段副本的引用，所以myCar的购买日期不变。
q为2010，10，15
第二种：

public Day getPurchaseDay(){
     
	return purchaseDay;
}

返回的是购买日期字段本身的引用，此时myCar的购买日期被更改。

6.小结

• 当通过方法的参数传递类类型的变量时，传递的是实例的引用。

使用书籍：《Java核心技术卷Ⅰ》
编者：[美]凯S.霍斯特曼
译者：周立新、陈波、叶乃文、杜永萍

《Java核心技术卷I》

3.1大数值

BigInteger和BigDecimal两个类可以处理包含任意长度数字序列的数值
但是+，与*需要变成add和multiply方法。

3.2.1 for each循环

for(int element:a)//"循环a中的每一个元素"(for each element in a)
	System.out.println(element);

例如：

int[] a = new int[]{
     1,2,3,4,5};
         for (int ele:a)
            System.out.println(ele);
//输出结果：
1
2
3
4
5

提示：打印数组还可以使用Arrays的toString方法

 System.out.print(Arrays.toString(a));
 //输出结果：
 [1,2,3,4,5]

3.2.2数组拷贝

将数组变量赋给另一个数组变量，这时候两个变量引用同一个数组！！不是新创建一个。

int[] luckNumbers = smallPrimes;
luckyNumbers[5]=12;// 这个时候smallPrimes[5]也为12；

如果想创建一个与原数组数值相同的数组

int[] copiedLuckNumbers = Arrays.copyOf(luckyNumbers,luckNumbers.length);//注意第二个参数是copiedLuckNumbers的数组长度，大于原数组长度，多余元素赋值0，小于原数组长度，只拷贝前面的数组元素。

注意
数组拷贝这里与C不同，在C中

int a[]={
     1,2,3};
int b=a;//b新创建了一个与a数值相同的数组

3.3.3数组排序

使用Arrays.sort();

int[] a=new int[100];
Arrays.sort(a);

其它方法：

static String toString(type[] a)
static type copyOf(type[] a,int length)
static type copyOfRange(type[] a,int start,int end)
static void sort(type[] a)
static int binarySearch(type[] a,type v)
static int binarySearch(type[] a,int start,int end,type v)
static void fill(type[] a,type v)
static boolean equals(type[] a,type[] b)

快速回想一下，想不起来查API手册

第四章：对象与类

4.1类

4.1.1类的关系：

• 依赖
• 聚合
• 继承

4.2对象

1.构造器的名字应该与类名相同
2. new Date(); //构造了一个新对象
3.

Date birthday = new Date();

当构造的对象想多次使用，可以赋给一个对象变量
一个对象变量并没有实际包含一个对象，而仅仅引用一个对象
这里同时解释了之前数组拷贝的内容，当int []b=a;时，b与a指向同一个数组。
但是在int a; 时，这不是创建了一个对象，而是一个对象变量。
4.

Date birthday = new Date();
birthday = null;//可以将对象变量设置为null，代表这个对象变量目前没有引用任何对象
birthday.toString(); //错误，方法不能用于值为null的对象

4.3时间

4.3.1时间点的Date类

4.3.2日历表示法LocalDate类

1.LocalDate使用

LocalDate.now()；//使用静态工厂方法代表调用构造器
LocalDate newYear=LocalDate.of(1999,12,31);//将构造的对象保存在newYear(对象变量)中

int year = newYear.getYear();//1999,方法(getYear）用于对象变量(newYear)

2.year是一个对象变量，但是并没有进行引用，引用写成new XXX();那种，这里只是得到了一个数据，如果int a=year;a=1999;并不会改变year的值。

LocalDate newYear = LocalDate.now();
         int year = newYear.getYear();
         int a=year;
         a=1999;
         System.out.print(year);//2020

4.3.3更改器方法和访问器方法

更改器方法：访问的同时进行改变原对象的值
例子：GregorianCalendar类（较早版本使用）
访问器方法：访问后，创建一个新的对象。

		LocalDate newYear = LocalDate.now();
        LocalDate athousdays=newYear.plusDays(100);
        System.out.print(athousdays);//2021-3-12

4.3.4minusDays(today-1);

假设今天14号

LocalDate date =LocalDate.now(); 
date=minusDays(13);//此时date指向13天前，也就是1号。

同理date=minusDay(n);
代表n天前；

其它方法

static LocalTime now( )
static LocalTime of(int year,int month,int day)
int getYear( )
int getMonthValue()
int getDayOfMonth()
DayOfWeek getDayOfWeek
LocalDate plusDays(int n)
LocalDate minusDays(int n)

4.4类中实例域、构造器、方法

解释下文前阅读代码

import java.time.LocalDate;
public class Test {
     
    public static void main(String[] args) {
     
        Employee[] stuff = new Employee[3];
        stuff[0]=new Employee("a",100,1,2,2019);
        stuff[1]=new Employee("b",200,2,2,2019);
        stuff[2]=new Employee("c",300,3,2,2019);
        }
}

class Employee{
     
    private String name;
    private double salary;
    private LocalDate hireday;

    public Employee(String n,double s,int d,int m,int y){
     
        name=n;
        salary=s;
        hireday=LocalDate.of(y,m,d);
    }
    public String getName(){
     
        return name;
    }
    public double getSalary(){
     
        return salary;
    }
    public LocalDate getHireday(){
     
        return hireday;
    }

    public void riseSalary(double percent){
     
        double raise=salary*percent;
        salary+=raise;
    }
}

Employee类包含一个构造器和 4 个方法：
public Employee(String n , double s, int year, int month , int day) //构造器
public String getName()
public double getSalary()
public Local Date getHi reDay()
public void raiseSalary(double percent)

三个实例域
private String name;
private double salary;
private Local Date hireDay;

• 构造器与类同名。
• 每个类可以有一个以上构造器
• 构造器可以有0个、1个或多个参数
• 构造器没有返回值
• 构造器与其他方法不同，构造器总是伴随着new操作符的执行被调用，但是不能对一个已经存在的对象调用构造器重新设置实例域。
  注意
  不要在构造器中定义与实例域重名的局部变量
  public Employee(String n, double s, . . ){
  String name = n; // Error -->可以这样写，但是这样会屏蔽实例域的name，这个只能在构造器中使用，所以不建议。
  double salary = s; // Error -->同上
  }

4.5隐式参数、显式参数

stuff[0].raiseSalary(0.5)

stuff[0]：隐式参数
raiseSalary：方法
0.5：显式参数

在每一个方法中， 关键字 this 表示隐式参数。 如果需要的话，可以用下列方式编写
raiseSalary 方法：
public void raiseSalary(double percent) {
double raise = this.salary * percent;
this.salary += raise;
}
有些程序员更偏爱这样的风格，因为这样可以将实例域与局部变量明显地区分开来。

name一旦设定，便无法修改。
如果需要获得或设置实例域的值，应该提供下面三项内容：
-一个 私有的数据域；

• 一个公有的域访问器方法；
• 一个公有的域更改器方法。

4.6 final实例域

final关键字只是表示存储在变量中的对象引用不会再指示其他对象，但是这个对象可以更改。
也就是一夫一妻制度下，虽然你妻子不能变成别人，但是妻子可以做做头发。