编程基础

最新推荐文章于 2024-09-11 00:00:00 发布

猪拱小白菜

最新推荐文章于 2024-09-11 00:00:00 发布

阅读量208

点赞数

分类专栏：笔记文章标签： java

本文链接：https://blog.csdn.net/qq_41309583/article/details/105320784

版权

笔记专栏收录该内容

21 篇文章 1 订阅

订阅专栏

public class 和 class 的区别

1、一个java源文件中可以有多个class
2、一个java源文件中public的class不是必须的
3、一个class会定义生成一个xxx.class字节码文件
4、一个java文件当中定义公开类的话，public的class只能只有一个，并且该类名要和java源文件名称一致
5、每一个class当中都可以编写main方法，都可以设定程序的入口，向B.class中的main方法： --输入命令java B
注意：当在命令窗口中执行java Hello 那么要求Hello.class当中必须有主方法，没有主方法会出现运行报错

编程基础

一、标识符
1、什么是标识符？
有权利自己命名的单词叫做标识符
- 标识符可以标识什么元素？
*类名
*接口名
*方法名
*常量名
…

**一个合法的标识符只能由“数字”、“字母”、“下划线”、“$美元符号”组成 不能含有其他符号
*不能以数字开头
*严格区分大小写
*关键字不能作为标识符**

2、标识符的命名规范？
只是一种规范不属于语法不遵守规范编译器不会报错
*最好见名知意
*遵守驼峰命名方式
*类名、接口名：首字母大写，后面每个单词首字母大写
*变量名、方法名：首字母小写，后面每个单词首字母大写
*常量名全部大写

二、字面值
字面值 == 数据
也就是字表面的值包括标识符和关键字都是java源文件的组成部分

变量
1、什么是变量
可以自己定义的数据。数据会在内存中占用一定的空间，给这个空间去一个名字，这个名字就叫做变量。
*本质上是内存中的一块空间，这块空间有有数据类型、有名字、有字面值
*变量包含三部分：数字类型、字面值、名称
*变量是内存中存储数据的最基本单元

2、数据类型的作用？？？
***指导***程序运行时数据在内存中占用的空间。
不同的数据又不用的类型，不同的数据类型底层会分配不同大小空间。
数据类型是指导程序在运行阶段应该分配多大的内存空间

3、变量的要求：变量中存储的具体的数据必须变量的数据类型一致，当不一致的时候编译报错

4、声明或定义变量的语法格式：
*数据类型 ;
*变量名：只要是合法的标识符就行

5、声明变量后怎么赋值
语法格式：变量名 == 字面值
要求：字面值的数据类型必须和变量的数据类型一致
” =" 等号是一个运算符叫做赋值运算符赋值运算符先运算等号右边的表达式，表达式执行结束后的结果赋值给左边的变量

6、声明和赋值可以发到一起完成 ;

7、变量复制之后可以重新复制变量的值可变化；

8、有了变量值的概念之后，内存空间得到了重复的使用

9、通常访问一个变量包括两种访问形式：
*第一种：读取变量中保存的具体数据 get/获取
*第二种：修改变量中保存的具体数据 set/设置

10、变量在一行中可以声明多个

变量遵守：先声明后赋值成员变量（加了static）如果没有手动赋值系统会默认赋值【】局部变量不会

数据类型
1、数据类型的作用？
每一个数据都是有相关类型的，不同的数据类型占用的空间大小不同，数据类型的作用是知道java虚拟机运行程序的时候给该数据分配多大的空间
2、java中的数据类型包括两种：
*基本数据类型
*引用数据类型： 类接口数组
3、关于基本数据类型：
四大类八大小种
整数型： byte | short | int | long
浮点型: float | double
布尔型: boolean
字符型: char
4、字符串不属于基本数据类型，属于引用数据类型，
*字符串使用双引号
*字符使用单引号

5、八种基本数据类型各自占用空间的大小是多少？

基本数据类型占用空间大小【单位：字节】

byte ---------------------------- 1
short --------------------------- 2
int ------------------------------- 4
long ---------------------------- 8
float ---------------------------- 4
double ------------------------ 8
boolean ---------------------- 1
char --------------------------- 2

计算机在任何情况下只能识别二进制 0101001
【现代计算机底层使用交流电的方式，接通和断开两种方式，计算机只识别0、1 其他都不认识】
什么是二进制？
*数据的一种表示形式。十进制表示满十进一原则。二进制满二进一原则。
二进制转十进制
十进制转二进制

字节（byte）
1、1 byte = 8 bit 【一个字节 = 8 个比特币位】一个比特位表示一个二进制位： 1/0
【-127~128】

整数型当中的byte类型，占用一个字节，所以byte类型的数据占用8个比特币位。取值范围???
*JAVA中的数字类型，数字都是有正负之分。所以在二进制中有个二进制位成为符号位。并且这个符号位在所有二进制位的最左边。0表示正数 1表示负数。
国际化标准组件ISO置顶的，支持西欧语言，向上兼容ASCII码，不支持中文。 ISO-8859-1，又被称为latin-1
支持中文： GB2312 < GBK < GB18030
unicode： UTF-8 UTF-16 UTF-32

java语言采用的事故哪一种编码方式？
unicode。所以java的标识符可以使用中文

char类型
char是两个字节，一个中文也是2个字节所有char刚好存储一个字节

转义字符

转义字符出现在特殊字符之前，会将特殊字符转化成普通字符

\n 换行符
\u 转unicode编码编译

两者区别：
System.out.print() 不换行
System.out.println() 换行功能

整数类型
1、java中的“整数型字面值”被默认当作int类型来处理。要让这个“整数型字面值”
被当作long来处理的画，需要在“整数型字面值”后面添加1/L，建议使用大写的L

2、java整数型字面值有三种表达方式：
十进制【默认】
八进制【以0开始】
十六进制【以0x开始】

小类型转大类型自动转。大类型转小类型强转（可能损失精度）

面向对象的三条主线：
1、类和类的成员
2、面向对象的三大特性
3、关键字：this、super、import、package、abstract、final、inteface、extends等

1.1java程序关注于类的设计，类的代码的角度并列关系。从执行、设计的角度继承关系、关联关系、聚合关系。
1.2类的成分：属性、构造器、方法、代码块、内部类
属性：（1）成员变量 vs 局部变量（方法的形参、方法内部、代码块）
基本数据类型（8大数据类型不同数据类型对应的默认值不一样） vs 引用数据类型（数组、inteface、class 默认初始值为null）
（2）属性格式：数据类型属性名 = 初始化值 //java是强类型语言
（3）对属性赋值的操作默认初始化显示初始化代码块初始化构造器初始化方法赋值
1.3 方法：
（1）格式：修饰符（其他关键字：static final abstract）返回类型方法名（方法形参）{方法体}
（2）方法的重载 vs 方法的重写
（3）构造器作用：创建类的对象初始化类的成员变量也可以重载
（4）代码块用来初始化类的成员变量
1.4类的初始化（创建类的实例）

2.1封装
通过私有化属性，提供公共的set get方法来进行调用和修改
还可以对类的其他结构进行封装
权限修饰符 public private protected 缺省
2.2继承
2.3多态
方法的重载重写
子类对象的多态性

File文件
注意点
1、从硬盘中读入一个文件要求这个文件一定要存在否则报异常
2、从程序中输入一个文件到硬盘文件可以不存在会自动创建一个文件
3、真正的开发一般用缓冲流来代替字节流
4、最后要关闭相对于的流首先关闭输出流在关闭输入流

FileInputStream FileOutputStream

/**
 * IO体系
 * 1、流的分类
 * 按照流向不同 输入流 输出流
 * 按照处理数据的单位不同 字节流 字符流（处理文本文件）
 *
 * 抽象基类           节点流（文件流）        缓冲流
 * InputStream       FileInputStream     BufferedInputStream
 * OutputStream      FileOutputStream    BufferedOutputStream
 * Reader            FileReader          BufferedReader
 * Writer            FileWriter          BufferedWriter
 *
 */
public class TestFileInputOutputStream {
    //从硬盘中读取文件内容到程序中
    @Test
    public void testFileInputStream()  {


        //1、创建一个File类的对象
        File file = new File("hello.txt");
        //2、创建FileInputStream类的对象
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(file);
            //3、调用FileInputStream的方法 读取file文件
            /**
             * read()
             * 读取文件的一个字节  当执行到文件的结尾时 返回-1
             */
            int b = fis.read();
            while(b != -1){
                System.out.println((char)b);
                b = fis.read();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        //不是java虚拟机处理 所以不能自动回收  所以要手动关闭读取流

    }


    @Test
    public void testFileInputStream2(){
        //1、创建File对象
        File file = new File("hello.txt");
        //2、创建FileInputStream类
        FileInputStream fis = null;

        try {
            fis = new FileInputStream(file);
            byte[] b= new byte[5];
            //3、读取fis中的数据
            int len;
            while((len = fis.read(b)) != -1){
//                for (int i = 0; i < len; i++){
//                    System.out.print((char)b[i]);
//                }
                String str = new String(b, 0, len);
                System.out.print(str);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }


    @Test
    public void testFileOutputStream(){
        //1、创建一个File对象 表明要写入的文件位置
        //输出的物理文件可以不存在  当执行过程中不存在会自动创建   若存在会将原有的文件创建
        File file = new File("hello.txt");
        //2、创建一个FileOutputStream对象 将file对象作为形参传递过来
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(file);
            //3、写入操作
            fos.write(new String("i love you").getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(fos != null){
                try {
                    //关闭输出流
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }


    @Test
    public void testFileInputOutputStream(){
        //1、提供写入写出的文件
        File file1 = new File("C:\\Users\\Administrator\\Desktop\\微信图片_20191101164636.jpg");
        File file2 = new File("C:\\Users\\Administrator\\Desktop\\2.jpg");
        //2、提供相应的流
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(file1);
            fos = new FileOutputStream(file2);
            byte[] b = new byte[20];
            int len;
            //3、实现文件的复制
            while((len = fis.read(b)) != -1){
                fos.write(b,0,len);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

}

FileReader FileWriter


public class TestFileReaderWriter {
    /**
     * FileReader FileWriter可以实现文本文件的复制
     * 对于非文本文件 只能使用字节流
     */
    @Test
    public void testReaderWriter(){
        File src = new File("hello.txt");
        File dest = new File("dest.txt");

        FileReader fileReader = null;
        FileWriter fileWriter = null;
        try {
            fileReader = new FileReader(src);
            fileWriter = new FileWriter(dest);
            char[] c = new char[24];
            int len;
            while((len = fileReader.read(c)) != -1){
                fileWriter.write(c,0,len);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(fileReader != null){
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fileWriter != null){
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

BufferedInputStream BufferedOutputStream

public class TestBuffered {
    //使用BufferedInputStream BufferedOutputStream 实现非文本的复制
    @Test
    public void testBufferedInputStreamOutputStream(){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //1、提供写入写出的文件
            File src = new File("hello.txt");
            File dest = new File("dest1.txt");
            //2、先创建相应的节点流  FileInputStream FileOutputStream
            FileInputStream fis = new FileInputStream(src);
            FileOutputStream fos = new FileOutputStream(dest);
            //3、将创建的节点流的对象作为形参传递给缓冲流的构造器中
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            //4、具体实现文件复制的操作
            byte[] b = new byte[1024];
            int len;
            while((len = bis.read(b)) != -1){
                bos.write(b,0,len);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //5、关闭相应的流
            if(bos != null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bis != null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }




    }

}

字节流和字符流的转换

public class TestOtherStream {
    @Test
    public void test1(){
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            //解码
            File file = new File("hello.txt");
            FileInputStream fis = new FileInputStream(file);
            InputStreamReader is  = new InputStreamReader(fis,"GBK");
            br = new BufferedReader(is);
            //编码
            File file1 = new File("hello.txt");
            FileOutputStream fos = new FileOutputStream(file1);
            OutputStreamWriter osw = new OutputStreamWriter(fos,"GBK");
            bw = new BufferedWriter(osw);
            String str;
            while((str = br.readLine()) != null){
                bw.write(str);
                bw.newLine();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(bw != null){
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}