Java学习第一周

第一天：

首先学习了一些java语言的基本特性和idea软件的简单使用

和教程中的idea相比，我的idea的界面显示是不太一样的。但应该不影响使用

我的java和jdk的版本为 "1.8.0_261"

对于Java中的数字，如果不在后面加上后标，都会被默认为int型的变量

比如long a=123456789123456

这个数字符合long的要求，但在Java中会报错。必须要在后面加上一个l

比如： long a=123456789123l，这样才是可行的

看了一些比较基础的内容，这些内容在以前算都是学过了，希望这段时间可以尽快把这部分给推进完。对一些稍微重要一点的部分进行记录。

第二天:

小数默认的是double类型的。如果想要用float，同样要在后面加上一个F才可以实现

浮点类型的数是无法做到精确计算的。

中文也可以作为变量名，但不建议。

‘’  单个字符，""  字符串

注意：Java中的布尔类型是boolean,这个和C语言中的不一样，注意区分

整数和整数运算：结果为整数

整数和小数运算：结果为小数

小整数和大整数计算：结果为大整数

%取余，与C语言一样

强制类型转换：

int a=10;

short b=(short) a

& 与运算 ，都是1才是1

| 或运算，一个1就是1

^ 异或运算，一个1一个0才是1

！非运算，0为1，1为0

左移运算符和右移运算符

>>  <<

这里需要结合0,，1编码进行理解，属于计组里面的内容

三元运算符

判断语句 ? 结果1 : 结果2

语句真：结果1

语句假：结果2

一个大括号属于一个代码块，每一个块中算一个单独的作用域

sout 快捷键 输出

fori 快捷键  for循环

Java的for循环的第一个语句中，不能单纯的写a，这样会导致报错，可以写int a=0之类的。

continue 跳过本次循环

break     跳过当前循环

可以为代码加上outer ，此时在break后面加上outer，就可以自定义break跳出的位置。该方法不常用，理解即可

三道题目写掉了。

主义问题：在Java的输出中，当我们想要输出7*5=35时，要这样做：

a+“*”+b+=+a*b+"\t";    其中斜杠加t的作用是生成一个tab大小的空格

从此处开始进入面向对象的部分

在面向对象部分，我们在创建一个类之后，使用：

Person a=new Person(); 其实可以将a视为一种指针，类似于c++中的&符号。

即Person b=a; 只不过是指针的变化，a与b其实指向同一个类。

同理 Person c= null .此时我们在想调用c类中的各参数，就会出现空指针异常。

如果我们Person d =new Person() .此时我们可以调用d中的参数，不会出现空指针异常，我们得到的结果就是null，0，false。这个要看具体对应的类型。引用类型默认为null，boolean类型默认为false，数字类型默认为0.

第三天：

方法即C语言中的函数。

函数的思路与C语言中的差不多，很像c++中的类，关注一下就可以了。

return之后就不需要在写其他语句了，这些都是不可到达的。

形参与实参的值：

函数入口传入的参数，是不会随着函数内的操作而产生变化，这也就是我们所说的形参。

在上文中我们说对于创建的person对象可以视为一个引用，从而在函数中也会出现不一样的情况、如果我们是在传入的参数中使用的情况如下

Person p= new  Person(); void  gaiming(Person a){a.name="wyf";}p2.gaiming(p1);

那么在这个时候，我们会将p1中的结果完成修改，原因就是传入的是一个引用

（1）重复命名的选择问题

对于一个变量名，他会优先选择作用域离自己最近的一个，如下面这段代码

public class Person {String name;int age;String sex;void setname(String name){name=name;}
}

本意是想修改类中的姓名，但无法成功。这里的两个name都会被定位到String name这里。 

使用this可以解决这个问题。他表示指向当前的对象本身

（2）重载问题（类似于c++）

在Java中同样支持重载，就是保持函数名称不变，只修改传入参数的类型。整体的实现较为简单。必须要修改传入的参数,仅仅是返回值的修改，是无法实现重载的。

（3）定义的函数可以调用其他函数，包括自己

由以上的特性可以实现递归求和的操作

 int getsun(int n){if (n==0)return 0;return getsun(n-1)+n;}

（4）构造

在Java的类中是默认有一个构造函数的，这个构造函数是空的。我们可以设置自己的构造函数。

构造函数的设置比较简单，没有什么特别需要注意的点

 Person (){name="wyf";age=18;sex="男";}

构造函数也可以通过传入参数来进行构造

Person (String a,int b,String c){name=a;age=b;sex=c;System.out.println("构造成功了");}

如果自定义了构造函数，原本的默认的就会被覆盖掉，这个时候我们需要使用的就是重载的方式进行修改。

（5）成员属性和静态变量

成员属性指 对象中的属性，比如name，age等信息。

静态变量的设置方式：static  String  info

static 是静态变量的关键字。

对于静态变量，我们只需要通过Person .info 来即可完成调用，即该变量是所有对象所共享的一个。因此被叫做静态变量。

第四天：

（1）静态变量

对于静态变量，这个同样可以定义一个函数作为一个静态变量，对于所有的对象都可以去调用这个函数。

在静态变量定义的函数中，我们不能在调用非静态的值。同时，由于静态变量属于类，因此不能再静态变量中使用this这种关键字

还可以设置静态代码块

static{System.out.println("qwer");}

静态部分的内容是先于对象构造之前的，即先对静态变量的部分进行赋值，之后在调用类的部分。

（2）包的概念

package  我们可以把创建的类放入到包中，包与目录一一对应。

如果两个文件在不同的包内时，当一个需要调用到另一个的类时，需要导入对应的包。

import com.test.entity.Person;import com.test.entity.*;

如果我们最后用一个*号，代表导入所有的类

如果同时导入多个包，并且存在包下有同名的类，此时我们就要去指明具体是哪个包下的类。

（3）包中的权限问题

什么都不写的情况下就是默认的情况。

权限同样可以对类进行定义，不过如果使用private和protected会报错。搜索后得知报错的原因是：

private 定义类之后，这个类就没有意义了，外界调用不了。

protected为什么不能调用其实还是不太理解的，搜索后大概的意思是，使用这个外界也调用不了，内部和默认又是一样的权限。

还可以针对静态函数实行静态导入：

import static com.test.entity.Person.test;
test();

导入之后就可以直接的调用了。

（4）类的封装

封装：类中的信息属性设置为private，这样外部无法直接看到，我们需要使用封装函数来进行调用才可以得知具体的信息。  

public class Person {private String name;private int age;private String sex;public String getName() {return name;}

关键字：contains 包含，检查字符串中是否包含某个字符。

（5）类的继承

类的继承可以一直往下，比如A->B,B->C 这是被允许的

继承的关键字是extend

public class student extends Person

继承之后，父类的属性和方法子类都可以使用。

super代表父类。super只能在类中用，表示的是当前类的父类。因此也不能和static结合使用。这点需要注意。

一个重要的硬性要求，如果在父类中有重新定义构造参数，那们我们在子类中一定要对这个构造参数重新进行调用。

public worker(String name,int age,String sex){super(name,age,sex);}

同时，一定要确保super（）语句是第一条语句，即优先保证父类先被创建完

    Person student =new student("asd",18,"sda");//student.study();student.hello();

子类可以被当做父类使用，这样做完之后会导致子类中的属性没有，只会保留父类中的信息.

关键字：instanceof 判断这个对象属于哪个类，或者是哪个类的继承类（比如student继承于person，那么我们询问student是否属于person，我们会得到肯定的答案）

    if (student instanceof  Person){System.out.println("hello" );}

在子类中可以定义与父类中相同的变量，在这种情况下，会优先调用子类中的变量

此时我们如果想再次访问父类，那我们还需要再次使用super这个关键字来使用

   public  void  test1(){System.out.println(name);}public void  test2(){System.out.println(super.name);}

（6）object类

所有的类默认都会继承一个object类，只是平时不写出来，可以看成所有的类的源头、

介绍了equal这个关键字的使用方法，以后还会用到object类中的其他函数。

（7）方法的重写（注意与方法的重载进行区分）

重写：将原本的东西覆盖掉。

这里举的例子是对equal进行修改，原本的equal对两个姓名等信息相同的不同个体，会输出false。

现在修改为不会。

public  boolean equals(Object obj){if(obj==null)return  false;if (obj instanceof  Person){if (((Person) obj).age==this.age){if (((Person) obj).name ==this.name){if (((Person) obj).sex==this.sex)return true;}}}return  false;}}

 worker a1 =new worker("小明",18,"sda");//student.study();worker a2=a1;worker a3=new worker("小红",18,"女");System.out.println(a2.equals(a1));System.out.println(a2.equals(a3));

现在的结果分别为真和假。

重写的重点是要保持和原有传入的参数和函数名要保持完全的一致，感觉就是一个简单的覆盖问题，不算是一个特别麻烦的任务。重写的语句前面可以加上一个@override，这个可以表示这个是重写的部分。

在不同的类中重写之后，对不同的类进行调用，得到的结果会是不一样的。

  worker a1 = new worker("小明", 18, "sda");//student.study();worker a2 = a1;worker a3 = new worker("小明", 18, "sda");a1.test();Person b = new Person("小明", 18, "sda");b.test();student c=new student("小明", 18, "sda");c.test();

这里就有了多态的特性的体现。

如果不想让子类复写，可以加上关键字final 

 public final void test(){System.out.println("考试方法");}

如果在类上加final ，那么这个类就不能再继承了。

如果父类中的函数的权限是private，那么我们子类中是无法直接调用它的。因此我们也不能对该函数进行重写。子类复写的权限不能低于父类。

第五天：

（1）抽象类

只保留方法的整体，不去对方法进行定义，定义留到子类中进行。

关键字：abstract  表示这是一个抽象类

只有抽象类下面才可以有抽象方法。

public abstract void test();

注意，这里我们没有再加上大括号了。对于抽象方法必须在子类中进行实现。不写会报错

如果一个类是抽象类，那么这个类是无法实例化对象的。

 （2）接口

接口的创建方式是  选择包->点击新建->选择Java 类->选择第二个（代表接口）

通常情况下 接口类中只能写抽象方法，即所有的方法都不能带上具体的语句

public interface Study {public  abstract  void  study();
}

由于只能定义public和abstract的方法，所以这两个关键字可以省略。

调用接口需要使用implement 关键字。

public abstract class Person implements Study

同理，接口也属于抽象方法，也是一定要实现的。

接口可以同时继承多个，但类只能继承一个。

如果想在接口中写上实现方法，可以加上关键字 default ，这样就可以实现默认实现，这样在子类中不需要再去写了。

此时如果我们还想再子类中调用 默认实现的方法，需要再前面加上一个super前加上接口名

接口中不允许出现成员变量和成员方法，但可以出现静态变量和静态方法

    public  static  final  int  a=40;public  static void  eat(){System.out.println("一天三顿");}

接口中的变量默认就是公共 ，静止，不可变的。

接口可以继承其他接口,继承的方式和类的继承比较相同。接口可以继承多个接口。

在继承接口类时候，如果这个类是一个抽象类的话，就不需要再对接口中的抽象方法进行实现。如果有子类继承这个类的话，仍然需要进行声明、

（3）克隆

clone 克隆需要调用接口clone 感觉用处不太大。

需要注意的是clone所做的是浅克隆。

（4）枚举类

枚举类的作用为输出的值限制范围。

枚举类的创建和接口类似：选择包->点击新建->选择Java 类->选择第三个（代表枚举）

枚举类的设置：

public enum Status {runing,sleep,eating;
}

枚举类的使用

注意，枚举类的使用不需要导入，只要两者在同一个包下就可以正常的进行使用。

package com.test.entity;import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;public class student {private Status statue;public Status getStatue(){return statue;}public void setStatue(Status statue){this.statue = statue;}}

student st1=new student();st1.setStatue(Status.sleep);//st1.setStatue("eating");System.out.println(st1.getStatue());

此时我们想要赋值就必须使用Status来操作。此时我们输入sleep会出错，因为这里的数据类型是Status,而非字符串。

关键字：valuesof  得到枚举类中的某个值。

Status status =Status.valueOf("sleep");System.out.println(status);

注意，当我们修改枚举类的构造函数时，此时我们需要按照构造函数的传入参数的类型，对其枚举的部分进行修改

runing("跑步"),sleep("睡觉"),eating("吃饭");   
Status(String name)
{
this.name=name;
}

runing("跑步",18)
Status(String name,int a)
{
this.name=name;
}

这点需要注意。

对于枚举类的理解：

枚举类的第一行，所写的名称，他们都可以被视为是该枚举类所创建的一个对象。从第二行开始，我们就可以对这个类进行声明。比如构造函数等等。因此我们可以实现以下的操作。

    private final String name;//这里我们定义了一个私有属性,属性的名称叫做nameStatus(String name){this.name=name;}public String getName(){return  name;}st1.setStatue(Status.eating);//st1.setStatue("eating");System.out.println(st1.getStatue().getName());

这里我们是先设置了student这个类，并将status作为其该类的一个属性，我们通过getstatus来获取该st1的status信息，之后再调用getname,获取该status对应的name的具体值。

第六天：

（1）基本类型包装类

是把我们常见的数据类型，比如int short char 等，打包成类。

    Integer a=new Integer(10);System.out.println(a);

包装类型支持自动装箱，我们可以直接将一个对应的基本类型值作为对应包装类型引用变量的值，同理也可以自动拆箱，由此我们可以认为在实际的运算中，这种和我们定义的普通的变量是一模一样。

 Integer a=10;System.out.println(a);int c=a;

主要区分:

值类型和引用类型：class类属于引用类型，int short 等属于值类型。具体可以下面博客

C#详解值类型和引用类型区别_c#值类型和引用类型的区别-CSDN博客

 Integer a=new Integer(10);Integer b=new Integer(10);int c=10;int d=10;System.out.println(c==d);System.out.println(a==c);System.out.println(a==b);

此处最后得到的结果为 true true false 。对于引用类型，必须指向同一个对象才能得到等号。

注意：对于int，如果我们赋的值在-128到127之间，这些值都被提前封装好放入到一个数组中了。此时我们如果使用自动装箱，是会指向同一个目标。超出就需要重新new空间。

用法1：字符串转换为整数

String str= "666";
Integer e=new Integer(str);
Integer f=Integer.parseInt(str);
Integer g= Integer.valueOf(str);
System.out.println(e);
System.out.println(f);
System.out.println(g);

三种方法都可以把字符串类型修改为整数类型。

用法2：将十六进制和八进制直接转化为整数。

  Integer h=Integer.decode("0x66");//对应十六进制System.out.println(h);Integer i=Integer.decode("077");//对应八进制System.out.println(i);

在Java中，我们在前面加上一个0，表示这是一个八进制数。在前面加上一个0x，表示这是一个十六进制的数。

在基本类型包装类中，定义了很多的静态方法。这些东西以后都是有可能会被用到的。

（2）特殊包装类

        BigInteger i= new BigInteger("10000000000000000000000000000000000000000");BigInteger h= BigInteger.valueOf(Long.MAX_VALUE);BigInteger k= i.multiply(BigInteger.valueOf(10));BigInteger O=i.pow(10);BigInteger l= h.divide(BigInteger.valueOf(3));//BigInteger 任然是一个整数的类型，当1000/3时也只会得到333System.out.println(i);System.out.println(h);System.out.println(k);System.out.println(O);System.out.println(l);

BigInteger 这个类是用来处理大数的。它自己也有很多的内置的函数可以使用。

如果用valueof 来进行初始化，那我们只能将其赋值到long类型的最大值、

但如果用new  BigInteger() 这种方式来处理，那我们就可以无限的去定义这个数了。 

     BigDecimal a= BigDecimal.valueOf(10);BigDecimal b=  a.divide(BigDecimal.valueOf(3),100, RoundingMode.FLOOR);System.out.println(b);

第二个特殊类是BigDecimal 这个是用来处理小数的，在divide中，我们不仅要输出除数，还需要设置小数点后的位数，以及最后是使用的模式。

BigDecimal.divide方法详解(基本用法、舍入模式、示例代码)_聚合数据 - 天聚地合

第七天：

今天没学，去看哔站上面的一篇论文带读，论文带读主要介绍的是图表示学习算法的一些基础知识。整体的内容不算很难。该部分的笔记写在语雀上。

以上就是第一周的学习的内容。