精华内容
下载资源
问答
  • 具有类类型的变量称作
    千次阅读
    2019-12-27 10:48:07

    1. 成员变量

    成员变量的修饰
    在这里插入图片描述
    (1) public 公共变量,可被任何包中的任何类访问,只有在确认任何外部访问都不会带来不良后果的情况下才将成员声明为公共的,公共变量对任何类可见,不具有数据保护功能。
    (2)private私有变量,由 private 修饰的变量称为私有变量,私有变量是不公开的,它们得到了最好的保护,这是对类进行封装时使用的主要方法。
    (3)protected 受保护变量,可以被声明它的类和派生子类以及同一个包中的类访问,而外界无法访问。
    (4)package(default),有 package 修饰的变量常常省略 package 关键字,即没有修饰符的成员被视为包成员。

    static 静态变量, **静态变量是类固有的,可以直接引用,其他成员变量仅仅在被声明、生成实例对象后才存在,**才可以被引用,因此,把静态变量称作类变量、把非静态变量称为实例变量。

    2. 成员方法和参数传递机制

    在Java中,方法只能作为类的成员,故称为成员方法。方法操作类定义的数据,以及提供对数据的访问的代码。

    大多数情况下,程序的其他部分都是通过类的方法和其他类的实例进行交互的,对象的行为由类的方法实现,其他对象可以调用另外一个对象的方法,通过消息(方法参数)的传递实现对该对象行为的控制。

    2.1 成员方法的声明与修饰

    [public] [private] [protected] [package] //访问控制修饰符 ,与成员变量的修饰符有相同作用。

    1. final 最终方法
      当方法被声明为最终方法后,将不能被子类覆盖,即最终方法能被子类继承和使用,但不能在子类中修改或重新定义。
    • 适用于: 保护一些重要的方法不被修改,尤其是那些对类的状态和行为有关键作用的方法被保护后,可以避免未知情况的发生。
    • 注意 : 有时不便于把整个类声明为最终类,这种保护太严格,不利于编程,此时可以有选择的把一些方法声明为最终方法,同样可以起到保护作用。
    1. abstract 方法
      一个抽象类可以含有抽象方法,抽象方法是指没有具体方法体的方法,该方法不能实现,所以抽象方法不能出现在非抽象类中
    • 使用抽象类和抽象方法的原因: 一个抽象类可以定义一个统一的编程接口,使其子类表现出共同的状态和行为,但各自的细节可以不同。子类共有的行为由抽象类中的抽象方法来约束,而子类行为的具体细节则通过抽象方法的覆盖来实现。这种机制可增加编程的灵活性,也是 OOP 继承树的衍生基础。

    例如,直线、圆和矩形等图形对象都有一些共同的位置(位置、边界)和行为(移动、改变大小、画出)。可以利用这些共性,把它们声明为同一个父类的子类,但是一个圆和一个矩形在很多细节方面又是不同的,这时,一个抽象父类是最佳选择。 子类继承父类后,可以通过覆盖方法实现自己的方法。

    1. 方法参数的传值方式
      一个对象和外部交换信息主要靠方法的参数来传递。在 Java中,可传递的参数包括任何数据类型,例如基本数据类型、数组和对象(没错,对象也可以)。
    class MyBox {
    	private int x, y, weight, height;public void draw(Graphics g){
    	g.drawRect(x,y,width,height);
    	}
    }
    

    Java虽然不能传递方法,但可以传递对象,然后调用该对象的方法。

    1. 可变参数
      返回值类型 方法名称(类型 参数名 1 , 类型 参数名 2, 类型…可变参数名){}

    向方法传递可变参数之后,其中可变参数以数组形式保存下来,如果方法中有多个参数,可变参数必须位于最后一项。

    更多相关内容
  • 现实生活中,我们在超市买东西的时候,往往都需要使用购物车来存储物品,...变量可以理解为去超市购物使用购物车,他的类型和值在赋值的那一刻被初始化。变量的赋值是通过符号来表示的,示例代码如下:num_one = 100...

    1577370495235_学IT就到黑马程序员.gif

    现实生活中,我们在超市买东西的时候,往往都需要使用购物车来存储物品,等到所有的物品都购买完成后,在收银台进行结账即可。 大家试想一下,如果程序中要对多个数据求和,就需要把这些数据先存储起来,再对这些数据进行累加。

    在python中,若要存储数据,需要用到变量。变量可以理解为去超市购物使用购物车,他的类型和值在赋值的那一刻被初始化。变量的赋值是通过符号来表示的,示例代码如下:

    num_one = 100 # num_one就是一个变量,就好比一辆购物车,存储的是数据100

    num_two = 87 # num_two也是一个变量,存储的数据是87

    result = num1+num2 # 把num_one和num_two两辆”购物车”数据进行累加,放到 result变量中

    上述示例中, num_one、 num_two、result都是变量。其中,变量 num_one和num_two就好比一辆购物车,它们分别存储的数据是100和87。变量 result存储的数据是num_one和num_two这两辆“购物车”中的数据累计之和。

    1577958668365_1563349531632_python.jpg

    变量用来存储数据,那么大家有没有想过,我们应该让变量占用多大空间,保存什么样的数据呢?在讲解变量的类型之前,我们先来看一个生活中的例子,例如,我们要运送一台电脑,大卡车和小轿车都可以完成,但是,如果使用大卡车运送一台电脑,显然有点小题大做,浪费了大。

    如果使用变量存储数据时,为了更充分利用内存空间,我们可以为变量指定不同的数据类型。下面我们来看下Python中常见的变量的数据类型。

    (1) 数字型

    Python中的数字类型包含整型、浮点型和复数类型。示例代码如下:

    整 型:0101 83 -239 0x80 299384938832

    浮点型:3.1415 4.2E-10 -2.34E-19

    复数类型:3.12+1.23j -1.23-98j

    (2)布尔类型

    布尔类型是特殊的整型,它的值只有两个,分别是True和False。如果将布尔值进行数值运算,True会被当作整型1,False会被当作整型0。

    (3)字符串类型

    Python中的字符串被定义为一个字符集合,它被引号所包含,引号可以是单引号、双引号或者三引号(三个连续的单引号或者双引号)。字符串具有索引规则,第1个字符的索引是0,第2个字符的索引是1,以此类推。

    下面是字符串的示例代码:

    string_one = 'Python'

    string_two = ''Python''

    string_three = '''Python'''

    (4)列表和元组类型

    我们可以将列表和元组当作是普通的“数组”,它们可以保存任意数量的任意类型的值,这些值称作元素。列表中的元素使用中括号[]包含,元素的个数和值是可以随意修改的。而元组中的元素使用小括号()包含,元素不可以被修改。下面看一下列表和元组的表示方式。

    list_name = [1, 2, 'hello'] # 这是一个列表

    tuple_name = (1, 2, 'hello') # 这是一个元组

    多学一招

    列表与元组的区别:

    列表是动态数组,它们不可变且可以重设长度(改变其内部元素的个数)。

    元组是静态数组,它们不可变,且其内部数据一旦创建便无法改变。

    元组缓存于Python运行时环境,这意味着我们每次使用元组时无须访问内核去分配内存。

    列表和元组设计哲学上不同:

    列表可被用于保存多个互相独立对象的数据集合;

    元组用于描述一个不会改变的事务的多个属性。

    (5)字典类型

    字典是 Python中的映射数据类型,由键-值对组成。字典可以存储不同类型的元素,元素使用大括号{}来包含。通常情况下,字典的键会以字符串或者数值的形式来表示,而值可以是任意类型。示例代码如下:

    dict_name

    = {"name":"zhangsan", "age":18} #这是一个字典

    上述代码中,变量 dict_name是一个字典类型,它存储了两个元素,第1个元素的键为name,值为 zhangsan;第2个元素的键为age,值为18。

    在 Python中,只要定义了一个变量,并且该变量存储了数据,那么变量的数据类型就已经确定了。这是因为系统会自动辨别变量的数据类型,不需要开发者显式说明变量的数据类型了。

    如果希望查看变量的类型,可以使用“type(变量的名字)”来实现。示例代码如下:

    >>> number = 5.2

    >>> type(number) // 使用type函数查看类型

    上述代码中,变量number存储的值为5.2,系统会自动根据数值判断number变量的数据类型为float。因此,当使用type函数查看变量number的数据类型时,结果为float。

    猜你喜欢:

    最新Python安装图文教程

    Python基础视频教程下载

    dict_name = {"name":"zhangsan", "age":18} #这是一个字典dict_name = {"name":"zhangsan", "age":18} #这是一个字典

    展开全文
  • 变量与数据类型 java基础03

    万次阅读 2020-11-30 08:36:00
    1. 关键字关键字是编程语言里事先定义好并赋予了特殊含义的单词,也称作保留字。和其它语言一样,Java中保留了许多关键字,例如,class、public等,下面列举的是Java中所有的关...

    1. 关键字

    关键字是编程语言里事先定义好并赋予了特殊含义的单词,也称作保留字。和其它语言一样,Java中保留了许多关键字,例如,class、public等,下面列举的是Java中所有的关键字。

    1.1 关键字概述

    被Java语言赋予特定含义的单词

    1.2 关键字特点

    组成关键字的字母全部小写

    1.3 关键字注意事项

    • goto和const作为保留字存在,目前并不使用

    • 类似Notepad++这样的高级记事本,针对关键字有特殊的颜色标记,非常直观

    用于定义数据类型的关键字

    用于定义访问权限修饰符的关键字

    2. 标识符

    2.1 标识符概述

    就是给类,接口,方法,变量等起名字时使用的字符序列

    2.2 组成规则

    由英文大小写字母、数字字符、$(美元符号)、_(下划线)组成

    2.3 注意事项

    • 不能以数字开头

    • 不能是Java中的关键字

    • 区分大小写

    2.4 标识符常见命名规则:见名知意

    2.4.1 包

    其实就是文件夹,用于把相同的类名进行区分,全部小写,单级:liuyi,多级:cn.itcast

    为了便于对硬盘上的文件进行管理,通常都会将文件分目录进行存放。同理,在程序开发中,也需要将编写的类在项目中分目录存放,以便于文件管理。为此,Java引入了包(package)机制,程序可以通过声明包的方式对Java类定义目录。

    Java中的包是专门用来存放类的,通常功能相同的类存放在相同的包中。在声明包时,使用package语句,具体示例如下:

    package cn.itcast.chapter01; // 使用package关键字声明包
    public class Example01{…}
    

    需要注意的是,包的声明只能位于Java源文件的第一行。

    在实际程序开发过程中,定义的类都是含有包名的,如果没有显式地声明package语句,创建的类则处于默认包下,在实际开发中,这种情况是不应该出现的,本教材的示例代码主要展现的是功能部分的代码,所以在大多数示例代码中没有为示例指定包名,但是在提供的源码中,都已使用包名。

    在开发时,一个项目中可能会使用很多包,当一个包中的类需要调用另一个包中的类时,就需要使用import关键字引入需要的类。使用import可以在程序中一次导入某个指定包下的类,这样就不必在每次用到该类时都书写完整类名,简化了代码量。使用import关键字的具体格式如下所示:

    import 包名.类名;
    

    需要注意的是,import通常出现在package语句之后,类定义之前。如果有时候需要用到一个包中的许多类,则可以使用 import 包名.*; 来导入该包下所有类。

    在JDK中,不同功能的类都放在不同的包中,其中Java的核心类主要放在java包及其子包下,Java扩展的大部分类都放在javax包及其子包下。为了便于后面的学习,接下来简单介绍Java语言中的常用包。

    • java.util:包含Java中大量工具类、集合类等,例如Arrays、List、Set等。

    • java.net:包含Java网络编程相关的类和接口。

    • java.io:包含了Java输入、输出有关的类和接口。

    • java.awt:包含用于构建图形界面(GUI)的相关类和接口。

    除了上面提到的常用包,JDK中还有很多其它的包,比如数据库编程的java.sql包,编写GUI的javax.swing包等等,JDK中所有包中的类构成了Java类库。在以后的章节中,这些包中的类和接口将逐渐介绍,这里只需要有个大致印象即可。

    2.4.2 类或者接口

    一个单词:单词的首字母必须大写,举例:Student,Dog
    多个单词:每个单词的首字母必须大写举例:HelloWorld,StudentName

    2.4.3 方法和变量

    一个单词:单词的首字母小写,举例:main,age
    多个单词:从第二个单词开始,每个单词的首字母大写,举例:studentAge,showAllNames()

    2.4.4 常量

    一个单词:全部大写,举例:PI
    多个单词:每个字母都大写,用_隔开,举例:STUDENT_MAX_AGE

    3. 注释

    3.1 注释概述

    用于解释说明程序的文字

    3.2 Java中注释分类格式

    • 单行注释,格式://注释文字

    • 多行注释,格式:/* 注释文字 */

    • 文档注释,格式:/** 注释文字 */

    /*
        注释:用于解释说明程序的文字
    
        Java中注释的分类及格式
            单行注释://
            多行注释:/星 星/
                注意:多行不可以嵌套使用,而单行是可以的
            文档注释:被javadoc工具解析生成一个说明书,面向对象部分讲解。
    */
    
    //这是我的注释案例
    class ZhuShiDemo {
        //main方法是主方法
        //是程序的入口
        //被jvm调用
        public static void main(String[] args) {
            System.out.println("好好学习,天天向上");
        }
    }
    
    • 对于单行和多行注释,被注释的文字,不会被JVM(java虚拟机)解释执行

    • 对于文档注释,是java特有的注释,其中注释内容可以被JDK提供的工具 javadoc 所解析,生成一套以网页文件形式体现的该程序的说明文档

    • 注释是一个程序员必须要具有的良好编程习惯

    • 初学者编写程序可以养成习惯:先写注释再写代码

    • 将自己的思想通过注释先整理出来,在用代码去体现

    • 因为代码仅仅是思想的一种体现形式而已

    /*
        需求:我准备写一个java程序,把"HelloWorld"这句话输出在控制台
    
        分析:
            A:要写一个Java程序,必须定义类
            B:把数据能够输出,说明我们的程序是可以独立运行的,而程序要独立运行,必须定义main方法
            C:把数据输出在控制台,必须使用输出语句
    
        实现:
            A:java语言提供了一个关键字:class用来定义类,后面跟的是类名
            B:main方法的格式是固定的:
                public static void main(String[] args) {
    
                }
            C:输出语句的格式是固定的:
                System.out.println("HelloWorld");
                "HelloWorld"这个内容是可以改变的
    */
    
    //这是我的HelloWorld案例
    class HelloWorld {
        /*
            为了程序能够独立运行,定义main方法
            main方法是程序的入口
            被jvm自动调用
        */
        public static void main(String[] args) {
            //为了把数据显示在控制台,我们就使用了输出语句
            System.out.println("HelloWorld");
        }
    }
    

    4. 常量

    4.1 常量概述

    在程序执行的过程中其值不可以发生改变

    4.2 Java中常量分类

    4.2.1 字面值常量

    • 字符串常量:用双引号括起来的内容,举例:“hello”,“world”

    • 整数常量:所有整数,举例:12,23

    • 小数常量:所有小数,举例:12.34,56.78

    • 字符常量:用单引号括起来的内容,举例:‘a’,’A’,’0’

    • 布尔常量,较为特有,举例:true,false

    • 空常量,举例:null

    4.2.2 自定义常量

    /*
        常量:
            在程序执行过程中,其值不发生改变的量。
    
        分类:
            A:字面值常量
            B:自定义常量(后面讲)
    
        字面值常量
            A:字符串常量 用双引号括起来的内容。
                举例:"hello","world","HelloWorld"
            B:整数常量  所有的整数
                举例:100,200
            C:小数常量  所有的小数
                举例:10.23,110.11
            D:字符常量  用单引号括起来的内容
                举例:'a','A','0'
                错误的:'ab'
            E:布尔常量  比较特殊
                举例:true,false
            F:空常量   后面讲
                举例:null
    */
    class ConstantDemo {
        public static void main(String[] args) {
            //字符串常量的输出
            System.out.println("hello");
    
            //整数常量的输出
            System.out.println(100);
    
            //小数常量的输出
            System.out.println(100.10);
    
            //字符常量的输出
            System.out.println('a');
            System.out.println('A');
            System.out.println('0');
            //这个是有问题的
            //System.out.println('ab');
    
            //布尔常量的输出
            System.out.println(true);
            System.out.println(false);
        }
    }
    

    5. 变量

    在程序运行期间,随时可能产生一些临时数据,应用程序会将这些数据保存在一些内存单元中,每个内存单元都用一个标识符来标识。这些内存单元我们称之为变量,定义的标识符就是变量名,内存单元中存储的数据就是变量的值。

    5.1 变量概述

    在程序执行的过程中,在某个范围内其值可以发生改变的量,理解:如同数学中的未知数

    5.2 变量定义格式

    数据类型 变量名 = 初始化值;
    注意:格式是固定的,记住格式,以不变应万变

    5.3 变量的组成规则

    1、从本质上讲,变量其实是内存中的一小块区域,使用变量名来访问这块区域,因此,每一个变量使用前必须要先申请(声明),然后必须进行赋值(填充内容),才能使用。通过画图说明一个变量的组成部分

    数据类型,变量名,变量值

    2、为什么要定义变量呢?用来不断的存放同一类型的常量,并可以重复使用

    6. 数据类型和类型转换

    Java是一门强类型的编程语言,它对变量的数据类型有严格的限定。在定义变量时必须声明变量的类型,在为变量赋值时必须赋予和变量同一种类型的值,否则程序会报错。

    类型转换

    6.1 数据类型

    6.1.1 Java语言是强类型语言,对于每一种数据都定义了明确的具体数据类型,在内存总分配了不同大小的内存空间

    6.1.2 所谓有效数字:具体地说,是指在分析工作中实际能够测量到的数字。所谓能够测量到的是包括最后一位估计的,不确定的数字。对于一个近似数,从左边第一个不是0的数字起,到精确到的位数止,所有的数字都叫做这个数的有效数字。

    6.1.3 Java 各整数类型有固定的表数范围和字段长度,其不受具体操作系统的影响,以保证Java程序的可移植性。

    • Java语言的整型常量默认为int型,声明long型常量可以后加‘ l ’或‘ L ’ ,如:

    int i1 = 600; //正确     long l1 = 88888888888L; //必须加l否则会出错
    
    • - 与整数类型类似,Java浮点类型有固定的表数范围和字段长度,不受平台影响。

      Java浮点类型常量有两种表示形式,十进制数形式,如: 3.14       314.0

    • Java 浮点型常量默认为 double型,如要声明一个常量为 float 型,则需在数字后面加 f 或 F ,如:
      java<br />double d = 12345.6; //正确 <br />float f = 12.3f; //必须加f否则会出错<br />

    • char* 型数据用来表示通常意义上的“字符”

      • 字符常量为用单引号括起来的单个字符,例如:char ch1= 'a'; char ch2='中';

      • Java字符采用 Unicode 编码,每个字符占两个字节,因而可用十六进制编码形式表示。

      • 注:Unicode是全球语言统一编码

    • boolean类型

      • boolean 类型适于逻辑运算,一般用于程序流程控制 。

      • boolean 类型数据只允许取值 true 或 false ,不可以 0 或非 0 的整数替代 true 和 false ,这点和C语言不同。

    • 数据类型

      • 基本数据类型:整型byte、short、int、long,浮点型float、double,字符型char,布尔型boolean

      • 引用数据类型:类class、接口interface、数组[]

    /*
        数据类型:Java是一种强类型的语言,针对每一种数据都定义了明确的数据类型。
    
        数据类型分类:
            A:基本数据类型
            B:引用数据类型(类,接口,数值)
    
        基本数据类型:4类8种
            A:整数            占用字节数
                byte            1
                short           2
                int             4
                long            8
    
            B:浮点数
                float           4
                double          8
    
            C:字符
                char            2
            D:布尔
                boolean         1
    
            注意:
                整数默认是int类型
                浮点数默认是double类型。
    
                长整型后缀用L或者l标记。建议使用L。
                单精度浮点数用F或者f标记。建议使用F。
    */
    class DataTypeDemo {
        public static void main(String[] args) {
            //定义变量的格式:
            //数据类型 变量名 = 初始化值;
    
            //定义一个字节变量
            byte b = 10;
            System.out.println(10);
            System.out.println(b);
    
            //定义一个短整型变量
            short s = 100;
            System.out.println(s);
    
            //定义一个整型变量
            int i = 1000;
            System.out.println(i);
    
            //超过了int的范围
            //int j = 1000000000000;
            long j = 1000000000000L;
            //long j = 100L;
            System.out.println(j);
    
            //定义浮点数据变量
            float f = 12.345F;
            System.out.println(f);
    
            double d = 12.345;
            System.out.println(d);
    
            //定义字符变量
            char ch = 'a';
            System.out.println(ch);
    
            //定义布尔变量
            boolean flag = true;
            System.out.println(flag);
        }
    }
    

    运行结果:

     

    6.1.4 使用变量的时候要注意的问题:

     

    A:作用域
    变量定义在哪个大括号内,它就在这个大括号内有效。
    并且,在同一个大括号内不能同时定义同名的变量。

    B:初始化值
     没有初始化值的变量不能直接使用。
     你只要在使用前给值就行,不一定非要在定义的时候立即给值。
     推荐在定义的时候给值。

    定义变量的格式:       
       a:数据类型 变量名 = 初始化值;      
       b:数据类型 变量名;    
       变量名 = 初始化值;


    C:在一行上建议只定义一个变量        
       可以定义多个,但是不建议

    6.2 类型转换

    当把一种数据类型的值赋给另一种数据类型的变量时,需要进行数据类型转换。

    根据转换方式的不同,数据类型转换可分为两种:自动类型转换和强制类型转换。

    6.2.2 默认转换(从小到大的转换)

    自动类型转换也叫隐式类型转换,指的是两种数据类型在转换的过程中不需要显式地进行声明。

    要实现自动类型转换,必须同时满足两个条件,

    • 第一是两种数据类型彼此兼容,

    • 第二是目标类型的取值范围大于源类型的取值范围。

    (1)整数类型之间可以实现转换,如byte类型的数据可以赋值给short、int、long类型的变量,short、char类型的数据可以赋值给int、long类型的变量,int类型的数据可以赋值给long类型的变量
    (2)整数类型转换为float类型,如byte、char、short、int类型的数据可以赋值给float类型的变量。
    (3)其它类型转换为double类型,如byte、char、short、int、long、float类型的数据可以赋值给double类型的变量。

    A:byte,short,char—int—long—float—double

    B:byte,short,char相互之间不转换,他们参与运算首先转换为int类型

    6.2.2 强制转换:

    强制类型转换也叫显式类型转换,指的是两种数据类型之间的转换需要进行显式地声明。

    当两种类型彼此不兼容,或者目标类型取值范围小于源类型时,自动类型转换无法进行,这时就需要进行强制类型转换。

    从大的数据类型到小的数据类型
    格式:目标数据类型 变量 = (目标数据类型) (被转换的数据);
    注意:不要随意的去使用强制转换,因为它隐含了精度损失问题

    /*
        面试题:
            byte b1=3,b2=4,b;
            b=b1+b2;
            b=3+4;
            哪句是编译失败的呢?为什么呢?
            b = b1 + b2;是有问题的。
            因为变量相加,会首先看类型问题,最终把结果赋值的也会考虑类型问题。
            常量相加,首先做加法,然后看结果是否在赋值的数据类型范围内,如果不是,才报错。
    */
    class DataTypeDemo6 {
        public static void main(String[] args) {
            //定义了三个byte类型的变量,b1,b2,b3
            //b1的值是3,b2的值是4,b没有值
            byte b1 = 3,b2 = 4,b;
    
            //b = b1 + b2; //这个是类型提升,所有有问题
    
            b = 3 + 4; //常量,先把结果计算出来,然后看是否在byte的范围内,如果在就不报错。
        }
    }
    

    1、在定义Long或者Float类型变量的时候,要加L或者f。

    • 整数默认是int类型,浮点数默认是double。

    • byte,short在定义的时候,他们接收的其实是一个int类型的值。

    • 这个是自己做了一个数据检测的,如果不再它们的范围内,就报错。

    2、byte值的问题

    byte b1 = 127;
    byte b2 = (byte)128; //-128
    byte b3 = (byte)129; //-127
    byte b4 = (byte)130; //-126
    byte的范围:-128 ~ 127
    128:10000000
    -128:10000000 (这里的1即是符号位,也是数值位)
    

    3、数据类型转换之默认转换
     byte,short,char -- int -- long -- float -- double
     long:8个字节
     float:4个字节
     A:它们底层的存储结构不同
     B:float表示的数据范围比long的范围要大
       long:2^63-1
       float:3.4*10^38 > 2*10^38 > 2*8^38 = 2*2^3^38 = 2*2^114 > 2^63-1

    4、Java语言中的字符char可以存储一个中文汉字吗?为什么呢?        
    可以。因为java语言中的字符占用两个字节。Java语言采用的是Unicode编码。

    参考地址:https://github.com/JackChan1999/Java_Basic_Introduction

    更多好文

    java精品入门-0基础第一篇

    JDK、JRE、JVM的区别与联系

    亲,需要你的“分享”“在看”

    IT入门 感谢关注

    程序员题库→

    程序员用的单词表→

    练习地址:http://520mg.com/it/#/main/397

    展开全文
  • 、方法、成员变量和局部变量的可用修饰符 修饰符 成员访求 构造方法 成员变量 局部变量 abstract(抽象的) √ √ - - - static (静态的) - √ - √ - public(公共的) √ √ √ √ - ...

    一、总述

    类、方法、成员变量和局部变量的可用修饰符

    修饰符成员访求构造方法成员变量局部变量
    abstract(抽象的)
    static (静态的)
    public(公共的)
    protected(受保护的)
    private(私有的)
    synchronized(同步的)
    native(本地的)
    transient(暂时的)
    volatie(易失的)
    final(不要改变的)

    在这里插入图片描述
    在这里插入图片描述

    二、类修饰符

    访问修饰符:公共类修饰符public(只能是它)

    非访问控制符:抽象类修饰符 abstract 、最终类修饰符 final

    (1)公共类修饰符 public : Java 语言中类的访问控制符只有 public 即公共的。每个 Java 程序的有且只有一个类是 public,它被称为主类 ,其他外部类无访问控制修饰符,具有包访问性。注意:一个类的内部类可以被其他访问控制修饰符protected、default、 private修饰,相当于类的成员。

    (2)抽象类修饰符 abstract :用 abstract 修饰符修饰的类,被称为抽象类。

    (3)最终类修饰符 final :当一个类不能被继承时可用修饰符 final修饰为最终类。被定义为 final 的类通常是一些有固定作用、用来完成某种标准功能的类。final关键字不能用来抽象类和接口

    (4)类缺省访问控制符:如果一个类没有访问控制符,说明它具有缺省的访问控制符特性。此时,这个类只能被同一个包中的类访问或引用。这一访问特性又称为包访问性。

    1、如果一个类包含抽象方法(用abstract修饰的方法),那么这个类必须是抽象类

    2、继承抽象类的子类必须重写父类所有的抽象方法(用abstract修饰的方法)。否则,该子类也必须声明为抽象类(也必须用abstract修饰)。最终,必须有子类实现该父类的抽象方法,否则,从最初的父类到最终的子类都不能创建对象,失去意义。

    接口通常是不带修饰符的,一般都是public interface

    以上是对于外部类,外部类只能用public、adstract、final修饰,如果是内部类类则可以用 修饰成员变量的修饰符修饰内部类,比如 private, static, protected 修饰。

    三、方法修饰符

    1、按修饰符分

    访问控制修饰符:公共访问控制符public、保护访问控制符protected、缺省默认default、私有访问控制符private

    非访问控制符:抽象方法控制符abstract 、静态方法控制符static 、最终方法控制符final 、本地方法控制符native 、同步方法控制符synchronized

    (1)抽象方法控制符 abstract :用修饰符 abstract 修饰的方法称为抽象方法。抽象方法仅有方法头,没有方法体和操作实现。

    (2)静态方法控制符 static :用修饰符 static 修饰的方法称为静态方法。静态方法是属于整个类的类方法;而不使用static 修饰、限定的方法是属于某个具体类对象的方法。 由于 static方法是属于整个类的,所以它不能操纵和处理属于某个对象的成员变量,而只能处理属于整个类的成员变量,即 static 方法只能处理 static的域。

    (3)最终方法控制符 final :用修饰符 final修饰的方法称为最终方法。最终方法是功能和内部语句不能更改的方法,即最终方法不能重写覆盖(可以被继承)。final固定了方法所具有的功能和操作,防止当前类的子类对父类关键方法的错误定义,保证了程序的安全性和正确性。所有被 private 修饰符限定为私有的方法,以及所有包含在 final 类 ( 最终类) 中的方法,都被认为是最终方法。

    (4)本地方法控制符 native :用修饰符 native 修饰的方法称为本地方法。为了提高程序的运行速度,需要用其它的高级语言书写程序的方法体,那么该方法可定义为本地方法用修饰符 native 来修饰。

    (5)同步方法控制符 synchronized :该修饰符主要用于多线程程序中的协调和同步。

    2、类的方法

    类成员的访问控制符:即类的方法和成员变量的访问控制符

    一个类作为整体对象不可见,并不代表他的所有域和方法也对程序其他部分不可见,需要有他们的访问修饰符判断。权限如下:

    访问修饰符同一个类同包不同包,子类不同包,非子类
    public
    protected
    默认(default)
    private

    (1)构造方法

    构造方法只能用public(所有的类访问)、protected(只能自己和子类访问)、private(只能在本类访问),而不能是abstract, static, final, native, strictfp, 或者synchronized的。原因如下:

    1. 构造器不是通过继承得到的,所以没有必要把它声明为final的。
    2. 同理,一个抽象的构造器将永远不会被实现。(所以也不能声明为abstract的)
    3. 构造器总是关联一个对象而被调用,所以把它声明为static是没有意义的。
    4. 没有实际的需要把构造器定义成同步的,因为它将会在构造的时候锁住该对象,直到所有的构造器完成它们的工作,这个构造的过程对其它线程来说,通常是不可访问的。 (synchronized)
    5. 本地化的方法情况特别复杂,所以JVM调用起来非常麻烦,需要考虑很多种情况,没有native关键字的情况下,JVM实现起来比较容易。

    (2)类方法(静态方法)

    类方法:使用static关键字说明的方法(与实例方法区分:是否用static修饰)

    1.系统只为该类创建一个版本,这个版本被该类和该类的所有实例共享。

    2.类方法只能操作类变量,不能访问实例变量。类方法可以在类中被调用,不必创建实例来调用,当然也可以通过对象来调用。

    3.静态方法可以直接访问类变量(静态成员变量)和静态方法。

    解释:因为静态方法在加载类的时候就被调用了

    4.静态方法不能直接访问普通成员变量或成员方法。反之,成员方法可以直接访问类变量(静态成员变量)或静态方法。

    普通成员变量或成员方法只有在创建对象的时候才会被创建,而静态方法在加载类的时候就被加载了,那时候还没有对象,更不必谈在静态方法中访问其中的普通成员变量和成员方法了

    5.静态方法中,不能使用this关键字。

    (3)成员方法

    • public(公共控制符)
    • private(私有控制符)指定此方法只能有自己类等方法访问,其他的类不能访问(包括子类)
    • protected(保护访问控制符)指定该方法可以被它的类和子类进行访问。
    • final,指定该方法不能被重载。
    • static,指定不需要实例化就可以激活的一个方法。
    • synchronize,同步修饰符,在多个线程中,该修饰符用于在运行前,对他所属的方法加锁,以防止其他线程的访问,运行结束后解锁。
    • native,本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。

    (4)抽象类的抽象方法

    抽象类中的抽象方法(其前有abstract修饰)不能用private、static、synchronized、native访问修饰符修饰。原因如下:

    1. 抽象方法没有方法体,是用来被继承的,所以不能用private修饰;
    2. static修饰的方法可以通过类名来访问该方法(即该方法的方法体),抽象方法用static修饰没有意义;
    3. 使用synchronized关键字是为该方法加一个锁。而如果该关键字修饰的方法是static方法。则使用的锁就是class变量的锁。如果是修饰类方法。则用this变量锁。但是抽象类不能实例化对象,因为该方法不是在该抽象类中实现的,是在其子类实现的。所以,锁应该归其子类所有。所以,抽象方法也就不能用synchronized关键字修饰了;
    4. native,这个东西本身就和abstract冲突,他们都是方法的声明,只是一个把方法实现移交给子类,另一个是移交给本地操作系统。如果同时出现,就相当于即把实现移交给子类,又把实现移交给本地操作系统,那到底谁来实现具体方法呢?

    3、接口的方法

    接口是一种特殊的抽象类,接口中的方法全部是抽象方法(但其前的abstract可以省略),所以抽象类中的抽象方法不能用的访问修饰符(private、static、synchronized、native)这里也不能用。而且protected访问修饰符也不能使用,因为接口可以让所有的类去实现(非继承),不只是其子类(比如如果实现类和接口不在同一个包内就会出现问题)。所以要用public去修饰,接口才可以被实现。

    默认写法:public abstract(默认不写)

    (1)静态方法(static)

    用static修饰的方法就是静态方法,静态方法必须要有实现体(一定要有花括号),并且静态方法是不能被实现类实现的,只能通过接口调用这个方法

    静态方法必须要有方法体,即一定要有花括号,是因为静态方法不能被实现类实现,但是接口的方法又必须全部被实现,所以矛盾,所以静态方法必须要有实现

    格式:public static 返回数据类型 方法名(参数列表){}

    省略了abstract

    (2)默认方法(default)

    default的加入就是为了解决接口中不能有默认方法的问题,在实现类中可以重写这个default方法也可以不重写

    default修饰的方法跟接口中的静态方法的区别就是default方法可以被实现类重写,这样就可以得到扩展并且不修改原来接口中功能,而静态方法就有点太苛刻了,还不如把静态方法写在实现类中,这样每个实现类都可以自己写自己的功能实现。

    格式:default 返回数据类型 方法名(){}

    (3)其他抽象方法

    四、变量修饰符

    1、类的成员变量修饰符

    一个类的成员变量的声明必须在类体中,而不能在方法中,方法中声明的是局部变量。

    public(公共访问控制符),指定该变量为公共的,他可以被任何对象的方法访问。

    private(私有访问控制符)指定该变量只允许自己的类的方法访问,其他任何类(包括子类)中的方法均不能访问。

    protected(保护访问控制符)指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。

    friendly ,在同一个包中的类可以访问,其他包中的类不能访问。

    final,最终修饰符,指定此变量的值不能变。

    static(静态修饰符)指定变量被所有对象共享,即所有实例都可以使用该变量。变量属于这个类。

    transient(过度修饰符)指定该变量是系统保留,暂无特别作用的临时性变量。

    volatile(易失修饰符)指定该变量可以同时被几个线程控制和修改。

    抽象类中变量的修饰符与一般类一致

    2、接口中的变量

    接口中的属性默认是public static final 的,(因为是final的,所以都是常量),只能读不能改

    public static final 可以省略不写

    1:public static final String name = “张三”;

    2:String name = “张三”;

    以上两种写法都可以

    public的话可以理解,需要被实现类使用

    如果是非static的话,因一个类可以多继承,容易出现重名导致编译错误

    接口的方法都是抽象的,可变的东西都应该归属到实现类中,这样接口才能起到标准化、规范化的作用,因此接口里的属性必须是不变的,即final的,可以不变实现类修改(如果能被实现类任意修改,接口就没有创建这个常量的必要了

    3、方法中的局部变量

    因为接口中的方法都是抽象方法,而抽象方法没有实现,即没有方法体。所以,只有一般类中的方法和抽象类中的非抽象方法才会有局部变量。

    方法中对于变量的修饰符只有两种:

    1、缺省(default):即什么都不写,这是一个普通的变量,必须为其设置初始值。
    2、final:表示变量值不可以被改变,即常量

    一般类和抽象类中的静态方法中的变量自动就是静态的,不需要加static

    五、常考修饰符

    1、final

    (1)修饰类

    • 该类不能被继承
    • final不能修饰抽象类和接口
    • final类中的方法不会被覆盖,因此默认都是final的
    • 用途:设计类时,如果该类不需要有子类,不必要被扩展,类的实现细节不允许被改变,那么就设计成final类

    (2)修饰方法

    • 该方法可以被继承,但是不能被覆盖
    • 用途:一个类不允许子类覆盖该方法,则用final来修饰
    • 好处:可以防止继承它的子类修改该方法的意义和实现;更为高效,编译器在遇到调用fianal方法转入内嵌机制,提高了执行效率
    • 父类中的private成员方法不能被子类覆盖,因此,父类的private方法默认是final型的(可以查看编译后的class文件)

    (3)修饰变量

    • 用final修饰后变为常量。包括静态变量、实例变量和局部变量这三种
    • **特点:**只能被赋一次值,必须被显示初始化。可以先声明,不给初值,这种叫做final空白。但是使用前必须被初始化。一旦被赋值,将不能再被改变。

    (4)修饰参数

    • 用final修饰参数时,可以读取该参数,但是不能对其作出修改

    2、static

    1、简介

    关于 static 关键字的使用,它可以用来修饰的成员变量和成员方法,被修饰的成员是属于类的,而不是单单是属 于某个对象的。也就是说,既然属于类,就可以不靠创建对象来调用了。

    2、定义和使用

    1)类变量当 static 修饰成员变量时,该变量称为类变量。

    该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值,但也可以在不创建该类的对象的情况下对类变量进行作。

    static变量也称作静态变量,静态变量和非静态变量的区别是:静态变量被所有的对象所共享,在内存中只有一个副本,它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的,在创建对象的时候被初始化,存在多个副本,各个对象拥有的副本互不影响。 static成员变量的初始化顺序按照定义的顺序进行初始化。

    定义格式:static 数据类型 变量名;举例:static int numberID;

    2)静态方法

    当 static 修饰成员方法时,该方法称为类方法 。

    静态方法在声明中有 static ,建议使用类名来调用,而不需要创建类的对象。调用方式非常简单。 类方法:使用 static关键字修饰的成员方法,习惯称为静态方法。 定义格式: 修饰符 static 返回值类型 方法名 (参数列表){ // 执行语句}

    调用格式:

    被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员,原因即多个对象均属 于一个类,共享使用同一个静态成员,但是不建议,会出现警告信息。

    3)静态代码块

    定义在成员位置,使用static修饰的代码块{ }。 位置:类中方法外。执行:随着类的加载而执行且执行一次,优先于main方法和构造方法的执行。

    3、注意事项:

    • 静态方法可以直接访问类变量和静态方法。
    • 静态方法不能直接访问普通成员变量或成员方法。
    • 反之,成员方法可以直接访问类变量或静态方法。
    • 静态方法中,不能使用this和super关键字。
    • 静态方法不能被abstract修饰
    • 静态方法和静态变量都可以通过类名直接被访问。
    • 当类被加载时,静态代码块只被执行一次。类中不同的静态代码块按它们在类中出现的顺序被依次执行

    static 关键字,可以修饰变量、方法和代码块。在使用的过程中,其主要目的还是想在不创建对象的情况

    3、注意事项:

    • 静态方法可以直接访问类变量和静态方法。
    • 静态方法不能直接访问普通成员变量或成员方法。
    • 反之,成员方法可以直接访问类变量或静态方法。
    • 静态方法中,不能使用this和super关键字。
    • 静态方法不能被abstract修饰
    • 静态方法和静态变量都可以通过类名直接被访问。
    • 当类被加载时,静态代码块只被执行一次。类中不同的静态代码块按它们在类中出现的顺序被依次执行

    static 关键字,可以修饰变量、方法和代码块。在使用的过程中,其主要目的还是想在不创建对象的情况

    展开全文
  • 类型类型表明了具有某种共同特性的事物抽象特征。字符类型char通常用来存储字符数据,如字母 ‘a’, ‘b’等。整型类型int用于存储正整数、负整数等,如1234,-965等。浮点类型float用于存储带小数据点的数据,如...
  • java 第四章 与对象

    千次阅读 2017-12-02 18:33:39
    是java语言中最重要的“数据类型”,声明的变量称作对象变量,简称对象。是对象的模板,没有就没有对象。 3. 的定义包括两部分:声明和体。基本格式为:  class 类名{ 体的内容 } 4. 如果类名...
  • C++和对象(下)——初始化列表、static成员和友元

    千次阅读 多人点赞 2021-03-08 09:23:18
    C++和对象——初始化列表、static成员和友元一、再谈构造函数1.1 构造函数整体...在创建对象时,编译器通过调用构造函数,给对象中各个成员变量一个合适的初始值。例如我们之前创建的Date class Date { public: D
  • 主要给大家介绍了关于Java中的定义与实例化的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用Java具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • Arduino 变量语法详解(含示例)一

    万次阅读 多人点赞 2019-01-31 21:58:17
    一、常量 1.1 HIGH | LOW(引脚电压定义) 1.2 INPUT | OUTPUT(数字引脚(Digital pins)定义) 1.3 true | false(逻辑层定义) ...二、数据类型 2.1 void 2.2 boolean(布尔) 2.3 char(有号数...
  • 自由变量

    千次阅读 2021-03-17 20:58:15
    在函数内声明的变量具有函数作用域,属于局部变量,就是在函数内部定义的变量, 只在函数内部有用,所以是局部作用域。 3,ES6的定义的块级作用域 声明变量的方法 有var let const var 声明的变量可以变量提升 变量
  • JavaScript的数据类型分为两:原始类型(primitive type)和对象类型(object typt)。 原始类型包括数字、字符串和布尔值。null(空)和undefined(未定义)是两个特殊的原始值,它们通常分别代表了各自特殊类型...
  • 可用于变量名的有哪几?求解答1,变量名必需由字母、数字、下划线组成。2,首字符串无法是数字Java将视作同一个函数,太长会被Java截取前面的,无法太长,明确长度限制由Java设定,在Java可辨识的范围完全相同,...
  • 本篇博客为你带来 python 中的小技巧,学会就能提高效率。 魔法方法 __str__ 和 __repr__ __str__:当出现将对象转换为字符串时,会调用这个方法。 __repr__: 这两个方法需要对比学习,因为其功能十分类似。 ...
  • 第四章 与对象 4.1 编程言语的几个发展阶段 1、面向机器语言 用诸如100011110110100这样的指令序列来编写 2、面向过程语言 采用自顶向下、逐步求精的程序设计方法,使用三种基本控制结构构造程序,即任何程序都...
  • 熟悉掌握vb中变量常数和数据类型及过程对编程有相当大的帮助,此文件中的概述是比较全的
  • 以上一句话对变量a进行了声明,定义以及初始化extern int a;以上一句话仅仅对变量a进行了声明,将a的链接属性设置为externalint *p;以上定义了一个指针int a=10;int *p;p=&a;以上为指针变量进行了赋值说明:首先...
  • 上一小节,我们了解到了关于...指针变量具有指针类型变量,被成为指针变量,其定义形式如下: 类型关键字 *指针变量类型关键字代表指针变量要指向的变量类型,即指针变量类型(举个例子) int *pa; .
  • 当程序需要将值保存起来以备将来使用时,便将其赋值给一个变量,值的类型称作数据类型变量JavaScript 的变量是松散类型的,所谓松散类型就是可以用来保存任何类型的数据。换句话说,每个变量仅仅是一个用于保存值...
  • JAVA_关于构造方法与中静态变量

    千次阅读 2016-04-03 23:08:00
    打算从今天开始记下学习JAVA过程中遇到的一些问题,同时万一我就帮助了某些还不明所以的小伙伴,另外哪里有问题欢迎指出,我会更马上更改,...是面向对象语言中最重要的一种数据类型,可以用来声明变量。在面向对
  • 由static关键字修饰的变量、常量和方法被称作静态变量、静态常量和静态方法。还可以用static来修饰代码块,static修饰的代码块叫静态代码块。 静态变量、静态常量和静态方法称为静态成员。静态成员属于所有,...
  • python:基础

    万次阅读 多人点赞 2018-06-17 01:14:53
    1、面向对象编程(oop)是一种程序设计思想。oop把对象作为程序的基本单元,一个对象包含数据和操作数据的函数2、在python中,所有数据类型都被视为对象,也可以...类变量通常不作为实例变量使用,类变量称作属性4、数
  • JavaScript——变量的声明与赋值

    千次阅读 2020-05-24 11:05:06
    这里的变量和数学中的x,y代表的含义是相同的,它们同时具有以下几个相同的功能。 假装一个未知的数 存储一个值 参与运算和编辑 所以,将具有这些功能的一个未知数称为变量。 关键字与保留字 对于数学中的变量来说...
  • Java中的抽象和接口

    千次阅读 多人点赞 2022-04-08 15:17:42
    各位铁汁们大家好呀!今天让我们继续学习java,看看java中的抽象和接口到底是什么? 里面也会讲到多态呀,一起来看看吧
  • java介绍

    千次阅读 2016-01-31 20:36:03
    是Java语言中最重要的“数据类型”,声明的变量被称为对象,即是用来创建对象的模板。 class 类名 { 体的内容 } class 是关键字,用来定义。 “class People” 为声明。 注意:1、首字母大写 2、写...
  • 计算机语言分类

    千次阅读 2021-12-14 20:38:25
    1计算机语言三大(按层次分) 与硬件的相关度逐步下降 计算机语言有很多种类,根据功能和实现方式的不同大致可分为3大,即机器语言汇编语言和高级语言。 1、机器语言,计算机不需要翻译就能直接识别的语言被...
  • Python基础之:Python中的

    千次阅读 2021-04-02 08:48:37
    文章目录 简介 作用域和命名空间 class 对象 的实例 实例对象的属性 方法对象 类变量和实例变量 继承 私有变量 迭代器 生成器 简介 class是面向对象编程的一个非常重要的概念,python中也有class,并且支持面向...
  • 在讲解变量类型之前,我们先来看一个生活中的例子,例如,我们要运送一台电脑,大卡车和小轿车都可以完成,但是,如果使用大卡车运送一台电脑,显然有点小题大做,浪费了大卡车的空间,如图1所示。图1 卡车和轿车...
  • JS 基础之全局变量,局部变量

    千次阅读 2018-08-23 09:56:29
    本章将概要介绍一些编写高质量JavaScript的最佳实践、模式和习惯,比如避免全局变量、使用单var声明、预缓存循环中的length、遵守编码约定等等。本章还包括一些编程习惯,这些习惯跟具体的代码关系不大,而是更多...
  • 【C++】C++和对象、构造函数和析构函数

    千次阅读 多人点赞 2018-06-03 20:32:37
    是对某一事物的抽象描述,具体地讲,是C++中的一种构造的数据类型。它即可包含描述事物的数据,又可包含处理这些数据的函数,在程序运行时是被用作样板来建立对象的。所以要建立对象,首先必须定义。 定义...
  • 第4章 与对象

    千次阅读 2019-12-19 19:28:37
     构造方法与对象的创建  与程序的基本结构 重点与难点:  重点:Java的语法规则、构造方法与对象的创建。  难点:对象的创建过程,对象引用与实体的关系、理解的封装。 4.1.1 面向机器语言 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 53,742
精华内容 21,496
关键字:

具有类类型的变量称作

友情链接: fs.rar