基础_基础语法 - CSDN
基础 订阅
基础是指建筑物地面以下的承重结构,如基坑、承台、框架柱、地梁等。是建筑物的墙或柱子在地下的扩大部分,其作用是承受建筑物上部结构传下来的荷载,并把它们连同自重一起传给地基。 [1] 展开全文
基础是指建筑物地面以下的承重结构,如基坑、承台、框架柱、地梁等。是建筑物的墙或柱子在地下的扩大部分,其作用是承受建筑物上部结构传下来的荷载,并把它们连同自重一起传给地基。 [1]
信息
中文名
基础
组    成
由土和岩石组成
基    础
条形基础 刚性基础
外文名
foundation
分    类
灰土基础、砖基础
基础历史
中国在建筑物的基础建造方面有悠久的历史。从陕西半坡村新石器时代的遗址中发掘出的木柱下已有掺陶片的夯土基础;陕县庙底沟的屋柱下也有用扁平的砾石做的基础;洛阳王湾墙基的沟槽内则填红烧土碎块或铺一层平整的大块砾石。到战国时期,已有块石基础。到北宋元丰年间,基础类型已发展到木桩基础、木筏基础及复杂地基上的桥梁基础、堤坝基础,使基础型式日臻完善。在《营造法式》中对地基设计和基础构造都作了初步规定,如对一般基础埋深作出“凡开基址,须相视地脉虚实,②采用地基上梁和板的计算方法。其深不过一丈,地基土质较好的情况下能够满足设计要求。浅止于五尺或四尺,……”的规定。
收起全文
  • 本课程从初学者角度出发,提供了C#从入门到成为程序开发高手所需要掌握的各方面知识和技术。 【课程特点】 1 由浅入深,编排合理; 2 视频讲解,精彩详尽; 3 丰富实例,轻松易学; 4 每章总结配有难点解析...
  • 你比其他Java程序员更优秀的原因,是你学习了这篇课程! 本篇涵盖了Java的主要语法和核心概念: (1)异常,抽象类,接口等语法概念 (2)装箱拆箱,反射,线程、...Java学习指南的后续篇章以此篇为基础展开讲解。
  • 网络基础知识(一)

    2018-08-05 18:08:01
    IP地址分类与子网掩码有关计算 一、IP地址 1、IP地址基本概念  IP地址在网络层将不同的物理网络地址统一到了全球唯一的IP地址上(屏蔽物理网络差异),是唯一标识互联网上计算机的逻辑地址(相当于手机号码,...

     

    IP地址分类与子网掩码有关计算

    一、IP地址

    1、IP地址基本概念 
    IP地址在网络层将不同的物理网络地址统一到了全球唯一的IP地址上(屏蔽物理网络差异),是唯一标识互联网上计算机的逻辑地址(相当于手机号码,可以通过唯一的手机号码找到手机),所以IP地址也被称为互联网地址(可见其重要性)。

    2、IP地址格式 
    我们目前常用的IPv4中规定,IP地址长度为32位二进制,在表示时,一般将32位地址拆分为4个8位二进制,再转为4个十进制数表示,每个数字之间用点隔开,如127.0.0.1(localhost),这种描述方式被称为“点-数表示法”。 
    IP地址层次:分为网络号和主机号两个层次。网络号表示主机所属网络,主机号表示主机本身。网络号与主机号的位数与IP地址分类有关。

    3、IP地址分配 
    IP地址分配的基本原则是:要为同一网络(子网、网段)内不同主机分配相同的网络号,不同的主机号。

    4、IP地址常见分类 
    IP地址类别与用途

    这里写图片描述

    A类IP地址 
    一个A类IP地址由1字节的网络地址和3字节主机地址组成,网络地址的最高位必须是“0”, 地址范围从1.0.0.0 到126.0.0.0。可用的A类网络有126个,每个网络能容纳1亿多个主机。

    B类IP地址 
    一个B类IP地址由2个字节的网络地址和2个字节的主机地址组成,网络地址的最高位必须是“10”,地址范围从128.0.0.0到191.255.255.255。可用的B类网络有16382个,每个网络能容纳6万多个主机 。

    C类IP地址 
    一个C类IP地址由3字节的网络地址和1字节的主机地址组成,网络地址的最高位必须是“110”。范围从192.0.0.0到223.255.255.255。C类网络可达209万余个,每个网络能容纳254个主机。

    D类地址用于多点广播(Multicast)。 
    D类IP地址第一个字节以“1110”开始,它是一个专门保留的地址。它并不指向特定的网络,目前这一类地址被用在多点广播(Multicast)中。多点广播地址用来一次寻址一组计算机,它标识共享同一协议的一组计算机。

    E类IP地址 
    以“llll0”开始,为将来使用保留。

    5、特殊的IP地址

    **受限的广播地址:**32位全“1”的IP地址,只能做目的地址,用于向本网内部所有主机发送数据包(路由器拒绝向外网发送广播,隔离数据包在本网内)。

    直接广播地址:网络号全“1”,只能作目的地址,用于向目标网内所有主机发送数据包(路由器接受向外网转发数据包,意为广播在全网有效),如C类IP所有主机255.255.255.主机号、B类IP所有主机255.255.主机号。

    **本网络本主机地址:**32位全零的IP地址对应于当前主机,只能做源地址。

    本网特定主机地址:网络号全零的IP地址表示本网络内的特定主机(路由器拒绝目的地址为本网特定主机的数据包,意为只能向本网内特定主机发送数据包),只能做目的地址。

    环回地址就是网络ID为127的IP地址,用于一台主机的客户端与服务器端通过TCP\IP进行通信或者本机进程间通信,一般在自己的主机上进行软件开发测试时候会用到的localhost(127.0.0.1)就是环回地址。

    在IP地址3种主要类型里,各保留了3个区域作为私有地址,其地址范围如下: 
    A类地址:10.0.0.0~10.255.255.255 
    B类地址:172.16.0.0~172.31.255.255 
    C类地址:192.168.0.0~192.168.255.255

    二、子网掩码 

    子网掩码 又叫网络掩码、地址掩码
    上面我们说到IP地址分为网络号与主机号,但是路由如何区分网络号与主机号呢?就需要通过子网掩码。子网掩码必须与IP地址结合使用,A、B、C类的子网掩码分别为255.0.0.0,255.255.0.0与255.255.255.0(网络号字节为255,主机号字节为0)。

    也就是说给你一个IP地址,那么怎么知道它的网络号和主机号各是多少位呢?

    如果不指定,就不知道哪些位是网络号、哪些是主机号,这就需要通过子网掩码来实现

    子网掩码的重要作用:就是将某个IP地址划分成网络地址主机地址两部分。

    子网掩码的位数就是网络的位数。A类网络的网络位数是8位,子网掩码就是255.0.0.0,B类网络的网络位数是16位,子网掩码是255.255.0.0,C类是24位,255.255.255.0。

    以C类IP地址192.168.1.2为例使用子网掩码划分网络号与主机号。

    这里写图片描述

    当然,在计算主机号时,可不用取反子网掩码二进制,直接令其与IP地址异或即可。

    例1 不同子网下的主机能否直接通信(是否在同一网络/段下)

    假设两个IP地址分别是172.20.0.18和172.20.1.16,子网掩码都是255.255.255.0。

    我们可以知道两者的网络标识分别是172.20.0和172.20.1,无法直接通信,也就无法PING通。要想能相互通信,需要将子网掩码改成255.255.0.0

    例2 如何理解172.20.1.0/26

    上文中的26代表主机ID的掩码地址长度,从前往后有26位,即子网掩码的地址是255.255.255.192。

    子网掩码还可以用来将网络划分为更小的子网,将IP的两极结构扩充成三级结构,节约地址空间,减轻路由器负担。

    子网掩码的划分

    如果要将一个网络划分为多个子网,如何确定子网掩码?步骤如下:

    第一步:将要划分的子网数目转换为2的m次方。如果不是恰好是2的多少次方,则按照取大原则。

    第二步:将上一步确定的幂m按照高序占用主机地址前m位,再转化为十进制。如m为3,表示主机位中有3位被划分为网络标识号占用,因网络标识号都为1,故如是C类地址,主机号对应的字节变为11100000,转化为十进制后为224,故子网掩码为255.255.255.224,如果是B类网络,则子网掩码为255.255.224.0。

    网关

    网关(Gateway)又称网间连接器,就是一个网络连接到另一个网络的“关口”。

    网关实质上是一个网络通向其他网络的IP地址。比如有网络A和网络B,网络A的IP地址范围为“192.168.1.1~192. 168.1.254”,子网掩码为255.255.255.0;网络B的IP地址范围为“192.168.2.1~192.168.2.254”,子网掩码为255.255.255.0。在没有路由器的情况下,两个网络之间是不能进行TCP/IP通信的,即使是两个网络连接在同一台交换机(或集线器)上,TCP/IP协议也会根据子网掩码(255.255.255.0)判定两个网络中的主机处在不同的网络里。而要实现这两个网络之间的通信,则必须通过网关。如果网络A中的主机发现数据包的目的主机不在本地网络中,就把数据包转发给它自己的网关,再由网关转发给网络B的网关,网络B的网关再转发给网络B的某个主机(如附图所示)。网络B向网络A转发数据包的过程。

      所以说,只有设置好网关的IP地址,TCP/IP协议才能实现不同网络之间的相互通信。那么这个IP地址是哪台机器的IP地址呢?网关的IP地址是具有路由功能的设备的IP地址,具有路由功能的设备有路由器、启用了路由协议的服务器(实质上相当于一台路由器)、代理服务器(也相当于一台路由器)。

    展开全文
  • 一、 windows系统  win7、win10基本操作组合键(win+e、win+r、win+d、alt+l)   硬件  硬盘(磁盘)分类、存储原理、区别;  内存 分类、运行原理、双通道;... 了解内容:扇区、光区、CPU、显卡;...

    一、  windows系统

          win7、win10基本操作组合键(win+e、win+r、win+d、alt+l) 

         硬件

         硬盘(磁盘)分类、存储原理、区别;

         内存 分类、运行原理、双通道;

         了解内容:扇区、光区、CPU、显卡;

         驱动

         网卡、声卡、USB、打印机;

         计算机管理

         组策略

        注册表

        基本命令(appwiz.cpl、ncpa.cpl、ping、tracert、msconfig、control、cmd、services.msc)

    二、  软件

         Office(word、excel、ppt)安装、卸载、分页、故障处理;

         浏览器(ie、谷歌、火狐)代理、访问页、安全

        Radmin、Teamview

    三、  网络

          TCP/IP协议,IOS模型;

          服务器、路由器、AC、交换机、网线、拓扑图;

          C类网、B类网

          对等网

         IP地址、MAC地址、子网掩码、网关、DNS

         命令(ping、tracert、telnet、ipconfig/all)
     

    展开全文
  • java入门基础

    2018-10-22 21:38:11
    java入门基础,介绍java的基本语法,java发展历程、数据类型、流程控制语句、类和对象、数组,是跨入java世界的基础课程和敲门砖,java爱好者和基础学习着的必修课!
  • 本人学习java时,做的java基础知识总结: 写代码: 1,明确需求。我要做什么? 2,分析思路。我要怎么做?1、2、3 。 3,确定步骤。每一个思路部分用到哪些语句,方法,和对象。 4,代码实现。用具体的java语言...

    本人学习java时,做的java基础知识总结:

    写代码:

    1,明确需求。我要做什么?

    2,分析思路。我要怎么做?1、2、3 。

    3,确定步骤。每一个思路部分用到哪些语句,方法,和对象。

    4,代码实现。用具体的java语言代码把思路体现出来。

    学习新技术的四点:

    1,该技术是什么?

    2,该技术有什么特点(使用注意):

    3,该技术怎么使用。demo

    4,该技术什么时候用?test。


    一:java概述:

    1991 年Sun公司的James Gosling(詹姆斯·高斯林)等人开始开发名称为 Oak 的语言,希望用于控制嵌入在有线电视交换盒、PDA等的微处理器;

    1994年将Oak语言更名为Java;

    Java的三种技术架构:

    JAVAEE:Java Platform Enterprise Edition,开发企业环境下的应用程序,主要针对web程序开发;

    JAVASE:Java Platform Standard Edition,完成桌面应用程序的开发,是其它两者的基础;

    JAVAME:Java Platform Micro Edition,开发电子消费产品和嵌入式设备,如手机中的程序;

    1,JDK:Java Development Kit,java的开发和运行环境,java的开发工具和jre。

    2,JRE:Java Runtime Environment,java程序的运行环境,java运行的所需的类库+JVM(java虚拟机)。

    3,配置环境变量:让java jdk\bin目录下的工具,可以在任意目录下运行,原因是,将该工具所在目录告诉了系统,当使用该工具时,由系统帮我们去找指定的目录。

    环境变量的配置: 
    1):永久配置方式:JAVA_HOME=%安装路径%\Java\jdk path=%JAVA_HOME%\bin 

    2):临时配置方式:set path=%path%;C:\Program Files\Java\jdk\bin

    特点:系统默认先去当前路径下找要执行的程序,如果没有,再去path中设置的路径下找。

    classpath的配置: 
    1):永久配置方式:classpath=.;c:\;e:\
    2):临时配置方式:set classpath=.;c:\;e:\

    注意:在定义classpath环境变量时,需要注意的情况

    如果没有定义环境变量classpath,java启动jvm后,会在当前目录下查找要运行的类文件;

    如果指定了classpath,那么会在指定的目录下查找要运行的类文件。

    还会在当前目录找吗?两种情况:

      1):如果classpath的值结尾处有分号,在具体路径中没有找到运行的类,会默认在当前目录再找一次。
       2):如果classpath的值结果出没有分号,在具体的路径中没有找到运行的类,不会再当前目录找。 
       一般不指定分号,如果没有在指定目录下找到要运行的类文件,就报错,这样可以调试程序。

    4,javac命令和java命令做什么事情呢?

    要知道java是分两部分的:一个是编译,一个是运行。
    javac:负责的是编译的部分,当执行javac时,会启动java的编译器程序。对指定扩展名的.java文件进行编译。生成了jvm可以识别的字节码文件。也就是class文件,也就是java的运行程序。
    java:负责运行的部分.会启动jvm.加载运行时所需的类库,并对class文件进行执行. 
    一个文件要被执行,必须要有一个执行的起始点,这个起始点就是main函数.


    二:java语法基础:

    1,关键字:其实就是某种语言赋予了特殊含义的单词。 
    保留字:其实就是还没有赋予特殊含义,但是准备日后要使用过的单词。

    2,标示符:其实就是在程序中自定义的名词。比如类名,变量名,函数名。包含 0-9、a-z、$、_ ; 
    注意: 
       1),数字不可以开头。 
       2),不可以使用关键字。

    3,常量:是在程序中的不会变化的数据。

    4,变量:其实就是内存中的一个存储空间,用于存储常量数据。
       作用:方便于运算。因为有些数据不确定。所以确定该数据的名词和存储空间。
       特点:变量空间可以重复使用。

    什么时候定义变量?只要是数据不确定的时候,就定义变量。

    变量空间的开辟需要什么要素呢?
      1,这个空间要存储什么数据?数据类型。
      2,这个空间叫什么名字啊?变量名称。
      3,这个空间的第一次的数据是什么? 变量的初始化值。

    变量的作用域和生存期:

    变量的作用域: 
      作用域从变量定义的位置开始,到该变量所在的那对大括号结束;

    生命周期: 
      变量从定义的位置开始就在内存中活了;
      变量到达它所在的作用域的时候就在内存中消失了;

    数据类型: 
    1):基本数据类型:byte、short、int、long、float、double、char、boolean
    2):引用数据类型: 数组、类、接口。

    **级别从低到高为:**byte,char,short(这三个平级)–>int–>float–>long–>double

    自动类型转换:从低级别到高级别,系统自动转的;

    强制类型转换:什么情况下使用?把一个高级别的数赋给一个别该数的级别低的变量;

    运算符号: 
    1)、算术运算符。
       + - * / % %:任何整数模2不是0就是1,所以只要改变被模数就可以实现开关运算。
       +:连接符。
       ++,–

    2)、赋值运算符。
       = += -= *= /= %=

    3)、比较运算符。
      特点:该运算符的特点是:运算完的结果,要么是true,要么是false。

    4)、逻辑运算符。

      & | ^ ! && ||

      逻辑运算符除了 ! 外都是用于连接两个boolean类型表达式。

      &: 只有两边都为true结果是true。否则就是false。

      |:只要两边都为false结果是false,否则就是true

       ^:异或:和或有点不一样。
        两边结果一样,就为false。
        两边结果不一样,就为true.
      & 和 &&区别: & :无论左边结果是什么,右边都参与运算。
           &&:短路与,如果左边为false,那么右边不参数与运算。
      | 和|| 区别:|:两边都运算。
           ||:短路或,如果左边为true,那么右边不参与运算。
    5)、位运算符:用于操作二进制位的运算符。
      & | ^
      & << >> >>>(无符号右移)
    练习:对两个变量的数据进行互换。不需要第三方变量。

    <span style="color:#000000"><code>            int <span style="color:#006666">a</span>  = <span style="color:#006666">3</span>,b = <span style="color:#006666">5</span><span style="color:#880000">;-->b = 3,a = 5;</span>
    
                <span style="color:#006666">a</span> = <span style="color:#006666">a</span> + b<span style="color:#880000">; a = 8;</span>
    
                b = <span style="color:#006666">a</span> - b<span style="color:#880000">; b = 3;</span>
    
                <span style="color:#006666">a</span> = <span style="color:#006666">a</span> - b<span style="color:#880000">; a = 5;</span>
    
                <span style="color:#006666">a</span> = <span style="color:#006666">a</span> ^ b<span style="color:#880000">;//</span>
    
                b = <span style="color:#006666">a</span> ^ b<span style="color:#880000">;//b = a ^ b ^ b = a</span>
    
                <span style="color:#006666">a</span> = <span style="color:#006666">a</span> ^ b<span style="color:#880000">;//a = a ^ b ^ a = b;</span>
    
            练习:高效的算出 <span style="color:#006666">2</span>*<span style="color:#006666">8</span> = <span style="color:#006666">2</span><<<span style="color:#006666">3</span><span style="color:#880000">;</span></code></span>
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    5,语句。 
      If switch do while while for
      这些语句什么时候用?
      1)、当判断固定个数的值的时候,可以使用if,也可以使用switch。
      但是建议使用switch,效率相对较高。

    switch(变量){ 
       case 值:要执行的语句;break; 
       … 
      default:要执行的语句; 
      }

      工作原理:用小括号中的变量的值依次和case后面的值进行对比,和哪个case后面的值相同了
      就执行哪个case后面的语句,如果没有相同的则执行default后面的语句;

      细节:a:break是可以省略的,如果省略了就一直执行到遇到break为止;
         b:switch 后面的小括号中的变量应该是byte,char,short,int四种类型中的一种;
          c:default可以写在switch结构中的任意位置;如果将default语句放在了第一行,则不管expression与case中的value是否匹配,程序会从default开始执行直到第一个break出现。
      2)、当判断数据范围,获取判断运算结果boolean类型时,需要使用if。
      3)、当某些语句需要执行很多次时,就用循环结构。 while和for可以进行互换。
    区别在于:如果需要定义变量控制循环次数。建议使用for。因为for循环完毕,变量在内存中释放。

    break:作用于switch ,和循环语句,用于跳出,或者称为结束。

    break语句单独存在时,下面不要定义其他语句,因为执行不到,编译会失败。当循环嵌套时,break只跳出当前所在循环。要跳出嵌套中的外部循环,只要给循环起名字即可,这个名字称之为标号。

    continue:只作用于循环结构,继续循环用的。

    作用:结束本次循环,继续下次循环。该语句单独存在时,下面不可以定义语句,执行不到。

    6,函 数:为了提高代码的复用性,可以将其定义成一个单独的功能,该功能的体现就是java中的函数。函数就是体现之一。

    java中的函数的定义格式:
       修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数1,…){
          执行语句;
         return 返回值;
      }没有具体的返回值时,返回的返回值类型用void关键字表示。

    如果函数的返回值类型是void时,return语句可以省略不写的,系统会帮你自动加上。

    return的作用:结束函数。结束功能。

    如何定义一个函数?

      函数其实就是一个功能,定义函数就是实现功能,通过两个明确来完成:

      1)、明确该功能的运算完的结果,其实是在明确这个函数的返回值类型。

      2)、在实现该功能的过程中是否有未知内容参与了运算,其实就是在明确这个函数的参数列表(参数类型&参数个数)。

    函数的作用:

      1)、用于定义功能。

      2)、用于封装代码提高代码的复用性。

      注意:函数中只能调用函数,不能定义函数。

    主函数:

       1)、保证该类的独立运行。

      2)、因为它是程序的入口。

      3)、因为它在被jvm调用。

    函数定义名称是为什么呢?

    答:1)、为了对该功能进行标示,方便于调用。

       2)、为了通过名称就可以明确函数的功能,为了增加代码的阅读性。

    重载的定义是:在一个类中,如果出现了两个或者两个以上的同名函数,只要它们的参数的个数,或者参数的类型不同,即可称之为该函数重载了。

    如何区分重载:当函数同名时,只看参数列表。和返回值类型没关系。

    7,数 组:用于存储同一类型数据的一个容器。好处:可以对该容器中的数据进行编号,从0开始。数组用于封装数据,就是一个具体的实体。

    如何在java中表现一个数组呢?两种表现形式。

    1)、元素类型[] 变量名 = new 元素类型[元素的个数];

    2)、元素类型[] 变量名 = {元素1,元素2…};

    元素类型[] 变量名 = new 元素类型[]{元素1,元素2…};


    //二分查找法。必须有前提:数组中的元素要有序。

    <span style="color:#000000"><code> public static <span style="color:#000088">int</span> halfSeach_2(<span style="color:#000088">int</span>[] arr,<span style="color:#000088">int</span> key){
    
            <span style="color:#000088">int</span> <span style="color:#4f4f4f">min</span>,<span style="color:#4f4f4f">max</span>,mid;
    
            <span style="color:#4f4f4f">min</span> = <span style="color:#006666">0</span>;
    
            <span style="color:#4f4f4f">max</span> = arr.<span style="color:#4f4f4f">length</span>-<span style="color:#006666">1</span>;
    
            mid = (<span style="color:#4f4f4f">max</span>+<span style="color:#4f4f4f">min</span>)>><span style="color:#006666">1</span>; <span style="color:#880000">//(max+min)/2;</span>
    
            <span style="color:#000088">while</span>(arr[mid]!=key){
    
                <span style="color:#000088">if</span>(key>arr[mid]){
    
                    <span style="color:#4f4f4f">min</span> = mid + <span style="color:#006666">1</span>;
    
                }
    
                <span style="color:#000088">else</span> <span style="color:#000088">if</span>(key<arr[mid])
    
                    <span style="color:#4f4f4f">max</span> = mid - <span style="color:#006666">1</span>;
    
                <span style="color:#000088">if</span>(<span style="color:#4f4f4f">max</span><<span style="color:#4f4f4f">min</span>)
    
                    <span style="color:#000088">return</span> -<span style="color:#006666">1</span>;
    
                mid = (<span style="color:#4f4f4f">max</span>+<span style="color:#4f4f4f">min</span>)>><span style="color:#006666">1</span>;
    
            }
    
            <span style="color:#000088">return</span> mid;
    
        }
    
    ------------------------------------------</code></span>
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    java分了5片内存。

    1:寄存器。2:本地方法区。3:方法区。4:栈。5:堆。

    栈:存储的都是局部变量 ( 函数中定义的变量,函数上的参数,语句中的变量 );

       只要数据运算完成所在的区域结束,该数据就会被释放。

    堆:用于存储数组和对象,也就是实体。啥是实体啊?就是用于封装多个数据的。

     1:每一个实体都有内存首地址值。

     2:堆内存中的变量都有默认初始化值。因为数据类型不同,值也不一样。

     3:垃圾回收机制。


    三:面向对象:★★★★★

    特点:1:将复杂的事情简单化。

    2:面向对象将以前的过程中的执行者,变成了指挥者。

    3:面向对象这种思想是符合现在人们思考习惯的一种思想。

    过程和对象在我们的程序中是如何体现的呢?过程其实就是函数;对象是将函数等一些内容进行了封装。

    匿名对象使用场景:

    1:当对方法只进行一次调用的时候,可以使用匿名对象。

    2:当对象对成员进行多次调用时,不能使用匿名对象。必须给对象起名字。

    在类中定义其实都称之为成员。成员有两种:

    1:成员变量:其实对应的就是事物的属性。

    2:成员函数:其实对应的就是事物的行为。

    所以,其实定义类,就是在定义成员变量和成员函数。但是在定义前,必须先要对事物进行属性和行为的分析,才可以用代码来体现。

    private int age;//私有的访问权限最低,只有在本类中的访问有效。

    注意:私有仅仅是封装的一种体现形式而已。
    私有的成员:其他类不能直接创建对象访问,所以只有通过本类对外提供具体的访问方式来完成对私有的访问,可以通过对外提供函数的形式对其进行访问。

    好处:可以在函数中加入逻辑判断等操作,对数据进行判断等操作。

    总结:开发时,记住,属性是用于存储数据的,直接被访问,容易出现安全隐患,所以,类中的属性通常被私有化,并对外提供公共的访问方法。

    这个方法一般有两个,规范写法:对于属性 xxx,可以使用setXXX(),getXXX()对其进行操作。

    类中怎么没有定义主函数呢?

    注意:主函数的存在,仅为该类是否需要独立运行,如果不需要,主函数是不用定义的。

    主函数的解释:保证所在类的独立运行,是程序的入口,被jvm调用。

    成员变量和局部变量的区别:

    1:成员变量直接定义在类中。

      局部变量定义在方法中,参数上,语句中。

    2:成员变量在这个类中有效。

     局部变量只在自己所属的大括号内有效,大括号结束,局部变量失去作用域。

    3:成员变量存在于堆内存中,随着对象的产生而存在,消失而消失。

     局部变量存在于栈内存中,随着所属区域的运行而存在,结束而释放。

    构造函数:用于给对象进行初始化,是给与之对应的对象进行初始化,它具有针对性,函数中的一种。

    特点:

    1:该函数的名称和所在类的名称相同。

    2:不需要定义返回值类型。

    3:该函数没有具体的返回值。

    记住:所有对象创建时,都需要初始化才可以使用。

    注意事项:一个类在定义时,如果没有定义过构造函数,那么该类中会自动生成一个空参数的构造函数,为了方便该类创建对象,完成初始化。如果在类中自定义了构造函数,那么默认的构造函数就没有了。

    一个类中,可以有多个构造函数,因为它们的函数名称都相同,所以只能通过参数列表来区分。所以,一个类中如果出现多个构造函数。它们的存在是以重载体现的

    构造函数和一般函数有什么区别呢?

    1:两个函数定义格式不同。

    2:构造函数是在对象创建时,就被调用,用于初始化,而且初始化动作只执行一次。

    一般函数,是对象创建后,需要调用才执行,可以被调用多次。

    什么时候使用构造函数呢?

    分析事物时,发现具体事物一出现,就具备了一些特征,那就将这些特征定义到构造函数内。

    构造代码块和构造函数有什么区别?

    构造代码块:是给所有的对象进行初始化,也就是说,所有的对象都会调用一个代码块,只要对象一建立,就会调用这个代码块。

    构造函数:是给与之对应的对象进行初始化,它具有针对性。

    <span style="color:#000000"><code>“Person p =<span style="color:#009900"> new Person();”</span></code></span>
    • 1


    创建一个对象都在内存中做了什么事情?

    1:先将硬盘上指定位置的Person.class文件加载进内存。

    2:执行main方法时,在栈内存中开辟了main方法的空间(压栈-进栈),然后在main方法的栈区分配了一个变量p。

    3:在堆内存中开辟一个实体空间,分配了一个内存首地址值。new

    4:在该实体空间中进行属性的空间分配,并进行了默认初始化。

    5:对空间中的属性进行显示初始化。

    6:进行实体的构造代码块初始化。

    7:调用该实体对应的构造函数,进行构造函数初始化。()

    8:将首地址赋值给p ,p变量就引用了该实体。(指向了该对象)


    封 装(面向对象特征之一):是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。

    好处将变化隔离;便于使用;提高重用性;安全性

    封装原则:将不需要对外提供的内容都隐藏起来,把属性都隐藏,提供公共方法对其访问。

    This:代表对象,就是所在函数所属对象的引用。

    this到底代表什么呢?哪个对象调用了this所在的函数,this就代表哪个对象,就是哪个对象的引用。

    开发时,什么时候使用this呢?

    在定义功能时,如果该功能内部使用到了调用该功能的对象,这时就用this来表示这个对象。

    this 还可以用于构造函数间的调用。

    调用格式:this(实际参数);

    this对象后面跟上 . 调用的是成员属性和成员方法(一般方法);

    this对象后面跟上 () 调用的是本类中的对应参数的构造函数。

    注意:用this调用构造函数,必须定义在构造函数的第一行。因为构造函数是用于初始化的,所以初始化动作一定要执行。否则编译失败。

    static:★★★ 关键字,是一个修饰符,用于修饰成员(成员变量和成员函数)。

    特点:

    1,想要实现对象中的共性数据的对象共享,可以将这个数据进行静态修饰。

    2,被静态修饰的成员,可以直接被类名所调用。也就是说,静态的成员多了一种调用方式。类名.静态方式。

    3,静态随着类的加载而加载,而且优先于对象存在。

    弊端:

    1,有些数据是对象特有的数据,是不可以被静态修饰的。因为那样的话,特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以,在定义静态时,必须要明确,这个数据是否是被对象所共享的。

    2,静态方法只能访问静态成员,不可以访问非静态成员。

     因为静态方法加载时,优先于对象存在,所以没有办法访问对象中的成员。

    3,静态方法中不能使用this,super关键字。

     因为this代表对象,而静态在时,有可能没有对象,所以this无法使用。

    4,主函数是静态的。

    什么时候定义静态成员呢?或者说:定义成员时,到底需不需要被静态修饰呢?

    成员分两种:

    1,成员变量。(数据共享时静态化)

    该成员变量的数据是否是所有对象都一样:

     如果是,那么该变量需要被静态修饰,因为是共享的数据。

     如果不是,那么就说这是对象的特有数据,要存储到对象中。

    2,成员函数。(方法中没有调用特有数据时就定义成静态)

      如果判断成员函数是否需要被静态修饰呢?

      只要参考,该函数内是否访问了对象中的特有数据:

      如果有访问特有数据,那方法不能被静态修饰。

      如果没有访问过特有数据,那么这个方法需要被静态修饰。

    成员变量和静态变量的区别:

    1,成员变量所属于对象,所以也称为实例变量。

     静态变量所属于类,所以也称为类变量。

    2,成员变量存在于堆内存中。

     静态变量存在于方法区中。

    3,成员变量随着对象创建而存在,随着对象被回收而消失。

     静态变量随着类的加载而存在,随着类的消失而消失。

    4,成员变量只能被对象所调用。

     静态变量可以被对象调用,也可以被类名调用。

    所以,成员变量可以称为对象的特有数据,静态变量称为对象的共享数据。

    静态的注意:静态的生命周期很长。

    静态代码块:就是一个有静态关键字标示的一个代码块区域,定义在类中。

    作用:可以完成类的初始化,静态代码块随着类的加载而执行,而且只执行一次(new 多个对象就只执行一次)。如果和主函数在同一类中,优先于主函数执行。

    Public:访问权限最大。

    static:不需要对象,直接类名即可。

    void:主函数没有返回值。

    Main:主函数特定的名称。

    (String[] args):主函数的参数,是一个字符串数组类型的参数,jvm调用main方法时,传递的实际参数是 new String[0]。

    jvm默认传递的是长度为0的字符串数组,我们在运行该类时,也可以指定具体的参数进行传递。可以在控制台,运行该类时,在后面加入参数。参数之间通过空格隔开。jvm会自动将这些字符串参数作为args数组中的元素,进行存储。

    静态代码块、构造代码块、构造函数同时存在时的执行顺序:静态代码块 —>构造代码块 –> 构造函数;

    生成Java帮助文档:命令格式:javadoc –d 文件夹名 –auther –version *.java

    /** //格式

    *类描述

    *@author 作者名

    *@version 版本号

    */

    /**

    *方法描述

    *@param 参数描述

    *@return 返回值描述

    */


    设计模式:解决问题最行之有效的思想。是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

    java中有23种设计模式:

    单例设计模式:★★★★★

    解决的问题:保证一个类在内存中的对象唯一性。

    比如:多程序读取一个配置文件时,建议配置文件封装成对象。会方便操作其中数据,又要保证多个程序读到的是同一个配置文件对象,就需要该配置文件对象在内存中是唯一的。

    Runtime()方法就是单例设计模式进行设计的。

    如何保证对象唯一性呢?

    思想:

    1,不让其他程序创建该类对象。

    2,在本类中创建一个本类对象。

    3,对外提供方法,让其他程序获取这个对象。

    步骤:

    1,因为创建对象都需要构造函数初始化,只要将本类中的构造函数私有化,其他程序就无法再创建该类对象;

    2,就在类中创建一个本类的对象;

    3,定义一个方法,返回该对象,让其他程序可以通过方法就得到本类对象。(作用:可控)

    代码体现:

    1,私有化构造函数;

    2,创建私有并静态的本类对象;

    3,定义公有并静态的方法,返回该对象。

    <span style="color:#000000"><code>---------------------------------------------
    
    <span style="color:#880000">//饿汉式</span>
    
    class Single{
    
        <span style="color:#000088">private</span> <span style="color:#009900">Single</span>(){} <span style="color:#880000">//私有化构造函数。</span>
    
    <span style="color:#000088">private</span> <span style="color:#000088">static</span> Single s = <span style="color:#000088">new</span> Single(); <span style="color:#880000">//创建私有并静态的本类对象。</span>
    
        <span style="color:#000088">public</span> <span style="color:#000088">static</span> Single <span style="color:#009900">getInstance</span>(){ <span style="color:#880000">//定义公有并静态的方法,返回该对象。</span>
    
            <span style="color:#000088">return</span> s;
    
        }
    
    }
    </code></span>
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    <span style="color:#000000"><code>
    <span style="color:#880000">//懒汉式:延迟加载方式。</span>
    
    class Single2{
    
        <span style="color:#000088">private</span> <span style="color:#009900">Single2</span>(){}
    
    <span style="color:#000088">private</span> <span style="color:#000088">static</span> Single2 s = <span style="color:#000088">null</span>;
    
        <span style="color:#000088">public</span> <span style="color:#000088">static</span> Single2 <span style="color:#009900">getInstance</span>(){
    
            <span style="color:#000088">if</span>(s==<span style="color:#000088">null</span>)
    
                s = <span style="color:#000088">new</span> Single2();
    
            <span style="color:#000088">return</span> s;
    
        }
    
    }
    
    -------------------------------------------------------------------------------------------------</code></span>
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    继 承 (面向对象特征之一)

    好处:

    1:提高了代码的复用性。

    2:让类与类之间产生了关系,提供了另一个特征多态的前提。

    父类的由来:其实是由多个类不断向上抽取共性内容而来的。

    java中对于继承,java只支持单继承。java虽然不直接支持多继承,但是保留了这种多继承机制,进行改良。

    单继承:一个类只能有一个父类。

    多继承:一个类可以有多个父类。

    为什么不支持多继承呢?

    因为当一个类同时继承两个父类时,两个父类中有相同的功能,那么子类对象调用该功能时,运行哪一个呢?因为父类中的方法中存在方法体。

    但是java支持多重继承。A继承B B继承C C继承D。

    多重继承的出现,就有了继承体系。体系中的顶层父类是通过不断向上抽取而来的。它里面定义的该体系最基本最共性内容的功能。

    所以,一个体系要想被使用,直接查阅该系统中的父类的功能即可知道该体系的基本用法。那么想要使用一个体系时,需要建立对象。建议建立最子类对象,因为最子类不仅可以使用父类中的功能。还可以使用子类特有的一些功能。

    简单说:对于一个继承体系的使用,查阅顶层父类中的内容,创建最底层子类的对象。

    子父类出现后,类中的成员都有了哪些特点:

    1:成员变量。

    当子父类中出现一样的属性时,子类类型的对象,调用该属性,值是子类的属性值。

    如果想要调用父类中的属性值,需要使用一个关键字:super

    This:代表是本类类型的对象引用。

    Super :代表是子类所属的父类中的内存空间引用。

    注意:子父类中通常是不会出现同名成员变量的,因为父类中只要定义了,子类就不用在定义了,直接继承过来用就可以了。

    2:成员函数。

    当子父类中出现了一模一样的方法时,建立子类对象会运行子类中的方法。好像父类中的方法被覆盖掉一样。所以这种情况,是函数的另一个特性:覆盖(复写,重写)

    什么时候使用覆盖呢?当一个类的功能内容需要修改时,可以通过覆盖来实现。

    3:构造函数。

    发现子类构造函数运行时,先运行了父类的构造函数。为什么呢?

    原因:子类的所有构造函数中的第一行,其实都有一条隐身的语句super();

    super(): 表示父类的构造函数,并会调用于参数相对应的父类中的构造函数。而super():是在调用父类中空参数的构造函数。

    为什么子类对象初始化时,都需要调用父类中的函数?(为什么要在子类构造函数的第一行加入这个super()?)

    因为子类继承父类,会继承到父类中的数据,所以必须要看父类是如何对自己的数据进行初始化的。所以子类在进行对象初始化时,先调用父类的构造函数,这就是子类的实例化过程

    注意:子类中所有的构造函数都会默认访问父类中的空参数的构造函数,因为每一个子类构造内第一行都有默认的语句super();

    如果父类中没有空参数的构造函数,那么子类的构造函数内,必须通过super语句指定要访问的父类中的构造函数。

    如果子类构造函数中用this来指定调用子类自己的构造函数,那么被调用的构造函数也一样会访问父类中的构造函数。 

    问题:super()和this()是否可以同时出现的构造函数中。

    两个语句只能有一个定义在第一行,所以只能出现其中一个。

    super()或者this():为什么一定要定义在第一行?

    因为super()或者this()都是调用构造函数,构造函数用于初始化,所以初始化的动作要先完成。

    继承的细节:

    什么时候使用继承呢?

    当类与类之间存在着所属关系时,才具备了继承的前提。a是b中的一种。a继承b。狼是犬科中的一种。

    英文书中,所属关系:” is a “

    注意:不要仅仅为了获取其他类中的已有成员进行继承。

    所以判断所属关系,可以简单看,如果继承后,被继承的类中的功能,都可以被该子类所具备,那么继承成立。如果不是,不可以继承。

    细节二:

    在方法覆盖时,注意两点:

    1:子类覆盖父类时,必须要保证,子类方法的权限必须大于等于父类方法权限可以实现继承。否则,编译失败。

    2:覆盖时,要么都静态,要么都不静态。 (静态只能覆盖静态,或者被静态覆盖)

    继承的一个弊端:打破了封装性。对于一些类,或者类中功能,是需要被继承,或者复写的。

    这时如何解决问题呢?介绍一个关键字,final:最终。

    final特点:

    1:这个关键字是一个修饰符,可以修饰类,方法,变量。

    2:被final修饰的类是一个最终类,不可以被继承。

    3:被final修饰的方法是一个最终方法,不可以被覆盖。

    4:被final修饰的变量是一个常量,只能赋值一次。

    其实这样的原因的就是给一些固定的数据起个阅读性较强的名称。 
    不加final修饰不是也可以使用吗?那么这个值是一个变量,是可以更改的。加了final,程序更为严谨。常量名称定义时,有规范,所有字母都大写,如果由多个单词组成,中间用 _ 连接。

    抽象类: abstract

    抽象:不具体,看不明白。抽象类表象体现。

    在不断抽取过程中,将共性内容中的方法声明抽取,但是方法不一样,没有抽取,这时抽取到的方法,并不具体,需要被指定关键字abstract所标示,声明为抽象方法。

    抽象方法所在类一定要标示为抽象类,也就是说该类需要被abstract关键字所修饰。

    抽象类的特点:

    1:抽象方法只能定义在抽象类中,抽象类和抽象方法必须由abstract关键字修饰(可以描述类和方法,不可以描述变量)。

    2:抽象方法只定义方法声明,并不定义方法实现。

    3:抽象类不可以被创建对象(实例化)。

    4:只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后,该子类才可以实例化。否则,该子类还是一个抽象类。

    抽象类的细节:

    1:抽象类中是否有构造函数?有,用于给子类对象进行初始化。

    2:抽象类中是否可以定义非抽象方法?

        可以。其实,抽象类和一般类没有太大的区别,都是在描述事物,只不过抽象类在描述事物时,有些功能不具体。
    所以抽象类和一般类在定义上,都是需要定义属性和行为的。
    只不过,比一般类多了一个抽象函数。而且比一般类少了一个创建对象的部分。

    3:抽象关键字abstract和哪些不可以共存?final , private , static

    4:抽象类中可不可以不定义抽象方法?可以。抽象方法目的仅仅为了不让该类创建对象。


    模板方法设计模式:

    解决的问题:当功能内部一部分实现时确定,一部分实现是不确定的。这时可以把不确定的部分暴露出去,让子类去实现。

    <span style="color:#000000"><code><span style="color:#000088">abstract</span> <span style="color:#000088">class</span> <span style="color:#4f4f4f">GetTime</span>{
    
        <span style="color:#000088">public</span> <span style="color:#000088">final</span> <span style="color:#000088">void</span> getTime(){ <span style="color:#880000">//此功能如果不需要复写,可加final限定</span>
    
            <span style="color:#000088">long</span> start = System.currentTimeMillis();
    
            code(); <span style="color:#880000">//不确定的功能部分,提取出来,通过抽象方法实现</span>
    
            <span style="color:#000088">long</span> end = System.currentTimeMillis();
    
            System.out.println(<span style="color:#009900">"毫秒是:"</span>+(end-start));
    
        }
    
        <span style="color:#000088">public</span> <span style="color:#000088">abstract</span> <span style="color:#000088">void</span> code(); <span style="color:#880000">//抽象不确定的功能,让子类复写实现</span>
    
    }
    
    <span style="color:#000088">class</span> <span style="color:#4f4f4f">SubDemo</span> <span style="color:#000088">extends</span> <span style="color:#4f4f4f">GetTime</span>{
    
        <span style="color:#000088">public</span> <span style="color:#000088">void</span> code(){ <font color=red ><span style="color:#880000">//子类复写功能方法</font></span>
    
            <span style="color:#000088">for</span>(<span style="color:#000088">int</span> y=<span style="color:#006666">0</span>; y<<span style="color:#006666">1000</span>; y++){
    
                System.out.println(<span style="color:#009900">"y"</span>);
    
            }
    
        }
    
    } </code></span>
    展开全文
  • java基础入门(一)

    2020-03-15 00:28:28
    2. 这篇教程是一个学习方向的引导,且只针对基础入门(更加进阶的知识笔者也还在学习)。 3. java的基础入门知识网上有很多,很多大神的博客里也有总结,笔者不认为自己能比大神总结的好。所以在这篇教程里,...

    前言:

    1. 笔者的java没有经过真正系统的学习过,只是跟着书上自学的。所以有些地方难免会理解错误之类的,如果看到错误的地方,请指出来,或者有什么不理解的地方也可以提出来,大家一起进步。

    2. 这篇教程是一个学习方向的引导,且只针对基础入门(更加进阶的知识笔者也还在学习)。

    3. java的基础入门知识网上有很多,很多大神的博客里也有总结,笔者不认为自己能比大神总结的好。所以在这篇教程里,很多基础知识笔者会直接引用一些大神的博客和网上的一些资料,做一个汇总。当然,同时也会加入笔者自己的理解,说一些笔者学习时踩过的坑,分享一些心得。

     

    话不多说,进入正题:

    java 简介

    简单的说,java是一门面向对象编程语言,吸收了C/C++的优点,摒弃了C/C++复杂的指针等内容,也不需要用户手动释放内存空间。java本身还具备了很强的可移植性,通过将源代码编译成二进制字节码,然后通过不同平台的java虚拟机来解释执行字节码,从而实行了“一次编译,到处执行”的跨平台特性。

    Java的应用领域非常广泛。可以做应用系统、互联网网站、以及移动端的安卓等。

    想了解更多的java的发展历史和语言特性,可以点击这里

     

    java 环境配置

    "工欲善其事,必先利其器",学习java首先要配置java运行所需要的java环境,这个网上也有很多教程了,我也不详细讲了。

    java环境配置教程:

    window环境:win7win10

    linux环境:通用教程云服务器(centos7)

    Mac环境:Mac

     

    集成开发环境安装:

    初学者推荐eclipse,安装和使用都比较简单,网上也有很多教程,如window用户可以看这篇教程。下文的例子都是基于eclipse环境,但如果你使用其他IDE也完全不影响代码运行。

    笔者现在用的是IntelliJ IDEA,功能相比eclipse更强大,更智能,尤其在代码提示和补全方面做得很好。笔者一开始学java的时候,也是用的eclipse,后面学java web的时候,就慢慢转用IntelliJ IDEA了,然后再回不来了。简单说说两者的优缺点。

    IntelliJ IDEA:功能强大、各类炫酷实用插件,智能化代码提示与补全,debug也很方便智能,适合开发大型项目。但是安装包很大,运行内存占用比较高,完整版收费(几百美元一年,但学生可以用教育邮箱免费申请使用资格),社区版虽然免费但是阉割了很多功能

    eclipse:免费!!安装包小(几百兆),解压即可使用,简单易上手。不足之处是代码提示和补全不够智能,插件很多但实用性不足。但是作为一款免费软件,eclipse已经非常棒了,对于初学者来说也完全够用。

    很多初学者配置环境时都会遇到一些莫名的问题,大部分都是因为jdk的路径问题引起。所以大家配置环境的一定不能照搬教程里的路径,要根据自己电脑里的jdk路径来配置。如果配置环境出现问题,这时候可以根据报错信息等百度看下原因。实在不行,可以 根据教程“重新配置环境”,这个方法可以解决大部分问题。(eclipse 不能正常运行也可以试试卸载重装。。)。其次也可能和jdk的版本及eclipe版本有关,下载的时候一定要根据你所使用的系统的版本来选择jdk版本和eclipse的版本,否则就会出错.

    这里我还要补充的是 有关java专业的一些术语:

    JRE(Java Runtime Environment):运行Java程序的用户使用的软件,包含了java虚拟机却不包含编译器。

    JDK(Java Development Kit):编写java程序的程序员所使用的开发工具包,JDK里包含了JRE。

    Server JRE :在服务器上运行java环境的软件

    SE (Standard Edition):用于桌面或简单服务器应用的java平台。(我们现在正在学习的)

    EE(Enterprise Edition):用于复杂服务器应用的java平台。

    ME(Micro Edition): 用于手机和其他小型设备的java平台。

    J2(Java 2):一个过时的术语,用于描述1998~2006之间的java版本。

    SDK(Software Development kit):一个过时的术语,用于描述1998~2006之间的JDK。

     

    到这里,默认你已经成功配置好了环境,成功运行了eclipse。

    (备注:1、eclipse默认是英文的,但也提供了中文语言包,下面有些教程的eclipse界面是中文的,但是笔者建议读者使用英文版,毕竟使用英文版软件、系统是一个程序员必须要学会习惯的

                 2、如果你不想用eclipse,完全可以选择其他你喜欢开发环境,如NetBeans和IntelliJ IDEA都是很棒的开发环境。)

    java 第一个程序

    下面开始练习用eclipse来写出你的第一个java程序,通过这个小程序你可以了解java最基础的语法,以便我们后续的学习。不要小看这个程序,几乎所有java程序都有这样的声明格式。

    相关教程:java 第一个程序

    java 数据类型

     

    java 是一门强类型的语言。这意味着必须为每一个变量声明一种类型。在java中一个有8种基本类型,四种整型(byte,short,int,long),两种浮点(float,double),一种字符类型char,一种用于表示真值的boolean型。

    相关教程 java 数据类型

    要注意的是:

    1. 读者后面会接触到一个字符串类型String,每个用双引号括起来的字符串都是String类型的实例,如:

     String e = "";//一个空字符串
     String hi= "hello";

    但是,String不是基本类型, 是标准java类库提供的一个预定类(类和对象的概念后续会讲到)。两个String类型相加的效果为两个字符串的拼接:

    String m = "abc";
    String n = "def";
    String p = a+b;//p = "abcdef";
    int i=13;
    String p = "abcdef"+i;// p="abcdef13"; 13被自动转换成字符串处理

    关于String的用法先简单了解下,后面等学习了对象和类的概念,我们再回头来了解下String类型。

    2. 在C语言里,可以用整数1和0代表代表布尔值true和false,但是,在java里,整数值和布尔值不能进行相互转换。

    3. 在java中,所有的数值类型所占据的字节数量与平台无关(int 永远占4个字节,long永远占8个字节)。

     

    java 变量

    学完了数据类型,我们来学变量。

    在java中,每个变量都有一个类型。声明变量类型时,变量的类型位于变量名之前,如:

    double salary;
    int days;
    long population;
    boolean done;

    相关教程:java 变量

    由于读者没有学习到修饰符及对象和类的相关知识,上面的教程可能会有些看不懂,但不必担心,我们这个小节学习的是变量,后面会讲到其他相关的知识。

    这里还想做几点补充:

    1. 变量的类型除了前面所讲八大基本类型,还可以是类名(如String 就是标准包里的一个类的名称)。

    2. 变量的命名规则:

      (1)变量名必须是一个以字母开头并由字母或数字构成的序列,且不能包含空格和java保留关键字

      (2)尽量使你的变量名有意义,容易一眼看出它本身所表达的意义,避免使用a,b,c等无意义的变量名。推荐使用驼峰命名            法来规范变量名。

    3.在C/C++里区别变量的声明和定义,但是在java中,不区分变量的声明与定义。

    int i=10;//是一个定义
    extern int i;//是一个声明

     

    java 运算符

     

    学习了数据类型及变量,下面我们就来了解下数据之间是怎么进行运算的.

    相关教程:java 运算符

    补充:

    任何数除以0,在运行过程中会抛出一个异常(java异常机制后面也会讲到,这里可以先理解成报错),负数的平方根的结果为NaN(不是一个数字)。

    java 输入输出

    为了增加后面示例程序的互动性,需要程序能够从控制台接收输入(标准输入流),并在控制台中以适当的形式输出(标准输出流)。

    这里要补充一个知识点:在java里,点号( . )用于调用方法(在C语言中被称为的函数)。通用的语法为:

    obeject.method(parameters);//这里表示的是调用了名为object对象的method方法,括号里是方法的参数

    注意,对于一个方法,即使是没有参数也需要使用空括号

    标准输出流:

         打印输出到“标准输出流”(即控制台窗口)是一件非常简单的事情。 

         在我们学习的java的第一个程序时,我们已经接触了标准输出流,并在控制台中输出了“Hello World!”。

    {
          System.out.println("Hello World!");
    }

         在这里,使用了System.out对象并调用了它的println方法并传递给他一个字符串参数(“hello world”)。println方法可以将传递给它的参数显示在控制台上。每次调用println都会在新的一行显示输出(如果想在输出后不换行,可以使用println,如System.out.print("hello");)。

         补充:

                 1.调用println方法也可以不传递参数,此时,将打印一个空行。

                 2.括号内可以使用“+”拼接字符串,实际上我们经常这么使用。     

    	System.out.println("Hello"+"World!");//在控制台中输出Hello world!
    	System.out.println("H"+"e"+"l"+"l"+"o");//在控制台中输出Hello

     

    标准输入流:

     

        标准输出流很简单,但是读取“标准输入流”System.in就没有那么简单了。

        首先需要构造一个Scanner对象,并与“标准输入流”System.in关联。(构造函数和 new操作符在下一篇教程讲到)

    Scanner in = new Scanner(System.in);

        其次,你还要在程序的最开始添加上一行:

        import  java.util.Scanner; 

        这句话的作用是:引入java.util包下的Scanner类。这句话现在不理解完全没没关系,你可以暂时理解成“类似C/C++调用函数时需要声明的头文件”。现在你只需要套用模板就可以了。下面我给出个例子:

    import java.util.Scanner;
    
    /**
     *标准输入输出流的简单实例
     */
    public class Test {
    	public static void main(String[] args) {
    		//构造一个Scanner对象,命名为 in (你完全可以选择其他名字),并与System.in关联
    		Scanner in = new Scanner(System.in);
    		//标准输出流
    		System.out.println("what is your name?");
    		//调用nextLine方法,从控制台读取一个字符串,并赋值给name;
            //值得说明的是,从方法名上看,nextLine可以读取一行内容,实际上也是这样的,你可以输入一个很长很长的字符串,直到你敲下回车键。
    		String name = in.nextLine();
    		//同样,读取一个整数,并赋值给age
    		System.out.println("How old are you");
    		int age = in.nextInt();
    		//打印刚刚输入的信息
    		System.out.println("your name:"+name+"  your age:"+age);
    	}
    }

    运行示例:

    补充:想要读取不同的数据类型,需要调用不同的方法,

               nextLine() 读取输入的下一行字符串,可以包含空格(遇到Enter键视为结束符)

               next()        读取输入的下一个字符串(遇到空格键、Tab键或Enter键视为分隔符或结束符)

               nextInt()        读取输入的下一个整数

               nextDouble() 读取并转换下一个表示整数或浮点数的字符序列

              类似的,还有next.Byte(), nextFloat , nextLong(), nextShot()方法,可以根据名字得出用途

    java 控制流程

    和任何其他程序设计语言一样,java使用条件语句和循环语句确定控制流程。

    教程循环结构分支结构

    拓展: 

    带标签的break语句

    与C/C++不同,java提供了一种带标签的break语句,用于跳出多重嵌套的循环语句。有时候在嵌套很深的循环语句中会发生一些不可预料的事情。此时可能会更加希望跳到嵌套的所有语句之外,但是添加一些额外的条件判断实现各层循环的检测很不方便,这是使用带标签额break语句就很方便了。

    注意:标签必须放在希望跳出的最外层循环之前,并且必须紧跟一个冒号(:)

    下面是一个伪代码示例

    Scanner in =new Scanner(System.in);
    int n;
    read_data:               //该标签标记的整个while语句块(即从while的大括号开始,到大括号结束)
    while(...){
    ...
      for(...){
         n=in.nextInt();
         if(n<0)
            break read_data; // 通过执行带标签的break跳转到带标签的语句块的末尾
       }
    }
    //break后,程序跳到这里并向下继续运行
    if(...){
    ....
    }
    

     

    注意:

     

           1. 带标签的break语句很容易让人想起C语言的goto语句,但是java虽然把goto当成保留字符,但却没有提供任何用法。

           2. 这个方法只能跳出语句块,而不能跳入语句块。

           3.可以将标签应用到任何语句中,甚至可以应用到if语句或者块语句中。

             (块是指由一对大括号括起来的若干条简单java语句)

    java 方法(Method)

    java里的"方法"(method)可能在其他语言(如C语言)里被称为"函数"(function)。简单的说,比如你为了求两个数的最大公因数,写了好多行代码,但如果需要求好多组数的最大公因数,你可以把这些代码用一个 "{}"括起来,并起一个名字,这样当需要用的时候,按照方法名字调用即可。

    教程java 方法

    上述的教程看到"方法调用"的内容即可,后续的 构造方法、java值传递、以及可变参数的内容后面的教程会讲到。

    方法的重载:

    简单的说,方法重载就是同一个方法名,不同的参数类型以及参数个数。有时候,会出现这样一种情况,你要设计一个方法,但是这个方法的形参类型和个数是不确定的,在C语言里,你可能就要设计多个不同的函数,且函数名不能一样,这样就会出现一个问题,调用函数的时候,非常麻烦,要针对参数的不同做出判断和处理;但是在Java里,由于有了方法的重载,你可以把方法名设置成一样的,只需要改变方法的形参列表,这样的好处,调用该方法的时候,Java虚拟机会根据你调用方法时传入的具体参数类型及个数选择相应的方法调用。

    教程:方法重载

    注意:

    1. java允许重载任何方法,而不只是构造方法。

    2. 方法的签名:方法名及参数类型。 值得注意的是方法的返回类型不是方法签名的的一部分,即,不能有两个名字形同、参数类型也相同,返回类型却不同的方法。

     

     

     

    这篇教程只是讲了java的一些基础语法,下一篇我们将开始讲java面向对象编程的思想。。。

    下一篇博客地址:Java基础入门(二)

    展开全文
  • 六大要素为资产、负债、所有者权益、收入、费用、利润。此六者构成了企业财务的全部。 关系具体如下: 资产由固定资产、流动资产等组成; 负债由流动负债、长期负债等组成;...所有者权益由实收资本、盈余公积等组成...

    六大要素为资产、负债、所有者权益、收入、费用、利润。此六者构成了企业财务的全部。

    关系具体如下:

    资产由固定资产、流动资产等组成;

    负债由流动负债、长期负债等组成;

    所有者权益由实收资本、盈余公积等组成;

    收入由主营业务收入、营业外收入等组成;

    费用由制造费用、经营费用、管理费用、财务费用等组成;

    利润由营业利润扣除各项开支后的项目等组成;

    资产=负债+所有者权益;

    所有者权益=资本+利润;

    利润=收入-费用;

    资产+费用(成本)=负债+资本+收入;

    资产类科目余额+成本类科目余额 = 负债类科目余额+所有者权益类科目余额 +损益类科目余额。

    看懂财务报表

    财务信息的主要来源是企业的年度财务报告。这些文件包括资产负债表、收益表和现金流量表。

            在年度财务报告中,会发现,题为管理讨论与分析的部分。这是企业管理者发现 管理中出现的问题和机会。财务报表附注虽然是以脚注的形式对财务报表所提供的信息进行的解释,但实际上,这与财务报表本身同样重要。这些附注可能会揭示企 业的一些重要事项,例如重要的法律诉讼案、会计方法的变更、高级职员组成结构的变化、以及各商业分部的买卖和重组等。

            如何合理地减少纳税 减税同增加收入和营业利润一样,增加了其净利润或称“底线”。通常,企业可以用许多种方法达到合理地减税目的。

    一、企业的结构

           即使一个经济实体是公司,而非合伙或独资企业,不同种类的公司都有不同的所得税税率。

          在经济实体从一种类型转变为另一种类型时,也会引起纳税款状况的变化,进而影响到企业的收益情况。此外,公司注册地所在的地区税收政策或法律,也会影响企业的税收负担。

    二、购买的时机

           大多数会计活动是建立在权责发生制基础之上的。运用这种方法,经营活动所带来的收入,在其实际发生的会计年度予以确认;反之,如果收入在其实际取得的会计 年度予以确认,那么其会计核算便遵循现收现付制。有时,将业务仅仅推迟一天,就会引起收入的确认挪至下一个年度的问题。如果在某一年度获利较多,企业可通 过在同一年度冲销各种可扣除的开支而获益,即有效降低其应税收入;反之,如果获利很少,或企业已经在本年度冲销了许多支出,那就可以将购买行为推迟至下一 年度,即将其在下一年度扣减。

    三、坏帐冲销的时机

           那些实际已经过期而尚未收回的应收帐款,有时可能收不回。与上述购买的时机完全相似,企业可将冲销坏帐的时间,定在这种扣减能够带来很大好处时候。

    四、折旧

           政府允许企业确认因设备和不动产的磨损或过时所引起的价值减少,进而减少其应缴税金。一般来说,政府可以通过折旧政策的变更,来试图刺激某一特定行业或经济的增长。

    如何看懂报表?

    财务报表是企业向管理者和外界提供和公布企业经营情况的正式文件,因此正确编制会计报表对于企业来说十分重要。会计报表中,除财务状况变动表中有些数据来自于分析外,其余各表都来自于帐本。基本报表为资产负债表和损益表,资产负债表资产总数等于负债总数,并且要求数字正确,期期相关;损益表实际上是一张结转利润的会计凭证,通过收入与各项费用的相互抵减可以体现出企业本期的净利润;利润分配表是 分配企业净利润去向的会计报表,通过净利润与各项目的抵减,可结算出未分配利润的数额;财务状况变动表是反映企业年度内营运资金增减变化的报表(营运资金 就是流动资金减去流动负债后的差额,流动资金是用于企业日常经营的资产,流动负债是企业在一年要偿还的债务)。财务状况变动表可以帮助投资者和企业管理者了解企业资金的使用是不是合理,资金来源的渠道是不是顺畅,企业资金融通有没有困难,进而了解企业的财务政策,分析企业的偿债能力。现金流量表是 反映企业在各种经济业务上所发生的现金流量的一张动态报表,现金流量的最后结果是计算出本期新增加的净现金流量。现金流量表可以反映净收益与现金余额的关 系,现金余额与企业盈亏并不一定成正向变化,一般认为有现金流量支持的净收益是高质量的,否则反之,现金流量表报告 过去一年中的现金流量,可以预测未来的现金流量,评价企业取得和运用现金的能力,确定企业支付利息、股利和到期债务的能力,再者可以表明企业生产性资产组 合的变化情况。

    各报表的作用用一句话来概括就是:

    1.资产负债表是反映某一时刻的财务状况。

    2.损益表是反映某一时刻的经营成果,该表的最后一个数字“净利润“将列入利润分配表。

    3.利润分配表反映某一时期的利润分配情况,将期初未分配利润调整为期末未分配利润,并列入 资产负债表。

    4.现金流量表反映现金变化的结果和财务状况变化的原因。

    一、资产负债表

    首先让我们来看看关于会计的两个重要公式。

    公式1 借方=贷方

    会计的基础课程始于借方和贷方。借方在帐簿的左侧,贷方在帐簿的右侧。在这里,要牢记一条不变的定律:“借方=贷方”,换句话说,在任何交易中,都必须同时登记到帐簿的左右两侧,其原则如下:

    (1)资产增加时,记入左侧;资产减少时,记入右侧。

    (2)负债增加时,记入右侧;负责减少时,记入左侧。

    公式2 资产=负债+股东权益

    会计学上最重要的概念是“平衡”,它的主体就是刚才提过的借方与贷方,简言之,资产增加是借方;

    负债或股东权益增加是贷方,双方相抵即所谓的“平衡”。

    资产负债表以这两个重要公式为依据,它反映了企业在某一定时间的财务状况,它揭示了公司拥有 什么,即公司的资产;公司欠什么人的债,即公司的负债;以及公司净资产价值,即股东的权益。资产负债表 上的各帐户在每一新的会计年度开始时,不能被结清而使其余额为零。在资产负债表中,资产是按流动性从大到小的顺序排列,而负债则是按债务到期日由近到远的 顺序排列。

    二、收益表

    收益表反映企业在某一段时间内的获利情况。它与资产负债表的一个显著区别是每一新的会计年度开始时,收益表上的各帐户都会被结平,其余额为零。

    该报表的一般关系式可表示为:

    毛收入-总费用=净利润(损失)

    这一表达式可派生出下列表达式:

    营业利润(损失)=销售收入-成本费用合计上式中,成本费用合计包括:

    一、企业偿还能力分析

    企业偿债能力的大小,是衡量企业财务状况好坏的标志之一,是衡量企业运转是否正常,是否能吸引外来资金的重要方法。反映企业偿债能力的指标主要有:

    (1)流动比率。

    流动比率=流动资产总额/流动负债总额×100%流动比率是反映企业流动资产总额和流动负债比例 关系的指标。企业流动资产大于流动负债,一般表明企业偿还短期债务能力强。流动比率以2∶1 较为理想,最少要1∶1。

    (2)速动比率。

    速动比率=速动资产总额/流动负债总额×100%速动比率是反映企业流动资产项目中容易变现的速动资产与流动负债比例关系的指标。该指标还可以衡量流动比率的真实性。速动比率一般以1∶1为理想,越大,偿债能力越强,但不可低于0.5∶1。

    (3)现金比率

    现金比率=现金类流动资产/流动资产总额×100%现金比率是反映企业流动资产中有多少现金能

    用于偿债。现金比率越大,流动资产变现损失的风险越小,企业短期偿债的可能性越大。

    (4)变现比率变现比率=现金类流动资产/流动负债×100%变现比率反映企业短期的偿债能力,又具有补充现金比率的功能。

    (5)负债流动率

    负债流动率=流动资产/负债总额 × 100%它是衡量企业在不变卖固定资产的情况下,偿还全部债务的能力。该比率越大,偿还能力越高。

    (6)资产负债率(负债比率)

    资产负债率=负债总额/ 资产净值×100%资产净值是指扣除累计折旧后的资产总额。它反映企业

    单位资产总额中负债所占的比重,用来衡量企业生产经营活动的风险程度和企业对债权的保障程度。该比率越小,企业长期偿债能力越强,承担的风险也越小。

    二、周转能力分析

    周转能力反映企业生产经营资金在获利条件下的周转速度。考核的主要指标有:

    1.应收帐款周转率。

    应收帐款周转率=赊销净额/平均应收帐款余额×100%

    应收帐款周转天数=日历天数/ 应收帐款周转率

    应收帐款周转率是反映企业在一定时期内销售债权(即应收帐款的累计发生额)与期末应收帐款平均余额之比。用来验测企业利用信用环节展销货业务的松紧程度,反映企业生产经营管理状况。

    2.存货周转率。

    存货周转率销售成本额=销售成本额/存货平均占用额 ×100%

    存货周转天数=日历天数/存货周转率

    存货周转率是反映企业存货在一定时期内使用和利用的程度,它可以衡量企业的商品推销水平和销货能力,验证现行存货水平是否适当。

    3.流动资产周转率。

    流动资产周转率=销售收入/ 流动资产平均占用额 ×100%

    该指标用来衡量企业生产产品是否适销对路,存货定额是否适当,应收帐款回笼的快慢。

    4.固定资产周转率。

    固定资产周转率=销售收入/ 固定资产平均占用额 ×100%

    该指标表明固定资产的价值转移和回收速度,比率越大,固定资产的利用率越高,效果越好。

    三、获利能力分析

    企业获利能力分析的目的在于观察企业在一定时期实现企业总目标的收益及获利能力。衡量企业获利能力的主要指标有:

    1.资本金利润率

    资本金利润率=企业利润总额/ 注册资本总额 ×100%  该指标是衡量企业经营成果,反映企业获利水平高低的指标。它越大,说明企业获利能力越大。

    2.销售利润率

    销售利润率=利润总额/产品销售收入×100%

    该指标是反映企业实现的利润在销售收入中所占的比重。比重越大,表明企业获利能力越高,企业的经济效益越好。

    3.成本利润率。

    成本利润率=利润总额/成本费用总额×100%

    该指标是反映企业在产品销售后的获利能力,表明企业在成本降低方面取得的经济效益何。

    4.资产报酬率。

    资产报酬率=(税后净收益+利息费用)/ 平均资产总额×100%

    该指标是用来衡量企业对所有经济资源的运用效率。

    四、成长能力分析

    企业成长能力分析的目的是为了说明企业的长远扩展能力,企业未来生产经营实力。评价企业成长能力的主要指标有:

    1.股本比重。

    股本比重=股本(注册资金)/ 股东权益总额

    该指标用来反映企业扩展能力的大小。

    2.固定资产比重。

    固定资产比重=固定资产总额/ 资产总额

    该指标用来衡量企业的生产能力,体现企业存在增产的潜能。

    3.利润保留率。

    利润保留率=(税后利润-应发股利)/ 税后利润

    该指标说明企业税后利润的留存程度,反映企业的扩展能力和补亏能力。该比率越大,企业扩展能力越大。

    4.再投资率。

    再投资率=(税后利润-应付利润)/ 股东权益该指标是反映企业在一个经营周期后的成长能力。该比率越大,说明企业在本期获利大,今后的扩展能力强。

    必须指出,上述各指标是从不同角度、以不同方式反映和评价企业的财务状况和经营成果,因此 要充分理解各种指标的内涵及作用,并考虑各指标之间的关联性,才能对企业的生产经营状况作出正确合理的判断.

    转自:https://www.cnblogs.com/Steveson/archive/2009/07/14/1523611.html

    展开全文
  • 五个基本的关系代数操作 并、差、笛卡尔积、选择、投影 数据库语言四大类 DQL(Data Query Language):数据库查询语言。...DDL(Data Definition Language):数据库定义语言。定义关系模式、删除关系、修改关系...
  • import java.io.IOException; import java.io.InputStream; import java.util.Properties; ... * 有时,需要配置文件,配置文件中保存的内容是什么 ?... * 保存一些经常变化的数据,部署后和开发时使用的数据 不一样, 如...
  • 我之前里的文章,写的大部分都是与计算机基础知识相关的,这些基础知识,就像我们的内功,如果在未来想要走的更远,这些内功是必须要修炼的。框架千变万化,而这些通用的底层知识,却是几乎不变的,了解了这些知识,...
  • C++语言基础视频教程

    2019-06-05 11:16:46
    C++语言基础视频培训课程:本课与主讲者在大学开出的程序设计课程直接对接,准确把握知识点,注重教学视频与实践体系的结合,帮助初学者有效学习。本教程详细介绍C++语言中的封装、数据隐藏、继承、多态的实现等入门...
  • 本课程提供零基础的孩子学习编程,学习Python语言的基本知识,讲课内容通俗易懂,结合大量的实例,让孩子更容易理解编程中的一些概念。 学会本课程后,孩子能看懂一般的Python代码,并能写简单的程序,学会编程...
  • 学员可以通过视频进行软考软件设计师相应的基础知识培训,掌握软件开发与设计的基础知识包括:数据结构、软件工程、操作系统、数据库原理、软件设计、UML分析与设计等内容,为考试和自身能力提高打下坚实基础。...
  • 首先,因为数据结构作为计算机专业的专业基础课程,是计算机考研的必考科目之一,如果打算报考计算机专业的研究生,你必须学好它;其次,数据结构是计算机软考、计算机等级考试等相关考试的必考内容之一,想要顺利...
  • iOS基础面试题(一)

    2016-03-23 18:19:35
    kaikaijia同学私信我,说想加群,我就建个iOS开发群,大家做技术交流和资源,群号:...随着iOS平台开发的职位的增加,笔试、面试也越来越有“套路”,这里我总结了一些面试题,多数是Objective-C的基础知识,适
  • 2015年最新Android基础入门教程目录(完结版) 前言: 关于《2015年最新Android基础入门教程目录》终于在今天落下了帷幕,全套教程 共148节已编写完毕,附上目录,关于教程的由来,笔者的情况和自学心得,资源分享 ...
  • 不管你是Java小白,还是Java初级, 没关系,学完我们的教程,你会对Java的核心知识体系有清晰的理解,你将会站在高处鸟瞰Java,为接下来的学习打下坚实的基础。 本教程的每一个细节都经过精心专研,完全针对Java初学...
  • 文章目录腾讯面试:我倒在了网络基础知识TCP与UDP的区别TCP的三次握手和四次挥手[TCP三次握手 四次挥手]...腾讯面试:我倒在了网络基础知识 腾讯面试十分注重网络基础知识,问的几乎都是一些细节知识,...
  • MATLAB最基础的教程

    2018-06-21 19:37:08
    这篇将介绍工程数学中常用的数学概念,与matlab似乎并不相关,但实则是matlab的基础。1.数值与符号 如果给工程数学问题分类,最大的两类肯定是数值问题和符号问题,对应matlab的数值运算和符号运算。简而言之,数值...
1 2 3 4 5 ... 20
收藏数 4,101,421
精华内容 1,640,568
关键字:

基础