java-基本概念

时间  2019-11-16
标签 java 基本概念 栏目 Java 繁體版
原文   原文链接

 IDEA旗舰版破解教程：http://www.javashuo.com/article/p-nwptovnj-nh.html

 

【破解jar更新，若失败请评论联系我更新jar包。java

连接: https://pan.baidu.com/s/1z-5EUttHd2fbzBRSFb_Muw 提取码: k3up 复制这段内容后打开百度网盘手机App，操做更方便哦 】程序员

在 hosts 文件里面添加以下配置绕过联网校验编程

0.0.0.0 account.jetbrains.com
0.0.0.0 www.jetbrains.com
 ubuntu

以前写过一片idea永久破解的方法，可是最新的2019.1版本好像不能用了，如今更新一下破解方法。其实和以前相似。vim

安装什么的就再不赘述了，直接进入正题。数组

1、先下载破解jar包 Jetbrains-agent.jar，直接放在了安装目录的bin下，我这里是D:\software\java\ideaIU2019.1\bin （事实上是放在那里都行，我这里放在bin下好管理）安全

2、安装好后，直接打开idea，选择试用。（这里是跟以前不同的一点，修改配置文件时：不能直接在bin目录下直接修改，必须先打开idea试用30天，而后在idea里修改配置文件）bash

 

3、随便建立一个空项目后，进入idea界面。点击IDE菜单的：“Help”而后点击  “Edit Custom VM Options”，若是提示是否要建立文件，请点"是|Yes"。而后在打开的vmoptions编辑窗口末行添加：-javaagent:"Jetbrains-agent.jar文件的绝对路径"（必定要本身确认好路径，填错会致使IDE打不开！！！）  好比个人是 -javaagent:D:\software\java\ideaIU2019.1\bin \Jetbrains-agent.jar。网络

保险起见将bin目录下idea.exe.vmoptions 和 idea64.exe.vmoptions 这两个文件末尾也添加该配置。多线程

编辑好后，保存，退出，重启idea。

修改完配置文件以后重启

若是错误则会出现打不开的状况，这时候能够删除用户配置目录（C:\Users\你的用户名）下的.idea文件夹，从新操做！！！

4、重启后。再次点击 idea菜单栏 的 "Help" -> “Register”，选择License server方式，地址填入：http://jetbrains-license-server

 

而后再次重启，当重启时看到以下图的 Licensed to （你本身的电脑用户名），就是激活成功了。

 

安装java：

一、下载java安装包（ubuntu系统）

二、新建目录：mkdir /usr/java，将安装包解压到该目录下

三、修改配置文件:vim /etc/profile 添加java的环境变量

JAVA_HOME=/usr/java/jdk-12
CLASSPATH=$JAVA_HOME/lib/
PATH=$PATH:$JAVA_HOME/bin
export PATH JAVA_HOME CLASSPATH

四、修改用户目录下的bashrc文件：vim ~/.bashrc　　添加java环境变量：export JAVA_HOME=/usr/java/jdk-12

五、重启电脑或者重启服务：source /etc/profile　　source ~/.bashrc

 

注意：

一、java的编译环境javac不能高于运行环境java，因此下载jdk版本的时候要注意和系统的兼容性。

二、若是出现编码错误，记得在javac 后面加-encoding utf-8这个参数，执行java的时候不用加编码参数了

 

主要特性

  • Java语言是简单的：

    Java语言的语法与C语言和C++语言很接近，使得大多数程序员很容易学习和使用。另外一方面，Java丢弃了C++中不多使用的、很难理解的、使人迷惑的那些特性，如操做符重载、多继承、自动的强制类型转换。特别地，Java语言不使用指针，而是引用。并提供了自动的废料收集，使得程序员没必要为内存管理而担心。

  • Java语言是面向对象的：

    Java语言提供类、接口和继承等面向对象的特性，为了简单起见，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为implements）。Java语言全面支持动态绑定，而C++语言只对虚函数使用动态绑定。总之，Java语言是一个纯的面向对象程序设计语言。

  • Java语言是分布式的：

    Java语言支持Internet应用的开发，在基本的Java应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包括URL、URLConnection、Socket、ServerSocket等。Java的RMI（远程方法激活）机制也是开发分布式应用的重要手段。

  • Java语言是健壮的：

    Java的强类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证。对指针的丢弃是Java的明智选择。Java的安全检查机制使得Java更具健壮性。

  • Java语言是安全的：

    Java一般被用在网络环境中，为此，Java提供了一个安全机制以防恶意代码的攻击。除了Java语言具备的许多安全特性之外，Java对经过网络下载的类具备一个安全防范机制（类ClassLoader），如分配不一样的名字空间以防替代本地的同名类、字节代码检查，并提供安全管理机制（类SecurityManager）让Java应用设置安全哨兵。

  • Java语言是体系结构中立的：

    Java程序（后缀为java的文件）在Java平台上被编译为体系结构中立的字节码格式（后缀为class的文件），而后能够在实现这个Java平台的任何系统中运行。这种途径适合于异构的网络环境和软件的分发。

  • Java语言是可移植的：

    这种可移植性来源于体系结构中立性，另外，Java还严格规定了各个基本数据类型的长度。Java系统自己也具备很强的可移植性，Java编译器是用Java实现的，Java的运行环境是用ANSI C实现的。

  • Java语言是解释型的：

    如前所述，Java程序在Java平台上被编译为字节码格式，而后能够在实现这个Java平台的任何系统中运行。在运行时，Java平台中的Java解释器对这些字节码进行解释执行，执行过程当中须要的类在联接阶段被载入到运行环境中。

  • Java是高性能的：

    与那些解释型的高级脚本语言相比，Java的确是高性能的。事实上，Java的运行速度随着JIT(Just-In-Time）编译器技术的发展愈来愈接近于C++。

  • Java语言是多线程的：

    在Java语言中，线程是一种特殊的对象，它必须由Thread类或其子（孙）类来建立。一般有两种方法来建立线程：其一，使用型构为Thread(Runnable)的构造子类将一个实现了Runnable接口的对象包装成一个线程，其二，从Thread类派生出子类并重写run方法，使用该子类建立的对象即为线程。值得注意的是Thread类已经实现了Runnable接口，所以，任何一个线程均有它的run方法，而run方法中包含了线程所要运行的代码。线程的活动由一组方法来控制。Java语言支持多个线程的同时执行，并提供多线程之间的同步机制（关键字为synchronized）。

  • Java语言是动态的：

    Java语言的设计目标之一是适应于动态变化的环境。Java程序须要的类可以动态地被载入到运行环境，也能够经过网络来载入所须要的类。这也有利于软件的升级。另外，Java中的类有一个运行时刻的表示，能进行运行时刻的类型检查。

基本语法

编写Java程序时，应注意如下几点：

  • 大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不一样的。
  • 类名：对于全部的类来讲，类名的首字母应该大写。若是类名由若干单词组成，那么每一个单词的首字母应该大写，例如 MyFirstJavaClass 。
  • 方法名：全部的方法名都应该以小写字母开头。若是方法名含有若干单词，则后面的每一个单词首字母大写。
  • 源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名做为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。（若是文件名和类名不相同则会致使编译错误）。
  • 主方法入口：全部的Java 程序由public static void main(String []args)方法开始执行。

 

Java标识符

Java全部的组成部分都须要名字。类名、变量名以及方法名都被称为标识符。

关于Java标识符，有如下几点须要注意：

  • 全部的标识符都应该以字母（A-Z或者a-z）,美圆符（$）、或者下划线（_）开始
  • 首字符以后能够是字母（A-Z或者a-z）,美圆符（$）、下划线（_）或数字的任何字符组合
  • 关键字不能用做标识符
  • 标识符是大小写敏感的
  • 合法标识符举例：age、$salary、_value、__1_value
  • 非法标识符举例：123abc、-salary

接口

在Java中，接口可理解为对象间相互通讯的协议。接口在继承中扮演着很重要的角色。

接口只定义派生要用到的方法，可是方法的具体实现彻底取决于派生类。

 

Java中的对象

 

如今让咱们深刻了解什么是对象。看看周围真实的世界，会发现身边有不少对象，车，狗，人等等。全部这些对象都有本身的状态和行为。

拿一条狗来举例，它的状态有：名字、品种、颜色，行为有：叫、摇尾巴和跑。

对比现实对象和软件对象，它们之间十分类似。

软件对象也有状态和行为。软件对象的状态就是属性，行为经过方法体现。

在软件开发中，方法操做对象内部状态的改变，对象的相互调用也是经过方法来完成。

 

Java中的类

类能够当作是建立Java对象的模板。

一个类能够包含如下类型变量：

  • 局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
  • 成员变量：成员变量是定义在类中，方法体以外的变量。这种变量在建立对象的时候实例化。成员变量能够被类中方法、构造方法和特定类的语句块访问。
  • 类变量：类变量也声明在类中，方法体以外，但必须声明为static类型。

一个类能够拥有多个方法，在上面的例子中：barking()、hungry()和sleeping()都是Dog类的方法。

 

构造方法

每一个类都有构造方法。若是没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。

在建立一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类能够有多个构造方法。

下面是一个构造方法示例：

public class Puppy{
    public Puppy(){
    }
 
    public Puppy(String name){
        // 这个构造器仅有一个参数：name
    }
}

建立对象

对象是根据类建立的。在Java中，使用关键字new来建立一个新的对象。建立对象须要如下三步：

  • 声明：声明一个对象，包括对象名称和对象类型。
  • 实例化：使用关键字new来建立一个对象。
  • 初始化：使用new建立对象时，会调用构造方法初始化对象。

下面是一个建立对象的例子：

public class Puppy{
   public Puppy(String name){
      //这个构造器仅有一个参数：name
      System.out.println("小狗的名字是 : " + name ); 
   }
   public static void main(String[] args){
      // 下面的语句将建立一个Puppy对象
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

 

源文件声明规则

在本节的最后部分，咱们将学习源文件的声明规则。当在一个源文件中定义多个类，而且还有import语句和package语句时，要特别注意这些规则。

  • 一个源文件中只能有一个public类
  • 一个源文件能够有多个非public类
  • 源文件的名称应该和public类的类名保持一致。例如：源文件中public类的类名是Employee，那么源文件应该命名为Employee.java。
  • 若是一个类定义在某个包中，那么package语句应该在源文件的首行。
  • 若是源文件包含import语句，那么应该放在package语句和类定义之间。若是没有package语句，那么import语句应该在源文件中最前面。
  • import语句和package语句对源文件中定义的全部类都有效。在同一源文件中，不能给不一样的类不一样的包声明。

类有若干种访问级别，而且类也分不一样的类型：抽象类和final类等。这些将在访问控制章节介绍。

除了上面提到的几种类型，Java还有一些特殊的类，如：内部类、匿名类。

 

Java包

包主要用来对类和接口进行分类。当开发Java程序时，可能编写成百上千的类，所以颇有必要对类和接口进行分类。

 

Java 基本数据类型

变量就是申请内存来存储值。也就是说，当建立变量的时候，须要在内存中申请空间。

内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来储存该类型数据。

所以，经过定义不一样类型的变量，能够在内存中储存整数、小数或者字符。

Java 的两大数据类型:

  • 内置数据类型
  • 引用数据类型

内置数据类型

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

byte：

  • byte 数据类型是8位、有符号的，以二进制补码表示的整数；
  • 最小值是 -128（-2^7）；
  • 最大值是 127（2^7-1）；
  • 默认值是 0；
  • byte 类型用在大型数组中节约空间，主要代替整数，由于 byte 变量占用的空间只有 int 类型的四分之一；
  • 例子：byte a = 100，byte b = -50。

short：

  • short 数据类型是 16 位、有符号的以二进制补码表示的整数
  • 最小值是 -32768（-2^15）；
  • 最大值是 32767（2^15 - 1）；
  • Short 数据类型也能够像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
  • 默认值是 0；
  • 例子：short s = 1000，short r = -20000。

int：

  • int 数据类型是32位、有符号的以二进制补码表示的整数；
  • 最小值是 -2,147,483,648（-2^31）；
  • 最大值是 2,147,483,647（2^31 - 1）；
  • 通常地整型变量默认为 int 类型；
  • 默认值是 0 ；
  • 例子：int a = 100000, int b = -200000。

long：

  • long 数据类型是 64 位、有符号的以二进制补码表示的整数；
  • 最小值是 -9,223,372,036,854,775,808（-2^63）；
  • 最大值是 9,223,372,036,854,775,807（2^63 -1）；
  • 这种类型主要使用在须要比较大整数的系统上；
  • 默认值是 0L；
  • 例子： long a = 100000L，Long b = -200000L。
    "L"理论上不分大小写，可是若写成"l"容易与数字"1"混淆，不容易分辩。因此最好大写。

float：

  • float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
  • float 在储存大型浮点数组的时候可节省内存空间；
  • 默认值是 0.0f；
  • 浮点数不能用来表示精确的值，如货币；
  • 例子：float f1 = 234.5f。

double：

  • double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
  • 浮点数的默认类型为double类型；
  • double类型一样不能表示精确的值，如货币；
  • 默认值是 0.0d；
  • 例子：double d1 = 123.4。

boolean：

  • boolean数据类型表示一位的信息；
  • 只有两个取值：true 和 false；
  • 这种类型只做为一种标志来记录 true/false 状况；
  • 默认值是 false；
  • 例子：boolean one = true。

char：

    • char类型是一个单一的 16 位 Unicode 字符；
    • 最小值是 \u0000（即为0）；
    • 最大值是 \uffff（即为65,535）；
    • char 数据类型能够储存任何字符；
    • 例子：char letter = 'A';。

实际上，JAVA中还存在另一种基本类型void，它也有对应的包装类 java.lang.Void，不过咱们没法直接对它们进行操做。

引用类型

  • 在Java中，引用类型的变量很是相似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，好比 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
  • 对象、数组都是引用数据类型。
  • 全部引用类型的默认值都是null。
  • 一个引用变量能够用来引用任何与之兼容的类型。
  • 例子：Site site = new Site("Runoob")。

Java 常量

常量在程序运行时是不能被修改的。

在 Java 中使用 final 关键字来修饰常量，声明方式和变量相似：

final double PI = 3.1415927;

　　

虽然常量名也能够用小写，但为了便于识别，一般使用大写字母表示常量。

字面量能够赋给任何内置类型的变量。

byte a = 68;
char a = 'A'

　　

byte、int、long、和short均可以用十进制、16进制以及8进制的方式来表示。

当使用常量的时候，前缀 0 表示 8 进制，而前缀 0x 表明 16 进制, 

int decimal = 100;
int octal = 0144;
int hexa =  0x64;

和其余语言同样，Java的字符串常量也是包含在两个引号之间的字符序列。下面是字符串型字面量的例子：

"Hello World"
"two\nlines"
"\"This is in quotes\""

字符串常量和字符常量均可以包含任何Unicode字符。例如：

char a = '\u0001';
String a = "\u0001";

Java语言支持一些特殊的转义字符序列。

符号	字符含义
\n	换行 (0x0a)
\r	回车 (0x0d)
\f	换页符(0x0c)
\b	退格 (0x08)
\0	空字符 (0x20)
\s	字符串
\t	制表符
\"	双引号
\'	单引号
\\	反斜杠
\ddd	八进制字符 (ddd)
\uxxxx	16进制Unicode字符 (xxxx)

自动类型转换

整型、实型（常量）、字符型数据能够混合运算。运算中，不一样类型的数据先转化为同一类型，而后进行运算。

转换从低级到高级。

数据类型转换必须知足以下规则：

  • 1. 不能对boolean类型进行类型转换。

  • 2. 不能把对象类型转换成不相关类的对象。

  • 3. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。

  • 4. 转换过程当中可能致使溢出或损失精度，

  • 5. 浮点数到整数的转换是经过舍弃小数获得，而不是四舍五入

自动类型转换

必须知足转换前的数据类型的位数要低于转换后的数据类型，例如: short数据类型的位数为16位，就能够自动转换位数为32的int类型，一样float数据类型的位数为32，能够自动转换为64位的double类型。

public class ZiDongLeiZhuan{
        public static void main(String[] args){
            char c1='a';//定义一个char类型
            int i1 = c1;//char自动类型转换为int
            System.out.println("char自动类型转换为int后的值等于"+i1);
            char c2 = 'A';//定义一个char类型
            int i2 = c2+1;//char 类型和 int 类型计算
            System.out.println("char类型和int计算后的值等于"+i2);
        }
}

运行结果：
char自动类型转换为int后的值等于97
char类型和int计算后的值等于66
解析：c1 的值为字符 a ,查 ASCII 码表可知对应的 int 类型值为 97， A 对应值为 65，因此 i2=65+1=66。

　　

强制类型转换

  • 1. 条件是转换的数据类型必须是兼容的。

  • 2. 格式：(type)value type是要强制类型转换后的数据类型 实例：

    public class QiangZhiZhuanHuan{
    public static void main(String[] args){
        int i1 = 123;
        byte b = (byte)i1;//强制类型转换为byte
        System.out.println("int强制类型转换为byte后的值等于"+b);
    }
}
    运行结果：
    int强制类型转换为byte后的值等于123

    　　

隐含强制类型转换

  • 1. 整数的默认类型是 int。

  • 2. 浮点型不存在这种状况，由于在定义 float 类型时必须在数字后面跟上 F 或者 f。

Java 变量类型

在Java语言中，全部的变量在使用前必须声明。声明变量的基本格式以下：

int a, b, c;         // 声明三个int型整数：a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22;         // 声明并初始化 z
String s = "runoob";  // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x';        // 声明变量 x 的值是字符 'x'。

Java语言支持的变量类型有：

  • 类变量：独立于方法以外的变量，用 static 修饰。
  • 实例变量：独立于方法以外的变量，不过没有 static 修饰。
  • 局部变量：类的方法中的变量。
public class Variable{
    static int allClicks=0;    // 类变量
 
    String str="hello world";  // 实例变量
 
    public void method(){
 
        int i =0;  // 局部变量
 
    }
}

 

Java 局部变量

  • 局部变量声明在方法、构造方法或者语句块中；
  • 局部变量在方法、构造方法、或者语句块被执行的时候建立，当它们执行完成后，变量将会被销毁；
  • 访问修饰符不能用于局部变量；
  • 局部变量只在声明它的方法、构造方法或者语句块中可见；
  • 局部变量是在栈上分配的。
  • 局部变量没有默认值，因此局部变量被声明后，必须通过初始化，才可使用。
package com.runoob.test;
 
public class Test{ 
   public void pupAge(){
      int age = 0;
      age = age + 7;
      System.out.println("小狗的年龄是: " + age);
   }
   
   public static void main(String[] args){
      Test test = new Test();
      test.pupAge();
   }
}

实例变量

  • 实例变量声明在一个类中，但在方法、构造方法和语句块以外；
  • 当一个对象被实例化以后，每一个实例变量的值就跟着肯定；
  • 实例变量在对象建立的时候建立，在对象被销毁的时候销毁；
  • 实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部可以经过这些方式获取实例变量信息；
  • 实例变量能够声明在使用前或者使用后；
  • 访问修饰符能够修饰实例变量；
  • 实例变量对于类中的方法、构造方法或者语句块是可见的。通常状况下应该把实例变量设为私有。经过使用访问修饰符可使实例变量对子类可见；
  • 实例变量具备默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值能够在声明时指定，也能够在构造方法中指定；
  • 实例变量能够直接经过变量名访问。但在静态方法以及其余类中，就应该使用彻底限定名：ObejectReference.VariableName。
import java.io.*;
public class Employee{
   // 这个实例变量对子类可见
   public String name;
   // 私有变量，仅在该类可见
   private double salary;
   //在构造器中对name赋值
   public Employee (String empName){
      name = empName;
   }
   //设定salary的值
   public void setSalary(double empSal){
      salary = empSal;
   }  
   // 打印信息
   public void printEmp(){
      System.out.println("名字 : " + name );
      System.out.println("薪水 : " + salary);
   }
 
   public static void main(String[] args){
      Employee empOne = new Employee("RUNOOB");
      empOne.setSalary(1000);
      empOne.printEmp();
   }
}

　

运行结果：

$ javac Employee.java 
$ java Employee
名字 : RUNOOB
薪水 : 1000.0

 

类变量（静态变量）

  • 类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法以外。
  • 不管一个类建立了多少个对象，类只拥有类变量的一份拷贝。
  • 静态变量除了被声明为常量外不多使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。
  • 静态变量储存在静态存储区。常常被声明为常量，不多单独使用static声明变量。
  • 静态变量在第一次被访问时建立，在程序结束时销毁。
  • 与实例变量具备类似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。
  • 默认值和实例变量类似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值能够在声明的时候指定，也能够在构造方法中指定。此外，静态变量还能够在静态语句块中初始化。
  • 静态变量能够经过：ClassName.VariableName的方式访问。
  • 类变量被声明为public static final类型时，类变量名称通常建议使用大写字母。若是静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。
import java.io.*;
 
public class Employee {
    //salary是静态的私有变量
    private static double salary;
    // DEPARTMENT是一个常量
    public static final String DEPARTMENT = "开发人员";
    public static void main(String[] args){
    salary = 10000;
        System.out.println(DEPARTMENT+"平均工资:"+salary);
    }
}

注意：若是其余类想要访问该变量，能够这样访问：Employee.DEPARTMENT。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程