java学习笔记

java认知

java为编译性的语言，应用很广泛，java对于类型具有很严格的限制，是一种强类型的语言

//定义一个公开的类Start
public class Start {
    //定义main函数默认参数必须为String[] args
    public static void main(String[] args){
        //输出语句
        System.out.print("hello world");
    }
}

java中对于类型的一些限制

基本类型	范围
byte	-127~127（(-2^8-1)——(2^8-1)）
int	（-2^31） —— (2^31)
short	-32768（-2^15）—— 32767（2^15 - 1）
long	（-2^63）—— （2^63 -1）
float	float 数据类型是单精度、32位
double	double 数据类型是双精度、64 位
bool	值只能为true或false
char	值只能为单个字符

其中string再java中不为一种基本类型，而是一种引用类型（接口等为引用类型），

在定义float类型时需要再所定义的值后加F表示为float类型

float num = 50.1F;

在定义long类型时需要在所定义的值后将L表示该值为long类型

long num1 = 20L;

定义一个bool类型的语法为：

boolean one = true;

示例：

我们会发两次的判断结果都为true，原因是float类型算是对一个数据的模糊判断，相当于只能比较个大概，它只能大约接近于但不等于，至于关于大数的相关运算则由BigDecimal这个类来进行相关运算。

类型的强制转换

语法为：

public class helloworld {
    public static void main(String[] args){
        char name = 'n';
        char str ='中';
        System.out.println((int)str);
        System.out.println((int)name);
        float num2 =10.2F;
        System.out.println((int)num2);
    }
}

其中对于name变量输出的ascii码表中所对应的位置，中文字符则是Unicode编码中所对应的位置。

一般的强制类型转换（用于由高等级的数据转换为低等级）：

int i = 111;
byte n = (byte)i;
System.out.println(n);

需要注意的是，由于不同类型有不同的长度限制，有些数据转换后会由于数据大于限制长度导致溢出。

例如：

int a = 10_0000_0000;
int b = 20;
System.out.println(a*b);//因为最后的结果大于限定长度，导致内存溢出
long f = a*b;
System.out.println(f);//输出的f同上边内存溢出的结果相同，在对f进行赋值之前a和b先进行了一次int类型的运算得到了内存溢出的结果再将结果进行赋值
System.out.println(a*((long)b));//由于对b及逆行了类型的转换，所以最后的输出结果会以最高的类型为准

在由低等级的数据向高等级转换时会自动转换数据类型不需要进行强制转换。

常见的转义符

字符名	用法
\t	制表符，类似于在输出语句后加teb
\n	换行

java中的变量

java中的变量一般分为三大类：局部变量，类变量，实例变量。

局部变量比较好理解，它一般用于一个方法中，先当于它的作用域为一个次函数，

示例：

public class helloworld {
    public void sss(){
        char cdk = 'w';
        System.out.println(cdk);
    }
    public static void main(String[] args){
        char str ='中';
        System.out.println((int)str);
        helloworld world =new helloworld(); 
        world.sss();
    }

}

sss方法中的cdk变量为局部变量，它的作用域只有sss方法，具体的代码逻辑为：

先去helloworld这个公共的类中执行main方法，进行输出，再创建一个新的helloworld方法并赋值给变量world，此时变量world的类型为helloworld，再执行helloworld中的sss方法。

类变量，又称为静态变量，经常被声明为常量，很少单独使用 static 声明变量，且伴随一个类的创建而产生随类的结束而消亡。

对于实例变量我的理解为若实例变量为共有则可在所有类中若调用该类则可调用该变量，若为私有则仅能够再当前类中调用。

java中的常量

常量为一旦被定义则不能被更改，即常量的值和类型在被定义时就被写死。

final double ss = 3.14;
//定义一个名为ss的double类型的常量其值为3.14

java中的位运算符

运算符	作用
<<	左移
>>	右移

java中方法的重载

例子如下：

在此例子中，定义了两个相同的名字的方法，但由于传入的参数不同，导致了传入的参数不同，调用了不同的函数，类似于这样的就为函数的重载，java中如果调用的方法名称相同，会根据传入的参数数量和参数类型进行匹配，最后选择对应的方法。

java中的数组

int amd[]   //定义一个int类型名为amd的数组

定义数组的格式为：

dataTybe[]  arrayRefVar
datatybe    arrayRefVar[]

数组在被定义时，会先向栈中写入该数组名，但此时并没有对此数组进行内存空间的分配，只有在对数组进行了初始化之后才会对数组在公开的堆中申请对应的内存空间大小。

对于数组进行初始化并规定大小

dataType[] arrayRefvar = new dataType[arraySize]

数组的静态初始化：

int[] a = {1,2,3};
//对数组a进行静态初始化

封装

对于一些类中某些不公开的变量，有时候我们会需要用到此时可以利用封装进行调用不公开的属性.

源码分析：

在nopubilc类中，对name属性为私有，我们可以创建一个公开的函数利用this.name调用当前类中的私有属性，并将其作为返回值，所以在learn类中调用getName()这个公开的函数会得到nopublic类中的私有变量。

源码分析：getMessage方法同上边的getName方法原理相同，setMessage方法则是利用函数的传参来及逆行修改私有属性的值，相当于给我们提供了一个能够修改类中内部属性的接口。

super和this

super主要作用为调用父类中的属性或者方法，父类中若属性或者方法为私有则无法被super调用，而this主要调用的时当前类中的属性或者方法，二者所作用的对象不同。在子类中生成构造函数会默认首先利用super调用父类的构造函数。

例子如下：

在最后的输出结果中可以发现对于父类中的构造函数也进行了调用，这里是默认利用了super函数进行对父类的构造函数进行调用。

若父类的构造函数需要传入参数，则子类的构造函数也需要传入参数，同时若子类构造函数中存在this函数则执行顺序为：super——>this——>构造函数中的语句，若父类的构造函数中需要传入参数，由于子类中默认调用的super函数是无参的，所以若没有对其进行自定义的修改则会出现报错。

方法的重写

例子为：

这里再test类中定义了对象a，同时我也调用了对象类型的判断函数a的类型为learn类型（子类），其中由于父类和子类都具有text函数且都不为静态函数，同时都为public函数，所以子类再继承父类时对父类的text方法进行了方法的重写，所以我们在用a调用的时候会得到子类的结果。也可以理解为子类中由于存在和父类相同的方法所以在调用时会直接对从父类继承而来的方法进行覆盖。

多态

对于多态我的理解如下：

我们在运行不同的对象后，会得到不同的结果，即在程序运行时才会确定最后的实例对象，再根据所确定的实例对象选择所对相应方法。

引用：

多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性

引自：https://www.cnblogs.com/chenssy/p/3372798.html

对于多态的实现需要以下三点：

1.具有继承性

2.子类对父类方法能够重写

3.父类引用指向子类对象（多态实现的根本所在，即为了实现对不同对象调用不同方法）

类型转换

在java中对于数据类型的转换主要有两种：自动转换（隐式转换）和强制转换（显式转换），对于隐式转换是为我我们在有一个低级别的类型向高级别的类型转换时会自动转换为目标类型，在由高级别向低级的类型转换时会需要我们进行手动转换（显式转换）。

隐式转换例子：

package day03;

public class Type {
    public static  void main(String[] args){
        int a=10;
        double b=10.00001;
        double c=a*b;
        System.out.println(c);
    }
}

最终得到的c的类型为double类型，运行过程为先将a进行类型转换为double类型在进行运算。

显式转换例子：

第三方调用类

public class Type {
    public static  void main(String[] args){
        Persion persion = new Worker();
        persion.text();
        Worker person2= (Worker) persion;
        person2.test();
    }
}

父类：

public class Persion {
    public static void main(String[] args){
        System.out.println("wdnmd12138");
    }
    public void text(){
        System.out.println("ddddddd");
    }
}

子类：

public class Worker extends Persion{
    public static void main(String[] args){
        System.out.println("this is son");
    }
    public void test(){
        System.out.println("wdnmd");
    }
}

类型强制转换语法为：

目标类型 自己所定义的类型名 = (目标类型名)想要转的对象名

强制转换适用于从高级别像低级别的类型转换，比如从父类向子类转换，此时我们可以调用子类中的test方法，强制类型转换会伴随这失去某些转换前的某些方法或者属性.

抽象类

java中我们若想要定义一个方法但具体的内容想要在子类中实现，可以利用抽象类来进行实现，例子：

抽象类：

package day03;

public abstract class ABS {
    public abstract void  Dothis();
}

子类：

package day03;

public class ABStest extends  ABS{
    public  void Dothis(){
        System.out.println("wdnmd");
    }
}

在以上例子中，抽象类的Dothis方法具体的实现实在子类中进行具体的实现，若在其子类中也不实现，可以再进行继承到子类的子类中进行实现，抽象类不能进行new对象。