Java语言

Java语言基础教程

本文将放入菜单栏中方便学习，记得点赞哦！

Java分为3个体系，为JavaSE，JavaEE，JavaME，是一种面向对象的程序设计语言，记住Oracle公司收购了 Sum公司，然后Oracle公司就负责了Java语言的维护。

“一次编译，到处运行”

Java语言的特点，具有面向对象，平台无关性，简单性，解释性，多线程，分布式，健壮性，高性能，安全性等。

Java的开发环境，JDK，它提供了编译和运行的Java程序环境，下载JDK，输入 www.oracle.com，单击 DOWNLOAD 按钮

下载jdk，和eclipse就比较简单了，提供JDK 9 地址：

http://www.oracle.com/technetwork/java/javase/downloads/jdk9-downloads-3848520.html

提供JDK 8 地址：

http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

JDK包安装完成后，需要配置环境变量。点击桌面上的“我的电脑”或者“此电脑”，选择“属性”，接着选择“高级”，点击其中的“环境变量”弹出“环境变量”对话框，其中包含“用户变量”和“系统变量”两部分。

设置系统“变量名”为“JAVA_HOME","变量值”为“C:ProgramFilesJavajre1.8.0_112",即是JDK安装路径，你也可以将地址栏中的路径直接复制过来。

再次选择”系统变量"列表中找到其"Path"（双击）-->"编辑",弹出”编辑系统变量",点击新建：

然后，单击”系统变量"下面的“新建"按钮，创建名为”classpath“的环境变量，值为”.",英文的一点，代表当前路径。

“环境变量”对话框中单击“系统变量”列表框下方的“新建”按钮，弹出“新建系统变量”对话框，“变量名”文本框中输入 JAVA_HOME，“变量值”文本框中输入 JDK 的安装路径。

“系统变量”列表框中双击 Path 变量，进入“编辑系统变量”对话框，添加最前端添加

.;％JAVA__HOME%in;

环境变量：

JAVA_HOME：D:Javajdk1.8.0_25

CLASSPATH  ：.;%JAVA_HOME%lib;%JAVA_HOME%libdt.jar;%JAVA_HOME%lib	ools.jar;

Path：;%JAVA_HOME%in;%JAVA_HOME%jrein

bin：提供 JDK 工具程序
jre：存放 Java 运行环境文件
src.zip：提供的 API 类的源代码压缩文件
include：存放用于本地访问的文件
lib：存放 Java 的类库文件

编程：

public class HelloJava
{
    public static void main(String[] args)
    {
        System.out.println("hello world");
    }
}

javac HelloJava.java
java HelloJava

Java程序运行流程：编写、编译和运行

Java 虚拟机（JVM）是运行 Java 程序的软件环境

下载eclipse链接（官网）：

https://www.eclipse.org/downloads/

接下来我们进入到这个链接：

https://www.eclipse.org/downloads/eclipse-packages/

官方网站是 www.eclipse.org，进入网站，点击 Download Packages，从 Eclipse IDE for Java EE Developers，选择下载的系统版本， 点击“64-bit”后跳转到“Choose a mirror close to you”界面，选择“大连东软信息学院”，点击下载，看到“click here”。

下载语言：

www.eclipse.org/babel

简体中文的下载列表，下载会得到一个文件，Eclipsedrogins文件夹中同名的 features 目录和 plugins 目录，重启就会自动加载语言包。

标识符

标识符由数字，字母，下划线，美元符号，第一个符号为字母，下划线，和美元符号，后面随意，Java是区分大小写的！标识符用来命名 常量，变量，类，和类的对象的。

关键字

51关键字，数据类型，流程控制，修饰符，动作，保留字

boolean, int, long, short, byte, float, double, char, 
class, interface

true, false, null, goto, const

if, else, do, while, for, switch, case, default, 
break, continue, return, 
try, catch, finally

public, protected, private, final, 
void, static, strict, abstract, 
transient, synchronized, volatile, native

package, import, throw, throws, extends, implements, 
this, supper, instanceof, new

运算符、数据类型、变量、控制流程语句

常量是运行过程中保存不变的量，常量值称为字面常量。

整型int
长整型long
双精度型double
单精度型float

字符型，单引号引起来的字符，双引号是用来表示字符串额，使用final定义常量的关键字。

变量，初始化变量指定义一个明确的初始值，初始化变量有两种一种为声明直接赋值，一种是先声明，后赋值。

var a = 1; // 直接赋值

String name; // 先声明
name = "dashucoding"; // 后赋值

变量，可以分为类变量，局部变量等。
类变量是声明在类中，也叫成员变量。
局部变量是声明在方法或是在方法代码块中的变量。

数据类型

基本数据类型：byte short int long float double
boolean, char。

byte字节型有1字节,short短整型有2字节,整数int有4个字节，长整型long有8字节，单精度float有4字节，双精度double有8字节，字符型char有2字节，布尔型boolean有1字节。

基本数据类型分，数值型（整数类型，byte,short,int,long）（浮点类型float,double），字符类型char,布尔类型boolean

整数字面量为整型（int）
小数字面量为双精度浮点型（double）

引用数据类型：类class,接口interface,数组

运算符：算术运算符，逻辑运算符，关系运算符，赋值运算符。

加（+）、减（-）、乘（*）、除（）

逻辑运算符：

&& 逻辑与
II 逻辑或
! 逻辑非

关系运算符：

>、<、>=、<= 

位逻辑运算符

&（与）
|（或）
~（非）
^（异或）

1 true 0 false

位与运算符
与
同时为1，才是1，不然就是0，任何数与0都是为0。

位或运算符
或
有一个是1，就为1，只有都是0，才为0。

位异或运算符
异或
同时为0，或，同时为1，才为0，否则都是为1。

位取反运算符
取反
1变0,0变1

左位移运算符
原来数的 2 倍

右位移运算符
原来数的 1/2 倍

数据类型转换

什么是向上转型？向上转型就是将子类的对象赋值给父类的引用。
什么是向下转型？向下转型就是将父类的对象赋值给子类的引用

显式转换，强制类型转换
隐式转换，自动类型转换

数据类型转换：

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

字符类型转换：

char -> int

public class Test{
char c = 'a';
switch(c){
 case 'b':
 System.out.println('b');
 break;
 case 'c':
 System.out.println('c');
 break;
 case 'a':
 System.out.println('a');
 break;
 default:
 System.out.println('d');
}
} 
}
// swith( char byte short int )只允许四种类型

public class Test{
public static void main(String args[]){
 int score = 90;
 if(score > 85 && score <= 100){
  System.out.println("成绩为优");
 }
 else if(score > 75 && score <= 85){
  System.out.println("成绩为良");
 }
 else if(score > 60 && score <= 75){
  System.out.println("成绩为中");
 }
 else if(score <= 60 && score >= 0){
  System.out.println("成绩为差");
 }
 else if(score > 100 || score < 0){
  System.out.println("成绩不在正常的范围之内");
 }
}
}

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

public class Test{
public static void main(String args[]){
 int i = 0;
 while(i < 10){
  System.out.println(i);
  i++;
 }
}
}

流程控制语句：顺序结构，选择结构，循环结构
打印100-200的素数：

class Test{
public static void main(String args[]){
 for(int i = 100; i < 201; i++){
  boolean b = false;
  
  for(int j = 2; j < i-1; j++){
   int k=i%j;
   if(k==0){
    b=true;
   }
  }
  //如果不是true就打印出素数
  
 if(!b){
  System.out.println(i);
 }
 }
}
}

public class Test{
public static void main(String args[]){
 int i = 5;
 int j = i++ + 5;
 System.out.println(i);
 System.out.println（j）;
 }
}

j=10;
i=6;

int j = ++i + 5;
System.out.println(j);
j=11;
i=6;

if语句：

if (条件表达式)
{
    // 语句块;
}

if (表达式)
{
    // 语句块1;
}
else
{
    // 语句块2;
}

switch语句：

switch(表达式)
{
    case 值1:
        // 语句块;
        break;
    case 值2:
        // 语句块;
        break;
    …
    case 值n:
        // 语句块;
        break;
    default:
        // 语句块;
    break;
}

while语句：

while(条件表达式)
{
    // 语句块;
}

do
{
    // 语句块;
}while(条件表达式);

for(条件表达式1;条件表达式2;条件表达式3)
{
 // 语句块;
}

九九乘法表

public class Demo
{
    public static void main(String[] args)
    {
        for(int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                System.out.print(j+"*"+i+"="+j*i+"	");
            }
            System.out.println();
        }
    }
}

foreach 循环语句：

for(类型 变量名:集合)
{
    // 语句块;
}

break,continue,return语句：

return用于终止函数的执行或退出类的方法
break用于退出循环，使用break语句可以实现goto功能
continue 语句跳出循环体，主要结束本次循环

break label;

输入语句：

Scanner sc=new Scanner(System.in);
int year=sc.nextInt();
int month=sc.nextInt();

判断闰年：

if((year%4==0&&year%100!=0)||(year%400==0)){
    System.out.println(year+"闰年");
}else{
    System.out.println(year+"平年");
}

int day=0;
switch(month)
{
    case 1:
    case 3:
    case 5:
    case 7:
    case 8:
    case 10:
    case 12:
        day=31;
        break;
    case 4:
    case 6:
    case 9:
    case 11:
        day=30;
        break;
    default:
        if(isR){
            day=29;
        }else{
            day=28;
        }
        break;
}

字符串一旦被创建，值是不能改变的，但是可以用其他变量重新赋值。字符串必须要进行初始化才能使用。

String()表示一个空字符序列：

String str1=new String("hello world");
String str2=new String(str1);

concat()方法，把一个字符串连接到另一字符串后面

字符串1.concat(字符串2);

toLowerCase()和toUpperCase()

字符串名.toLowerCase()   

字符串名.toUpperCase()

trim()去除空格：

字符串名.trim()

substring()方法用于获取字符串的，截取字符。

str.substring(0); // 从开始到结束
str.substring(3); // 从3开始
str.substring(0，3); // 从0到3

spilt()切割分隔符

字符串替换：

replace(), replaceFirst(), replaceAll()

str.replace(String old, String new); // 旧的， 新的

str.replaceFirst("dashucoding", "dashu"); // 替换第一个字符出现的位置

str.replaceAll("dashu", "da"); // 替换所有子字符串

Java虚拟机把内存分为栈内存和堆内存

class Test{
public static void main(String args[]){
 Dog d = new Dog();
 d.name="哈哈";
 d.age=2;
 d.jump();
 System.out.println("名字是"+d.name);
 }
}

重载的表达

class A{
void funA(){
 System.out.println("没有参数的funA函数");
}
void funA(int i){
 System.out.println("有参数的funA函数");
}
void funA(int i,double d){
 System.out.println("拥有两个参数的funA函数");
}
}

class Test{
public static void main(String args[]){
 A a = new A();
 a.funA();
 a.funA(1,2.0);
 }
}

equals()方法:

str1.equals(str2);

equalsIgnoreCase() 忽略大小写

str1.equalsIgnoreCase(str2);

indexOf(),lastIndexOf,CharAt()

indexOf()返回索引值，

str.indexOf(value)
str.indexOf(value,int fromIndex)

// 从末尾找
str.lastIndexOf(value)
str.lastlndexOf(value, int fromIndex)

str.charAt(索引值);

继承，封装，多态
Java只支持单继承，不允许多继承，继承是为了减少重复代码

class Person{
String name;
int age;
Person(){
 System.out.prinltn("Person的无参数构造函数");
}
Person(String name,int age){
 this.name=name;
 this.age=age;
 System.out.println("Person有参数的构造函数");
}

void eat(){
 System.out.println("定义吃饭的方法");
}
}

class Student extends Person{
//子类继承父类
Student(){
 //父类
 super();
 System.out.println("Student的无参数构造函数");
}
Student(String name,int age,int id){
 super(name,age);
 this.id=id;
}
}

class Test{
public static void main(String args[]){
 Student student = new Student();
}
}

什么是复写？
具有父子关系的两个类中，父类和子类各有一个函数，这两个函数的定义（返回值类型，函数名，参数列表）完全相同。

StringBuffer类是可变字符串类，创建StringBuffer类的对象后可以修改字符串的内容，如果超出了类对象的容量，会自动扩大的。

//多个引用指向同一个字符串
String str1 = "dashu"
String str2 = "dashu";
System.out.println(str1==str2);
//结果
true

//内容相同，但是创建方式不同的情况
String str3 = "abc"
String str4 = new String ("abc");
System.out.println(str3==str4);//false
System.out.println(str3.equals(str4));//true
//结果
false
true

StringBuffer

对于字符串是常量，它的值在创建后时不可以改变的，但字符串缓冲区支持可变的字符串。

StringBuffer类为java.lang中，StringBuffer为字符串缓冲，StringBuffer为线程安全的可变字符序列，类似String的字符串缓冲区，缓冲区不能改，但里面可以改，通过某方法可以改变序列的长度和内容。

StringBuffer提供了主要的两种方法，一，append（）,二，inset（）。

StringBuffer为一个字符串缓冲区，相对于一个容器，长度是可变的，可以存储任意类型数据，是将任意数据转变为字符串进行存储，StringBuffer提供了对数据的很多的操作功能。

例子：

StringBuffer sb = new StringBuffer();
sb.append("da");
sb.append("shu");
System.out.println(sb);
//sb.append("da").append("shu");

如果要操作数据，要转换为字符串。StringBuffer所有存储的元素都被转成字符串才可使用。

String str = sb.append("da").append("shu").toString();

在指定位置插入元素

sb.insert(2,"hehe");//插入

StringBuffer和StringBuilder的区别

StringBuilder为java.lang类，是一个可变的字符序列，提供了与StringBuffer兼容的API，StringBuffer和StringBuilder方法是一模一样的。

StringBuilder不同步，不安全。如果同时append(),delete(),insert(),会导致出错，多线程访问不安全，添加修饰synchronized即可。在jdk1.5版本后，推出StringBuilder被用作一个StringBuffer的简易替换，用在字符串缓冲区被单个线程使用的时候。

使用StringBuilder的出现，是为了提高效率，是非同步的，是对单线程访问效率高，对于StringBuffer是同步的，对多线程的访问是安全的。这些是不同点，相同的是功能一模一样的哦。

StringBuffer类替换字符

StringBuffer 对象
对象.setCharAt(int index, char ch);

StringBuffer 对象
对象.reverse();

StringBuffer 对象
对象.deleteCharAt(int index);

StringBuffer 对象
对象.delete(int start,int end);

正则表达式

^ 匹配输入字符串开始的位置
$ 匹配输入字符串结尾的位置
* 零次或多次匹配前面的字符或子表达式
+ 一次或多次匹配
? 零次或一次
{n} 正好出现 n 次
{n,} 至少出现 n 次
{n,m} 出现 n~m 次
[a-z] 匹配指定范围内的任何字符
[^a-z] 反向范围字符 匹配不在指定的范围内的任何字符
d 数字字符匹配 [0-9]
D 非数字字符匹配
s 匹配任何空白字符
	 制表符匹配

结言

好了，欢迎在留言区留言，与大家分享你的经验和心得。

感谢你学习今天的内容，如果你觉得这篇文章对你有帮助的话，也欢迎把它分享给更多的朋友，感谢。

作者简介

达叔，理工男，简书作者&全栈工程师，感性理性兼备的写作者，个人独立开发者，我相信你也可以！阅读他的文章，会上瘾！，帮你成为更好的自己。长按下方二维码可关注，欢迎分享，置顶尤佳。