Java基础之基础语法与面向对象

V2AS问路

Java基础之基础语法与面向对象

阅读原文时间：2023年08月16日阅读：3

　　小知识

　　Java由Sun公司于1995年推出，2009年Sun公司被Oracle公司收购，取得Java的版权

　　Java之父：James Gosling（詹姆斯·高斯林）

　　专业术语

　　JDK：java development kit（java开发工具包）

　　JRE：java runtime environment（java运行环境）

　　JVM: java virual machine（java虚拟机：跨平台的核心）

　　java实现跨平台的核心原理

　　1、编译，将源文件编译成字节码文件（.class文件）

　　2、解释，将字节码文件解释成不同操作系统可识别的机器码文件（经过jvm）

0、常量与变量

　　常量：在程序运行过程中，不会发生变化的值

　　常量如何定义：

　　在进行常量声明定义的时候，一般取名全部大写并且用_隔开且使用final进行修饰

　　例如：final 常量类型常量名称 = VALUE_ABC;

　　变量：在程序运行过程中，会发生变化值

　　变量如何定义：

　　1、声明加赋值：

　　　　变量类型变量名称 = value;

　　2、先声明，后赋值：

　　　　变量类型变量名称；

　　　　变量名称 = value；

　　变量会根据作用域的不同分为不同的类型

　　1、成员变量：定义在方法外，类内的变量

　　　　作用域：整个对象实例

　　2、局部变量：定义在方法内的变量

　　　　作用域：声明位置开始到整个方法结束

　　3、静态变量：使用static修饰的变量叫做静态变量

　　　　作用域：被所有对象实例所共享

1、标识符：给类，变量，方法，接口起得名字

　　规范：首字母必须是英文，_，$

　　　　其余部分可以是英文，下划线，$,数字

　　　　java严格区分大小写，且长度无限制

　　　　不能使用java中的关键字

　　约定：驼峰标识、见名思意

　　　　类名：首字母大写，如果类名由若干单词组成，那么每个单词的首字母应该大写

　　　　方法名：小写字母开头，如果方法名含有若干单词，则后面的每个单词首字母大写

　　　　源文件名：必须和类名相同，文件名的后缀为.java

2、字符集：iso8859-1西欧字符集 gbk：简体和繁体中文 unicode国际通用字符集（utf-8，utf-16）

3、保留字（关键字）：供系统内部使用的，不可以在标识符中使用

　　例如：this、super

4、数据类型：基本数据类型，引用数据类型

基本数据类型：4类8种

　　整型数据：byte：一个字节：范围是-128~127

　　　　　　short:两个字节：范围是-32768~32767

　　　　　　int :四个字节：范围正负21亿，是整型的默认类型

　　　　　　long：8个字节：使用的时候需要在后面加L或者l

　　浮点数据：float：单精度，7位小数，使用的时候需要加f或者F

　　　　　　double:双精度，14位小数，默认的浮点类型，

　　字符数据：char：2个字节，表示范围0-65535

　　布尔类型：true或者flase，只用1位表示

5、数据类型的转换：

　　基本数据类型之间可以相互转换：自动转换，强制转换

　　自动转换：小类型转为大类型

　　强制转换：大类型转为小类型

　　不同类型的数据进行混合运算的时候，会将类型向最大的转换

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

6、运算符：

　　算术运算符：+、-、*、/、%、++、--

　　%是取模运算，++，--是单目运算符

　　关系运算符：>、<、==、!=、>=、<=

　　逻辑运算符：&&、||、！

　　短路与 &&，式子两边都为真才为真；如果左边第一个式子已经为假则后面的就不会再判断，为假

　　短路或 ||，式子两边有一个为真就为真；如果左边第一个式子已经为真则后面的就不会再判断，为真

　　取反！，真变假，假变真

　　位运算符：&、|、~、^、<<,>>

　　赋值运算符：=

　　扩展赋值运算符：+=、-=、*=、/=、%=

　　条件运算符，三目表达式：？：

7、注释

　　java中注释分为三种：注释不会被编译成字节码文件

　　1、单行注释：// 单行注释

　　2、多行注释：/* 注释内容 */

　　3、文档注释：/** 使用文档注释，当导出doc文件的时候会一起导出来 */

　　idea如何将项目中的接口方法、文档注释导出？

　　Tools --> Generate JavaDoc

　　程序的执行有三种结构

　　顺序结构：Java代码执行顺序：从左到右、从上到下顺序执行

　　分支结构：if-else、switch

　　　　单分支：

        if(false或true){  
            语句;  
        }

　　　　双分支：

        if(false或true){  
            语句;  
        }else{  
            语句;  
        }

　　　　多分支：

        if(false或true){  
            语句;  
        }elseif(false或true){  
            语句;  
        }  
        ...  
        else{  
            语句;  
        }

　　switch结构：

        switch(value){  
            case 值1：  
                语句;  
                break;  
            ...  
            default：  
                语句;  
        }

　　循环结构：for、while、do-while

　　循环的结构的组成部分：初始化；判断条件；循环体；迭代器；

　　　　for循环语句：是最有效、最灵活的循环结构

        for (int i = 0; i < 10; i++) {  
            System.out.println(i);  
        }

　　　　while：先判断，后执行

        int i = 10;  
        while (i >= 0){  
            System.out.println(i);  
            i--;  
        }

　　　　do while：先执行，后判断（循环体至少执行一次）

        int i = 10;  
        do{  
            System.out.println(i);  
            i--;  
        }while (i >= 0);

　　跳转：break、continue、return

　　break：用于switch或循环，用于循环语句时，可跳出循环而执行循环后面的语句

　　continue：只能用在循环语句，跳出循环体中剩余的语句而执行下一次循环

　　return：从当前方法退出，返回到调用该方法的语句处，并从该语句的下一条语句处继续执行程序

递归：程序调用自身的编程技巧称为递归

　　结构：

　　　　递归结束条件

　　　　递归体

　　特点：

　　　　一个问题可被分解为若干层简单的子问题

　　　　子问题和上层问题的解决方案一致

　　　　外层问题的解决依赖于子问题的解决

　　缺点：

　　　　递归调用会占用大量的系统堆栈，内存耗太多

　　　　递归调用层次多时速度要比循环慢很多

数组

　　数组是相同类型数据的有序集合

　　数组的特点：长度固定，连续空间，存储同一种类型数据

　　优点：按照索引查询效率高

　　缺点：添加删除元素效率低；按照内容查询效率低

二维数组：数组的数组

　　面向对象和面向过程都是一种编程思维方式，面向对象和面向过程是相辅相成的，不是完全对立的

　　宏观上都是面向对象的，微观上面向过程

　　对象是类的实例化，类是对象的抽象，类是对象的模板，对象是由类生成的

　　Java通过new关键字来调用构造器，从而返回该类的实例，一个对象应包含两部分：属性（特点，特征）和方法（行为，动作）

　　Java中，万事万物皆对象

　　构造方法（构造器）：对类的属性进行初始化的操作

　　　　要求：类名必须和方法名称一致，没有返回值，参数列表可以任意，构造方法可以实现重载

　　　　　　当自己不定义构造器的时候，系统会默认的分配一个空的构造方法，当定义构造器之后，就不再分配

代码块：由{}括起来的一段代码

　　普通代码块：方法中

　　　　在方法中添加{}没有任何意义

　　构造代码块：方法外，类内

　　　　构造代码块的代码在编译的时候会自动的添加到构造方法中

　　　　1、当有多个构造方法的时候，会将构造代码块放到每一个构造方法中

　　　　2、如果构造方法之间有相互调用，会放到最初的构造方法中

　　静态代码块：方法外，类内

　　　　如果希望加载后，对整个类进行某些初始化操作，可以使用static初始化块。

　　　　在类加载的时候完成初始化的工作

　　　　是在类初始化时执行，不是在创建对象时执行。

　　　　静态初始化块中不能访问非static成员。

　　同步代码块：使用synchronized关键字对线程加锁

　　　　在Java的Object类型中，都是带有一个内存锁的

　　　　有线程获取该内存锁后，其它线程无法访问该内存，从而实现JAVA中简单的同步、互斥操作

方法：完成特定功能的代码块，由5部分组成:访问修饰符，返回值，方法名称，参数列表，方法体

\[修饰符\] 方法返回值类型 方法名(形参列表 ) {  
    方法体  
}

方法调用：返回值类型返回值 = 对象.方法(实参列表);

　　形参和实参

　　定义方法的参数是形式参数

　　调用方法的参数是实在参数

　　参数传递

　　基本数据类型的参数传递，无法通过方法调用改变变量的值

        //测试方法  
        private static test(int i){  
                i++;  
        }  
        //main函数  
        public static void main(String\[\] args) {  
            int i = 1;  
            test(i);  
            //将会打印：1  
            System.out.println(i);  
        }

　　引用数据类型的参数传递，可以通过方法调用改变变量的值

    //测试方法  
    private static void test(HashMap<String, String> hashMap){  
        hashMap.put("name","李四");  
    }  
    //main函数  
    public static void main(String\[\] args) {  
        HashMap<String, String> hashMap = new HashMap<>();  
        hashMap.put("name","张三");  
        test(hashMap);  
        //将会打印：{name=李四}  
        System.out.println(hashMap);  
    }

方法重写：当父类的某些方法不能满足子类的需要的时候，子类重新实现父类的方法

　　要求：

　　　　重写方法必须和被重写方法具有相同方法名称、参数列表和返回类型。

　　　　重写方法不能使用比被重写方法更严格的访问权限且不能重写父类的私有方法和构造方法。

方法重载：一个类中可以定义有相同的名字，但参数不同（类型，个数，顺序不同）的多个方法，调用时会根据不同的参数表选择对应的方法。

　　只有返回值不同不构成方法的重载、只有形参的名称不同不构成方法的重载

封装、继承、多态：

　　封装：该露的露，该藏的藏，将类的某些内部实现细节隐藏起来，只能通过公共的方法进行访问

　　继承：为了提高代码的复用性，对某一批类进行的抽象，抽出相同的属性和方法，组成父类，编写子类，使用extends关键字继承父类（java是单继承）

　　多态：同一个引用类型（父类），使用不同的实例（子类实例）而执行不同操作，多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法，从而实现更加灵活的编程，提高系统的可扩展性

package包：为了解决类重名问题、便于管理类，有了包的概念，合适的类位于合适的包

　　在类中，package位于非注释性语句的第一行