java基础（一）java常见关键字，运算符，深入理解基本数据类型及面向对象

java常见关键字

Java语言中的关键字是开发语言中预定义的保留标识符，不能在程序代码中表示类，变量方法等成员
Java关键字的特征：JAVA的关键字都是小写的
注意：大写的NULL不是java关键字，String是java的一个封装类，也不是关键字

在这里插入图片描述
按表中顺序比较难记的几个关键字解释：
static关键字（静态）：
static可以修饰变量、方法、代码块和内部类
static属性属于这个类所有，即由该类创建的所有对象共享同一个static属性。可以对象创建后通过对象名.属性名和类名.属性名两种方式来访问。也可以在没有创建任何对象之前通过类名.属性名的方式来访问。
static变量和非static变量的区别(都是成员变量，不是局部变量)
1.在内存中份数不同
不管有多少个对象，static变量只有1份。对于每个对象，实例变量都会有单独的一份
static变量是属于整个类的，也称为类变量。而非静态变量是属于对象的，也称为实例变量
2.在内存中存放的位置不同
3.访问的方式不同
实例变量：对象名.变量名
静态变量：对象名.变量名 or 类名.变量名
4.在内存中分配空间的时间不同
static代码块。当类被第一次使用时（可能是调用static属性和方法，或者创建其对象）执行静态代码块，且只被执行一次，主要作用是实现static属性的初始化。
static内部类：属于整个外部类，而不是属于外部类的每个对象。不能访问外部类的非静态成员（变量或者方法），.可以访问外部类的静态成员

strictfp关键字（严格，精准）
strictfp的意思是FP-strict，也就是说精确浮点的意思。在Java虚拟机进行浮点运算时，如果没有指定strictfp关键字时，Java的编译器以及运行环境在对浮点运算的表达式是采取一种近似于我行我素的行为来完成这些操作，以致于得到的结果往往无法令人满意。而一旦使用了strictfp来声明一个类、接口或者方法时，那么所声明的范围内Java的编译器以及运行环境会完全依照浮点规范IEEE-754来执行。因此如果想让浮点运算更加精确，而且不会因为不同的硬件平台所执行的结果不一致的话，那就请用关键字strictfp。

可以将一个类、接口以及方法声明为strictfp，但是不允许对接口中的方法以及构造函数声明strictfp关键字

synchronized 关键字（线程同步）
synchronized 关键字可以应用于方法或语句块，并为一次只应由一个线程执行的关键代码段提供保护。
synchronized 关键字可防止代码的关键代码段一次被多个线程执行。

如果应用于静态方法，那么，当该方法一次由一个线程执行时，整个类将被锁定。

如果应用于实例方法，那么，当该方法一次由一个线程访问时，该实例将被锁定。

如果应用于对象或数组，当关联的代码块一次由一个线程执行时，对象或数组将被锁定。

volatile 关键字（易失）
volatile 关键字用于表示可以被多个线程异步修改的成员变量。

注意：volatile 关键字在许多 Java 虚拟机中都没有实现。 volatile 的目标用途是为了确保所有线程所看到的指定变量的值都是相同的。

Java 语言中的 volatile 变量可以被看作是一种 “程度较轻的 synchronized”；与 synchronized 块相比，volatile 变量所需的编码较少，并且运行时开销也较少，但是它所能实现的功能也仅是 synchronized 的一部分。

final和abstract关键字
final和abstract是功能相反的两个关键字，可以对比记忆
abstract可以用来修饰类和方法，不能用来修饰属性和构造方法；使用abstract修饰的类是抽象类，需要被继承，使用abstract修饰的方法是抽象方法，需要子类被重写。
注意：
抽象类不能被实例化。因为抽象类中方法未具体化，这是一种不完整的类，所以直接实例化也就没有意义了。
抽象类中不一定要包含abstrace方法,但是如果包含了abstrace方法，则必须声明为抽象类
抽象方法不能有方法主体。格式如下：

abstract void xxx();

final可以用来修饰类、方法和属性，不能修饰构造方法。使用final修饰的类不能被继承，使用final修饰的方法不能被重写，使用final修饰的变量的值不能被修改，所以就成了常量。
下面总结了一些使用final关键字的好处:
final关键字提高了性能。JVM和Java应用都会缓存final变量。
final变量可以安全的在多线程环境下进行共享，而不需要额外的同步开销。
使用final关键字，JVM会对方法、变量及类进行优化。

this和super关键字
this是对象内部指代自身的引用,同时也是解决成员变量和局部变量同名问题；this可以调用成员变量，不能调用局部变量；this也可以调用成员方法，但是在普通方法中可以省略this，在构造方法中不允许省略，必须是构造方法的第一条语句。，而且在静态方法当中不允许出现this关键字。
super代表对当前对象的直接父类对象的引用，super可以调用直接父类的成员变量（注意权限修饰符的影响，比如不能访问private成员）
super可以调用直接父类的成员方法（注意权限修饰符的影响，比如不能访问private成员）；super可以调用直接父类的构造方法，只限构造方法中使用，且必须是第一条语句。

java运算符

运算符基本分为六类：算数运算符、赋值运算符、比较/关系运算符、逻辑运算符、位运算符、三元/三目/条件运算符。
一.算术运算符：
在这里插入图片描述
这里注意++和–在前在在后不同，i++是先用之前的值，用完后再增加，++i是先增加后再用

	int a=6;
	int b=a++;
	System.out.println("a:"+a);
	System.out.println("b:"+b);

结果：
a:7
b:6
一定要注意哦！自增和自减运算符只能用于操作变量，不能直接用于操作数值或常量！例如 5++ 、 8-- 等写法都是错误滴！

二.赋值运算符
赋值运算符是指为变量或常量指定数值的符号。如可以使用 “=” 将右边的表达式结果赋给左边的操作数。

Java 支持的常用赋值运算符，如下表所示：
在这里插入图片描述

三.比较/关系运算符
比较运算符用于判断两个数据的大小，例如：大于、等于、不等于。比较的结果是一个布尔值（ true 或 false ）。
在这里插入图片描述
关于==和equal：
对于==，比较的是值是否相等
如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；
如果作用于引用类型的变量，则比较的是所指向的对象的地址

2）对于equals方法，注意：equals方法不能作用于基本数据类型的变量，equals继承Object类，比较的是是否是同一个对象
　如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；
　诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。

四.逻辑运算符
逻辑运算符主要用于进行逻辑运算。Java 中常用的逻辑运算符如下表所示：
在这里插入图片描述

当使用逻辑运算符时，我们会遇到一种很有趣的“短路”现象。
譬如：( one > two ) && ( one < three ) 中，如果能确定左边 one > two 运行结果为 false , 则系统就认为已经没有必要执行右侧的 one < three 啦。
同理，在( one > two ) || ( one < three ) 中，如果能确定左边表达式的运行结果为 true , 则系统也同样会认为已经没有必要再进行右侧的 one < three 的执行。。。。如果是单个的|或&，必须是全部算出后再比较

五.位运算符

符合	含义
<<	左移运算符，num << 1,相当于num乘以2
>>	右移运算符，num >> 1,相当于num除以2
>>>	无符号右移，忽略符号位，空位都以0补齐

  5<<2 等于20
    5的二进制是   0000 0000 0000 0101
    左移两位      0000 0000 0001 0100
  5>>2 等于 1
    5的二进制是   0000 0000 0000 0101
    右移两位      0000 0000 0000 0001
 -5>>2 等于 -2
    -5的二进制是   1111 1111 1111 1011
    右移两位       1111 1111 1111 1110 转十进制，反着来，先-1，然后取反

六.三元/三目/条件运算符
对于有些选择分支结构,可以使用简单的条件运算符来代替. 如:
if(a<b)
min=a;
else
min=b;
可以用下面的条件运算符来处理
min=(a<b)?a:b;
其中"(a<b)?a:b"是一个"条件表达式",它是这样执行的:　　如果a<b为真,则表达式取a值,否则取b值.
它的一般形式为:
表达式1?表达式2:表达式3;
注意：
条件运算符的结合方向为"自右至左".
条件表达式允许嵌套,即允许条件表达式中的表达式2和表达式3又是一个条件表达式.例如:
　　　　　　　　x>0?1:x<0?-1:0
上述条件表达式中,表达式3部分又是一个条件表达式.根据条件表达式的结合性,上述条件表达式等价于:
　　　　　　　 x>0?1:(x<0?-1:0)
其作用是判断x的符号情况.当x为正数时,该条件表达式的值为1;当x为负数时,该条件表达式的值为-1;当x为0时,该条件表达式的值为0.

深入理解基本数据类型

Java 中的数据类型有两类：

值类型（又叫内置数据类型，基本数据类型）
引用类型（除值类型以外，都是引用类型，包括 String、数组

值类型
Java 语言提供了 8 种基本类型，大致分为 4 类
整数型
byte - 8 位。
short - 16 位。
int - 32 位。
long - 64 位，赋值时一般在数字后加上 l 或 L。
浮点型
float - 32 位，直接赋值时必须在数字后加上 f 或 F。
double - 64 位，赋值时一般在数字后加 d 或 D 。
字符型
char - 16 位，存储 Unicode 码，用单引号赋值。
布尔型
boolean - 只有 true 和 false 两个取值。
值类型和引用类型的区别
—从概念方面来说
基本类型：变量名指向具体的数值。
引用类型：变量名指向存数据对象的内存地址。
—从内存方面来说
基本类型：变量在声明之后，Java 就会立刻分配给他内存空间。
引用类型：它以特殊的方式（类似 C 指针）向对象实体（具体的值），这类变量声明时不会分配内存，只是存储了一个内存地址。
—从使用方面来说
基本类型：使用时需要赋具体值,判断时使用 == 号。
引用类型：使用时可以赋 null，判断时使用 equals 方法。

Java 中，数据类型转换有两种方式：

自动换行
强制转换

自动转换
一般情况下，定义了某数据类型的变量，就不能再随意转换。但是 JAVA 允许用户对基本类型做有限度的类型转换。
如果符合以下条件，则 JAVA 将会自动做类型转换：

由小数据转换为大数据
显而易见的是，“小”数据类型的数值表示范围小于“大”数据类型的数值表示范围，即精度小于“大”数据类型。
所以，如果“大”数据向“小”数据转换，会丢失数据精度。比如：long 转为 int，则超出 int 表示范围的数据将会丢失，导致结果的不确定性。
反之，“小”数据向“大”数据转换，则不会存在数据丢失情况。由于这个原因，这种类型转换也称为扩大转换。
这些类型由“小”到“大”分别为：(byte，short，char) < int < long < float < double。
这里我们所说的“大”与“小”，并不是指占用字节的多少，而是指表示值的范围的大小。
转换前后的数据类型要兼容
由于 boolean 类型只能存放 true 或 false，这与整数或字符是不兼容的，因此不可以做类型转换。
整型类型和浮点型进行计算后，结果会转为浮点类型

强制转换
强制转换使用括号 () ；；引用类型也可以使用强制转换。

装箱和拆箱
ava 中为每一种基本数据类型提供了相应的包装类，如下：
Byte <-> byte
Short <-> short
Integer <-> int
Long <-> long
Float <-> float
Double <-> double
Character <-> char
Boolean <-> boolean
基本数据（Primitive）型的自动装箱（boxing）拆箱（unboxing）自 JDK 5 开始提供的功能。
JDK 5 之前的形式：

Integer i1 = new Integer(10); // 非自动装箱

JDK 5 之后：

Integer i2 = 10; // 自动装箱

装箱、拆箱应用场景
一种最普通的场景是：调用一个含类型为 Object 参数的方法，该 Object 可支持任意类型（因为 Object 是所有类的父类），以便通用。当你需要将一个值类型（如 int）传入时，需要使用 Integer 装箱。
另一种用法是：一个非泛型的容器，同样是为了保证通用，而将元素类型定义为 Object。于是，要将值类型数据加入容器时，需要装箱。
当 == 运算符的两个操作，一个操作数是包装类，另一个操作数是表达式（即包含算术运算）则比较的是数值（即会触发自动拆箱的过程）。
示例：

Integer i1 = 10; // 自动装箱
Integer i2 = new Integer(10); // 非自动装箱
Integer i3 = Integer.valueOf(10); // 非自动装箱
int i4 = new Integer(10); // 自动拆箱
int i5 = i2.intValue(); // 非自动拆箱
// Output:
// i1 = [10]
// i2 = [10]
// i3 = [10]
// i4 = [10]
// i5 = [10]
// i1 == i2 is [false]
// i1 == i4 is [true]

上面的例子，虽然简单，但却隐藏了自动装箱、拆箱和非自动装箱、拆箱的应用。从例子中可以看到，明明所有变量都初始化为数值 10 了，但为何会出现 i1 == i2 is [false 而 i1 == i4 is [true] ？

原因在于：

i1、i2 都是包装类，使用 == 时，Java 将它们当做两个对象，而非两个 int 值来比较，所以两个对象自然是不相等的。正确的比较操作应该使用 equals 方法。
i1 是包装类，i4 是基础数据类型，使用 == 时，Java 会将两个 i1 这个包装类对象自动拆箱为一个 int 值，再代入到 == 运算表达式中计算；最终，相当于两个 int 进行比较，由于值相同，所以结果相等。

面向对象

Java 是面向对象的高级编程语言，类和对象是 Java 程序的构成核心。围绕着 Java 类和 Java 对象，有三大基本特性：封装是 Java 类的编写规范、继承是类与类之间联系的一种形式、而多态为系统组件或模块之间解耦提供了解决方案。

面向对象与面向过程的区别
面向对象和面向过程的思想有着本质上的区别, 作为面向对象的思维来说，当你拿到一个问题时，你分析这个问题不再是第一步先做什么，第二步再做什么，这是面向过程的思维，面向对象的思维是，当我碰到这个问题域的时候，碰到这个程序的时候，我首先应该把这个问题里有哪些对象，对象与对象之间有什么关系抽象出来。

面向对象开发模式更有利于人们开拓思维，在具体的开发过程中便于程序的划分，方便程序员分工合作，提高开发效率。面向对象程序设计有以下优点。

可重用性：它是面向对象软件开发的核心思路，提高了开发效率。面向对象程序设计的抽象、继承、封装和多态四大特点都围绕这个核心。
可扩展性：它使面向对象设计脱离了基于模块的设计，便于软件的修改。
可管理性：能够将功能与数据结合，方便管理。
该开发模式之所以使程序设计更加完善和强大，主要是因为面向对象具有继承、封装和多态 3 个核心特性。

1.封装
Java中的封装是指一个类把自己内部的实现细节进行隐藏，只暴露对外的接口（setter和getter方法）。封装又分为属性的封装和方法的封装。把属性定义为私有的，它们通过setter和getter方法来对属性的值进行设定和获取。

public class Person {
    private int id;

    public int getId() {
        return id;
    }
 public void setId(int id) {
        this.id = id;
    }

在Person类中，定义了个成员变量，分别为id ，它们的访问修饰都是private私有的，通过setter和getter方法对这些变量进行设值以及取值。那么这么做有什么好处呢？封装的意义就是增强类的信息隐藏与模块化，提高安全性。封装的主要作用也是对外部隐藏具体的实现细节，增加程序的安全性。
2.继承
Java中的继承是指在一个现有类（父类）的基础上在构建一个新类（子类），子类可以拥有父类的成员变量以及成员方法（但是不一定能访问或调用，例如父类中private私有的成员变量以及方法不能访问和调用）。继承的作用就是能提高代码的复用性。子类拥有父类中的一切（拥有不一定能使用），它可以访问和使用父类中的非私有成员变量，以及重写父类中的非私有成员方法。

继承的好处是实现代码的复用以及扩展，子类通过对父类代码的复用，可以不用再定义父类中已经定义的成员变量，方法上直接对父类的方法进行重写实现了扩展。
3.多态
多态就是指多种状态，就是说当一个操作在不同的对象时，会产生不同的结果。

在Java中，实现多态的方式有两种，一种是编译时的多态，另外一种是运行时多态，编译时的多态是通过方法的重载实现的，而运行时多态是通过方法的重写实现的。

方法的重载是指在同一个类中，有多个方法名相同的方法，但是这些方法有着不同的参数列表，在编译期我们就可以确定到底调用哪个方法。

方法的重写，子类重写父类中的方法（包括接口的实现），父类的引用不仅可以指向父类的对象，而且还可以指向子类的对象。当父类的引用指向子类的引用时，只有在运行时才能确定调用哪个方法。

其实在运行时的多态的实现，需要满足三个条件：1.继承（包括接口的实现）2.方法的重写 3.父类的引用指向子类对象

并且，我们说的多态都是类中方法的多态，属性是没有多态性的。方法的重载我这里就不举例说明了，我说一下运行时的多态。

接口：

public interface Animal {
	void shout();
}

实现类：

public class Dog implements Animal{
 
	@Override
	public void shout() {
		System.out.println("wangwang...");
	}

实现类：


public class Cat implements Animal {
 
	@Override
	public void shout() {
		System.out.println("miaomiao...");
	}

测试类：


public class AnimalTest {
	public static void main(String[] args) {
		//父类的引用指向子类对象
		Animal d = new Dog();
		animalShout(d);
		
		//父类的引用指向子类对象
		Animal c= new Cat();
		animalShout(c);
		
	}
	
	
	public static void animalShout(Animal animal) {
		animal.shout();
	}