java基础学习笔记1

java基础学习笔记1

1.java语言特点

面向对象的语言

健壮性

提供程序运行的解释环境

2.核心机制

JAVA虚拟机

自己写的java文件，通过编译器 编译成 字节码class文件

然后通过虚拟机一行一行解释执行

所以java是解释型语言

垃圾收集器

每隔一段时间回收一次。

3.Helloworld

public class HelloWorld{
public static void main(String[] args){
System.out.println("helloufose");
}
}

javac编译这个文件，java运行编译后的文件.

问题：找不到或无法加载主类

解决：在运行的时候不能带.class

4.基础语法

程序执行过程

编译好后，全部装载到内存里面，找到main方法，开始执行。

把内存分为四部分

代码区：存放代码

数据区：存放静态变量，字符串常量

栈：存放局部变量

堆：动态申请内存，new出来的东西

标识符

不能以数字开头,不能使用关键字,不能使用空格.

特殊字符只能用_或者$,其他字符一律不能使用.

区分大小写.

举例:

关键字

常量

整型常量：123

实型常量：123.4

字符常量：‘a’

逻辑常量：false true

字符串常量：“hello中国”

变量

先声明，再赋值。

按声明的位置划分：

局部变量：方法里面声明的变量

成员变量：class里面声明的变量

数据类型

基本数据类型

4类8种：

整数型：byte short int long

浮点型：float double

字符型：char

布尔型：boolean

引用数据类型：

class，interface，数组

字符

java采用unicode编码，每个字符占2个字节。

国标码：gbk或者gb2312

各个国家有各个国家的编码，unicode统一了全球编码。

java使用unicode的utf-16.

\可以转义。

整数类型

byte 1字节 范围： -128~127

short 2字节 范围：类似上面计算出来

int 4字节 范围：类似上面计算出来

long 8字节 范围：类似上面计算出来

8进制要用0开头，16进制用0x开头

long类型赋值时必须加在最后加L或者l。

浮点型

float 4字节 范围：类似上面计算出来

double 8字节 范围：类似上面计算出来

默认为double，所以在晟声明float时必须在最后加上F或者f。

基本数据类型之间的转换

byte,short,char->int->long->float->double

byte,short,char之间不会互相转换，他们三者在计算时首先回转换为int类型。

实数常量（如:1.2）默认为double。
整数常量（如:123）默认为int。

小心！从大到小的转换存在溢出问题！

例如：

double c2= 1e200;
float f2=(float)c2;
System.out.println(f2);
//打印Infinity
//表示溢出

例如：

float a1=1.73f;
long a2=(long)a1;
System.out.println(a2);//打印1

long a=1000;没问题，没超出。类型为long。

long a=88888888888888888;有问题，超出范围。

long a=88888888888888888L;应该加L。

两个char相加，首先会把他们俩转成int相加，结果是int。如果强制转化，则再把加后的int转为char。

– ++

int a=11;

int b=a++; // b等于11 赋值结束后，a=12.

&& & || |

&&如果前面不成立，就不在计算后面的了。

&前后两个都要计算

三目运算

int a=1;
System.out.println(a==1?"男":"女");

可以用在打印语句里面！

if else

注意:else{} 最好加上大括号，不加只运行其后的一句。

循环

---

for(表达式1；表达式2；表达式3){

语句；

}

执行过程：表达式1–表达式2—语句—表达式3，再循环回去

---

while(表达式){语句}

执行过程：表达式–语句

---

do{语句}while(表达式);

执行过程：语句–表达式 注意最后的分号！

---

break：

for(int i=0;i<5;i++){
	if(i==2){break;}
	System.out.println(i);
}
	//打印01

---

continue：

for(int i=0;i<5;i++){
	if(i==2){continue;}
	System.out.println(i);
}
	//打印0134

---

switch(){
case xx:

…

case xx:

…

defalut：

…

}

一定要和break一起使用！！不然会一路case下来。

xx只能是int类型！！

defalut是上面都不是才运行。可以省略！

5.基本概念

引用类型

除了那8个基础类型，其他的所有变量都是引用类型。

引用类型占2块内存。

类是静态的概念，存在代码区。

对象是new出来的，在堆区。

类里面的方法只有一份，执行时才占用内存。

构造方法

使用场景：

Person a= new Person();

后面这个Person();就是构造函数。

定义位置：

与类名相同，没有void，没有返回值。

public class Person {
    String name;
    int age;
    
    //下面这个就是构造函数，他不是方法！
    Person(String n,int a) {
         name = n;
         age = a;
     }
}

内存解析

public class Person {
    String name;
    int age;
	//此处省略了setter和getter
    
    //下面有三种试图改变name的方法
    public static void change(Person a) {
        a.setName("wdcwec");
    }
    public static void change2(Person a) {
        a = new Person("funcname", 77);
    }
    public static void change3(String newname) {
        newname = "dwjcwfbefbwe";
    }

    //主函数
        public static void main(String[] args) {
        Person a = new Person("dcwe", 12);
        change2(a);
        System.out.println(a.getName());//并没修改成功

        change3(a.getName());
        System.out.println(a.getName());//并没修改成功

        change(a);
        System.out.println(a.getName());//修改成功

    }
}

具体内存分析过程查看视频：

https://www.bilibili.com/video/BV1Gs411G7TY?p=34

其实就是声明变量时，在栈里面声明，

然后new出东西来，放在堆里面，

然后这个变量指向这个new出来的东西，也就是从栈里面指向堆。

更复杂的内存分析（坐标Point求距离的例子）：

https://www.bilibili.com/video/BV1Gs411G7TY?p=38

重载

函数名字必须相同，参数个数不同，参数类型不同。

不要求返回类型！！没有半点关系！！！

构造方法重载

注意，构造函数不写时，默认有个Perosn(){}

如果手动写了构造函数，默认的就不存在了。

构造函数也可以重载。

this

在构造函数传入参数重名时会用到。

static

staic成员变量只有一份。也就是说，每个地方改了它，它都生效：

public class Person {

    static int statu = 99;

    public static void main(String[] args) {
        Person.statu = 100;
        test();//打印100
    }
    public static void test() {
        System.out.println(Person.statu);
    }
}

static成员可以通过类名.访问：

public class Person {
    static int statu = 99;
    public static void main(String[] args) {
        System.out.println(Person.statu);
    }
}

static方法中不能访问非static成员：

直接报错：

package

只有java.lang不需要引入，直接使用！里面有常用的String，System，Thread，Integer等等。

自己写的类，如果要相互使用：

使用全类名:

使用import：

使用package：

打包自己的类 成jar：

jar -cvf test.jar *.*

-c创建新的存档 -v生成详细输出到标准输出上 -f指定存档文件名

这些可以jar -h查看

test.jar 自己的命名

继承

Java只支持单继承！

访问控制符

假如我有个类：

在同一个包，另一个类下继承这个类：

在不同包，不同类下，继承这个类：

就在这个类中的类：

重写

场景：

在子类中，继承父类，重写父类方法

要求：

相同方法名称、参数列表、返回类型、访问权限不能更严格