1、什么是java?

Java不仅是一种优秀的程序设计语言，Java还是一个有一系列计算机软件和规范形成的技术体系，这个技术体系提供了完整的用于软件开发和跨平台部署的支持环境，并广泛应用于嵌入式系统、移动终端、企业服务器、大型机等各种场合。

1.1 java的特性

简单性：这里没有头文件、指针运算（甚至指针语法）、结构、联合、操作符重载、虚基类等等。
面向对象：在Java的世界里，一切皆对象。所谓面相对象，就是依靠对象之间的交互来完成事情。
安全性：Java适用于网络/分布式环境。
可移植性：基本数据类型的大小以及有关运算都做了明确的说明。
解释性：Java为了实现与平台无关，自己维护了一套基于栈架构的指令集，供自己使用。
多线程：多线程可以带来更好的交互响应和实时行为。
动态性：它能够适应不断发展的环境。库中可以自由的添加新方法和实例变量，而
对客户端没有任何影响。

1.2 java的关键字

用于定义访问权限修饰符的关键字：private、protected、public
用于定义类、函数、变量修饰符的关键字：abstract、final、static、synchronized
用于定义类与类之间关系的关键字：extends、implements
用于定义建立实例及引用实例、判断实例的关键字：new、this、super、instanceof
用于处理异常的关键字：try、catch、finally、throw、throws
用于包的关键字：package、import

2、java的数据类型与变量

2.1 数据类型

在Java中数据类型主要分为两类：基本数据类型和引用数据类型。
基本数据类型有四类八种：
1. 四类：整型、浮点型、字符型以及布尔型
2. 八种：

2.2 变量

2.2.1 什么是变量？

对于经常改变的内容，在Java程序中，称为变量。而数据类型就是用来定义不同种类变量的。

2.2.2 变量的语法格式

int a = 10;
double d = 3.14;
char c = 'A';
boolean b = true;
System.Out.println(a);
System.Out.println(d);
System.Out.println(c);
System.Out.println(b);

2.2.3 类型转换

1、自动类型转换(隐式)：代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。

特点：数据范围小的转为数据范围大的时会自动进行

System.Out.println(1024); // 整型默认情况下是int
System.Out.println(3.14); // 浮点型默认情况下是double
int a = 100;
long b = 10L;
b = a; // a和b都是整形，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值
a = b; // 编译报错，long的范围比int范围大，会有数据丢失，不安全

2、强制类型转换(显式)：当进行操作时，代码需要经过一定的格式处理，不能自动完成。

特点：数据范围大的到数据范围小的。

int a = 10;
long b = 100L;
b = a; // int-->long，数据范围由小到大，隐式转换
a = (int)b; // long-->int, 数据范围由大到小，需要强转，否则编译失败

3、类型提升：不同类型的数据之间相互运算时，数据类型小的会被提升到数据类型大的。
（1）int与long之间：int会被提升为long

int a = 10;
long b = 20;
int c = a + b; // 编译出错: a + b==》int + long--> long + long 赋值给int时会丢失数据
long d = a + b; // 编译成功：a + b==>int + long--->long + long 赋值给long

（2）byte与byte的运算

byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);

3、字符串类型

（1）. int 转成 String

int num = 10;
// 方法1
String str1 = num + "";
// 方法2
String str2 = String.valueOf(num);

（2）String 转成 int

String str = "100";
int num = Integer.parseInt(str);

3、运算符

3.1 算数运算符

1、基本四则运算符：加减乘除模(+ - * / %）

int a = 20;
int b = 10;
System.out.println(a + b); // 30
System.out.println(a - b); // 10
System.out.println(a * b); // 200
System.out.println(a / b); // 2
System.out.println(a % b); // 0 --->模运算相当于数学中除法的余数

2、增量运算符：+= -= *= %=

int a = 1;
a += 2; // 相当于 a = a + 2
System.out.println(a); // 输出3
a -= 1; // 相当于 a = a - 1
System.out.println(a); // 输出2
a *= 3; // 相当于 a = a * 3
System.out.println(a); // 输出6
a /= 3; // 相当于 a = a / 3
System.out.println(a); // 输出2
a %= 3; // 相当于 a = a % 2
System.out.println(a); // 输出2

3、自增/自减运算符：++ --

int a = 1;
a++; // 后置++ 表示给a的值加1，此时a的值为2
System.out.println(a++); // 注意：后置++是先使用变量原来值，表示式结束时给变量+1，因此输出2
System.out.println(a); // 输出3
++a; // 前置++ 表示给a的值加1
System.out.println(++a); // 注意：前置++是先给变量+1，然后使用变量中的值，因此输出5
System.out.println(a); // 输出5

3.2 关系运算符

关系运算符主要有六个: == != < > <= >= ，其计算结果是 true 或者 false 。

int a = 10;
int b = 20;
// 注意：在Java中 = 表示赋值，要与数学中的含义区分
// 在Java中 == 表示相等
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a < b); // true
System.out.println(a > b); // false
System.out.println(a <= b); // true
System.out.println(a >= b); // false

3.3 逻辑运算符

逻辑运算符主要有三个: && || ! ，运算结果都是 boolean类型。

int a = 1;
int b = 2;
System.out.println(a == 1 && b == 2); // 左为真 且 右为真 则结果为真
System.out.println(a == 1 && b > 100); // 左为真 但 右为假 则结果为假
System.out.println(a == 1 || b == 2); // 左为真 且 右为真 则结果为真
System.out.println(a == 1 || b > 100); // 左为真 但 右为假 则结果也为真
System.out.println(!(a == 1)); // a == 1 为true，取个非就是false
System.out.println(!(a != 1)); // a != 1 为false，取个非就是true

4、逻辑控制

4.1 分支结构

（1）if 语句

int num = 10;
if (num % 2 == 0) {
System.out.println("num 是偶数");
} else {
System.out.println("num 是奇数");
}

（2）switch 语句

int day = 1;
switch(day) {
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("输入有误");
break;
}

4.2 循环结构

（1）while 循环

举例：计算1-100的和。

int n = 1;
int result = 0;
while (n <= 100) {
result += n;
n++;
}
System.out.println(num)

（2）for 循环

举例：计算 1! + 2! + 3! + 4! + 5!

int sum = 0;
for (int i = 1; i <= 5; i++) {
int tmp = 1;
for (int j = 1; j <= i; j++) {
tmp *= j;
} s
um += tmp;
}System.out.println("sum = " + sum);

5、数组

数组：可以看成是相同类型元素的一个集合。在内存中是一段连续的空间。

5.1 数组的使用

int[]array = new int[]{10, 20, 30, 40, 50};
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);
System.out.println(array[3]);
System.out.println(array[4]);
// 也可以通过[]对数组中的元素进行修改
array[0] = 100;
System.out.println(array[0]);

举例：获取斐波那契数列的前N项

public class TestArray {
public static int[] fib(int n){
if(n <= 0){
return null;
}
int[] array = new int[n];
array[0] = array[1] = 1;
for(int i = 2; i < n; ++i){
array[i] = array[i-1] + array[i-2];
}
return array;
}
public static void main(String[] args) {
int[] array = fib(10);
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}

6、类和对象

6.1 封装

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

public class Computer {
private String cpu; // cpu
private String memory; // 内存
public String screen; // 屏幕
String brand; // 品牌---->default属性
public Computer(String brand, String cpu, String memory, String screen) {
this.brand = brand;
this.cpu = cpu;
this.memory = memory;
this.screen = screen;
}
public void Boot(){
System.out.println("开机~~~");
}
public void PowerOff(){
System.out.println("关机~~~");
}
public void SurfInternet(){
System.out.println("上网~~~");
}
}
public class TestComputer {
public static void main(String[] args) {
Computer p = new Computer("HW", "i7", "8G", "13*14");
System.out.println(p.brand); // default属性：只能被本包中类访问
System.out.println(p.screen); // public属性： 可以任何其他类访问
// System.out.println(p.cpu); // private属性：只能在Computer类中访问，不能被其他类访问
}
}

6.2 继承

继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。

继承主要解决的问题是：共性的抽取，实现代码复用。

public class Base {
public void methodA(){
System.out.println("Base中的methodA()");
}
}
public class Derived extends Base{
public void methodB(){
System.out.println("Derived中的methodB()方法");
}
public void methodC(){
methodB(); // 访问子类自己的methodB()
methodA(); // 访问父类继承的methodA()
// methodD(); // 编译失败，在整个继承体系中没有发现方法methodD()
}
}

6.3 多态

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

多态的实现条件:

1. 必须在继承体系下
2. 子类必须要对父类中方法进行重写
3. 通过父类的引用调用重写的方法
多态体现：在代码运行时，当传递不同类对象时，会调用对应类中的方法。

public class Animal {
String name;
int age;
public Animal(String name, int age){
this.name = name;
this.age = age;
}
public void eat(){
System.out.println(name + "吃饭");
}
}
public class Cat extends Animal{
public Cat(String name, int age){
super(name, age);
}
@Override
public void eat(){
System.out.println(name+"吃鱼~~~");
}
}
public class Dog extends Animal {
public Dog(String name, int age){
super(name, age);
}
@Override
public void eat(){
System.out.println(name+"吃骨头~~~");
}
}

7、抽象类

抽象类：如果一个类中没有包含足够的信息来描绘一个具体的对象，这个类就是抽象类。

7.1 抽象类特性

1. 抽象类不能直接实例化对象
2. 抽象方法不能是 private 的
3. 抽象方法不能被final和static修饰，因为抽象方法要被子类重写
4. 抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用 abstract 修饰

5. 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类
6. 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

7.2 接口

在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。
接口的定义格式与定义类的格式基

public interface 接口名称{
// 抽象方法
public abstract void method1(); // public abstract 是固定搭配，可以不写
public void method2();
abstract void method3();
void method4();
// 注意：在接口中上述写法都是抽象方法

本相同，将class关键字换成 interface 关键字，就定义了一个接口。

7.3 接口特性

1. 接口类型是一种引用类型，但是不能直接new接口的对象
2. 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是public abstract，其他修饰符都会报错）

3. 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现

4. 重写接口中方法时，不能使用默认的访问权限
5. 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量
6. 接口中不能有静态代码块和构造方法
7. 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
8. 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类
9. jdk8中：接口中还可以包含default方法。

class Duck extends Animal implements IRunning, ISwimming, IFlying {
public Duck(String name) {
super(name);
}
@Override
public void fly() {
System.out.println(this.name + "正在用翅膀飞");
}
@Override
public void run() {
System.out.println(this.name + "正在用两条腿跑");
}
@Override
public void swim() {
System.out.println(this.name + "正在漂在水上");
}
}

8、异常

在Java中，将程序执行过程中发生的不正常行为称为异常。

【异常处理流程总结】

程序先执行 try 中的代码
如果 try 中的代码出现异常, 就会结束 try 中的代码, 看和 catch 中的异常类型是否匹配.
如果找到匹配的异常类型, 就会执行 catch 中的代码
如果没有找到匹配的异常类型, 就会将异常向上传递到上层调用者.
无论是否找到匹配的异常类型, finally 中的代码都会被执行到(在该方法结束之前执行).
如果上层调用者也没有处理的了异常, 就继续向上传递.
一直到 main 方法也没有合适的代码处理异常, 就会交给 JVM 来进行处理, 此时程序就会异常终止

JAVA SE 认识相关推荐

oracle java rmi 漏洞,Oracle Java SE Java运行时环境RMI子组件远程漏洞(CVE-2011-3556)
发布日期:2011-10-20 更新日期:2011-10-20 受影响系统: Oracle Sun JRE 1.6.x Oracle Sun JDK 1.6.x 不受影响系统: Oracle Sun ...
[零基础学JAVA]Java SE实战开发-37.MIS信息管理系统实战开发[JDBC](1)
MIS信息管理系统实战开发之使用MySQL实现保存开发背景 ID.姓名.年龄为公共信息,而学生有成绩,工人有工资定义一个抽象类Person(ID.姓名.年龄),学生是其子类,有成绩,工人是其子类有 ...
java se 与j2se_关于java：J2EE和J2SE项目之间的区别
本问题已经有最佳答案,请猛点这里访问. 我已经从github下载了一个开源项目. 这是一个基于Maven的项目. 我如何理解该项目是J2SE项目还是J2EE项目? 这两种项目在结构上有何不同? Jav ...
浅谈Java SE、Java EE、Java ME三者的区别
1. Java SE(Java Platform,Standard Edition).Java SE 以前称为 J2SE.它允许开发和部署在桌面.服务器.嵌入式环境和实时环境中使用的 Java 应用程 ...
Android SDK Tools Setup 提示 “ java se development kit not found”
使用 installer_r11-windows.exe:安装Android SDK. 使用exe安装会自动检测是否配置好JDK. 当安装和配置完JDK后,运行安装程序依旧会提示 java se de ...
Java SE和Java EE应用的性能调优
凡事预则立,不预则废,和许多事情一样,Java性能调优的成功,离不开行动计划.方法或策略以及特定的领域背景知识.为了在Java性能调优工作中有所成就,你得超越"花似雾中看"的状态, ...
【读书笔记】《写给大忙人看的Java SE 8》——Java8新特性总结
2019独角兽企业重金招聘Python工程师标准>>> 阅读目录接口中的默认方法和静态方法函数式接口和Lambda表达式 Stream API 新的日期和时间 API 杂项改进 ...
零基础学JAVA]Java SE基础部分-01. Java发展及JDK配置
1.课程名称:Java发展及JDK配置本季介绍了JAVA的发展过程,包括JDK的发展历程,path路径的配置和classpath的配置及作用.并简单讲解了一个简单的JAVA程序,并通过此程序讲解了J ...
java se翻译_(翻译)Java SE 8 Lambda 标准库概览(下)
Java SE 8 Lambda 标准库概览 8,Collectors 在目前的例子中,我们已经使用了collect()方法来收集流中的元素并放入List或Set中了.collec()方法的参数是一个 ...
JDK版本Java SE、Java EE、Java ME的区别
想在win7 X64上搭建JAVA开发环境来着(只是尝试下),打开JAVA 官网下载JDK,发现好多版本懵了,百度了下找到这些版本的区别,故有了下文 1.JAVA SE Java2平台标准版(Java ...

JAVA SE 认识