[Java]基础语法知识点v.01

Java基础知识入门

总结一下看到的Java的基础知识点包括博客上的面试题、视频上的知识点和Java书上的一些点。写出来重在输出，强化自己的记忆，出现纰漏或者错误欢迎指出错误，感激不尽。

JVM、JRE和JDK

1. JVM： Java Virtual Machine ,Java虚拟机是运行Java程序,Java中最能体现跨平台优势的，不同的平台只要安装自己的虚拟机，就能实现跨平台
2. JRE： Java Runtime Environment Java运行环境 其中包括JVM与核心库如Java.lang包，Java程序中的基本数据类型，字符串，线程，异常等类都包含在其中
3. JDK： Java Development Kit Java开发工具包，包含JRE，开发工具：Javac.exe(编译工具) ，Jar.exe(打包工具) java(解释器)

字节码 Java的编译器，解释器

1. 运行程序：

1.javac code.java   编译器
2.java code         解释器
执行流程：Java程序先通过编译器编译成字节码，字节码由虚拟机解释执行，
   		之后虚拟机把字节码送人解释器，翻译成机器上的机器码如二进制机器码 之后运行。

2. 字节码： Java程序经过虚拟机编译后产生的.class文件 只面向虚拟机 。因为字节码的存在，可以不针对专一的特定的机器，Java通过字节码无需编译可在多种不同的机器上运行

注释

1、//普通方式
2、 /* 注释内容 /
3、/** 自动生成文档方式 */

基本数据类型

1. 整型： int 4字节 short 2字节 long 8字节 长整型数值有一个后缀L或l byte 1字节
2. 浮点型： float 单精度浮点型 4字节 有一个后缀F或f double 双精度浮点型 8字节 后缀D或d 两个浮点类型不写后缀会默认是D
3. 字符型： char 2字节 Java使用的是unicode编码 如‘A’
4. 布尔型： 只有true与false两种类型 1字节 整型和布尔型之间不能进行互相转换

基本数据类型之间的转换

数据类型的转换中 byte、short、char转换为int都可以无信息丢失的转化
int转化为long、double也可与无信息丢失转化
两个数在运算时先转换为同一数据类型在计算
两个数中有double类型转换的 都是double
否则，有float类型转换的 都是float
否则，有long类型转换的 都是long
否则，两个数都是int

Math.round的用法是得到最接近的整数的用法
如Math.round（11.5） 为12 Math.round（-11.5）为-11
在参数上加上0.5然后向下取整

运算符

算数运算符  +   -  *  /   加  减  乘  除
自增自减   ++   –
赋值运算符   int a=b   a+=1  a-=1
比较运算符  ==   <   >   <=  >=   !=
逻辑运算符  and  or   ont

流程控制

1. 选择： if 语句 swith语句
2. 循环： for语句 while语句 do…while语句

面向对象编程

1.类：对象中的一些数据与方法的调用 操作数据的过程加方法
对象：有行为 有状态 有标识 使用new关键词在类前加上 相当于构建一个对象
有对象之后可以直接使用如 System.out.print(new Date())
String s = new Date().toString();
如果想多次使用可以将对象存入一个变量中 在变量前的类 引用xxx类型的对象
如 Data d = new Date()
2.在类中构造器伴随着new的操作符的执行而被调用
每一个类中可有多个构造器 必须与类名同名

访问修饰符

四种访问修饰符的使用范围：

修饰符	当前类	同包内	子类	其他包	使用对象
private	可以	不	不	不	变量、方法
default	可以	可以	不	不	类、接口、变量、方法
protected	可以	可以	可以	不	变量、方法
public	可以	可以	可以	可以	类、接口、变量、方法

this关键字

当方法局部变量与成员变量重名时，优先使用局部变量
需要访问本类中的成员变量，需要使用格式 this.成员变量名 谁调用谁是this
1.直接引用 this就是指向对象本身
2.形参与成员变量重名 this区分
3.应用本类中的构造函数

final关键字

用法 修饰一个类 、修饰一个方法、修饰一个局部变量、修饰一个成员变量
1.修饰一个类 不能有子类 不能被继承
2.修饰方法 方法不能被重写
3.修饰变量 修饰的变量不能被重新赋值

静态域、静态方法

将域定义为static，每个类中只有一个这样的域
将一个实例域中如：private static int nextId = 1；
表示这个类中的所有实例都共享一个nextId域，在内存在只有一个副本，它在类初次加载时被初始化，静态变量属于类。
静态方法： 静态方法在访问本类成员时，只允许访问静态成员，静态成员变量与静态方法，
而不能访问实例成员变量与实例方法， 外部调用静态方法时，可直接用 对象名.方法名的方式调用 静态方法可以不通过对象进行调用，在静态方法里 不能调用非静态变量，也不能访问非静态变量成员。

面向对象

概述

Java的特点 面向对象封装 继承 多态 平台无关性 java虚拟机的实现
支持方便的网络编程
支持多线程 在同一时间执行多项任务

面向过程 注重过程的具体化 流程化 一步步分析 一步步解决问题
面向对象 是模型化的 想用什么功能 只需要抽象出一个类 不必关系怎么实现 找出实现功能的模块即可。

面向对象的特性

封装 把对象的属性私有化 将细节信息隐藏 对外界不可见

继承 继承是多态的前提， 在原本已有的基础上的类中，可以新增新的功能 在继承中可以选择性的使用父类功能 也可以新加入功能。子类中可以用自己的方式实现父类方法 。关键字 extends。 如public class 类名称 extends 父类名称{}

多态 指的是程序中定义的应用变量所指向的具体类型 该变量的实例对象是在 程序运行期间才确定的 简单来说 一个对象中可以有多重形态。
在Java有两种形式可以实现 继承 与 接口

方法重载(overload) 方法重写(override)
重载发生在编译时的多态性 重写实现的是运行的多态性

重载 发生在同一个类中 方法名相同，参数列表不同 与返回值和访问修饰符无关

重写 发生在父子类中 方法名 参数列表必须相同 子类中的返回值小于等于父类方法的返回值，子类方法中的修饰符必须大于等于父类方法， 如果父类中的方法修饰符是private 则子类中就不是重写。

多态的实现 三个必要条件 继承 重写 向上转型
继承 存在子类父类关系
重写 子类中对父类的方法进行重新定义
向上转型 子类的引用赋给父类 这样该引用才能调用父类的方法与子类方法
如 public class Fu{} Public class Zi extends Fu{} Fu zi = new Zi();

super关键字

子类中的构造方法中有一个默认的super() 调用父类的构造方法
1.在子类的方法中访问父类的成员变量 super.xxx
2.在子类中的成员方法中访问父类成员方法 super.show()
3.子类的构造方法中引用父类的构造方法 super(xxx)

抽象类abstract

抽象的概念:如果在父类中有的方法不确定具体的实现 那么可以把这个方法抽象出来，定义为抽象方法 ,抽象类也一样
方法: public abstract void do()
类: public abstract class do()

使用extends来继承父类
抽象类 不能直接new抽象类对象
必须要用一个子类继承父类(抽象类)
子类中的方法必须覆盖抽象父类中的所有抽象方法
创建子类来使用方法

接口interface

接口interface,是一种公共的规范,用来抽象出一些方法
其他的类使用implement来实现其中的方法 不能实例化
用电子产品来说明 抽象是一个电子的正方形 实现有多种类实现 如电阻 手机 电视 电脑这就是具体的实现
接口是一种引用数据类型 最重要的是其中的抽象方法
格式public interface 接口名{} 其中的内容可以包含 常量、抽象方法、 默认方法、静态方法、私有方法 接口中的方法是 public abstract 返回值类型 方法名{}

实现类的格式 public class 名称 implement 接口名称{}

内部类

一个类放在另一个类中的操作称为内部类。 内部类就是类中的属性 类的定义方式一致

内部类可以分为静态内部类 成员内部类 局部内部类 匿名内部类

静态内部类
一个类隐藏在一个类中的内部 并不需要内部类引用外围类对象 则可以使用static声明范围
静态内部类中的可以访问外部类中的所有静态变量 不能访问非静态变量
创建方式 new 外部类.静态内部类.

成员内部类
定义在类内部 不是用static修饰的类 就是成员内部类
这个内部类中可以访问 外部类的 所有变量 和方法 静态 非静态的 公有 私有
创建方式
外部类名.内部类名 对象名 = new 外部类名.new 内部类名();

局部内部类
定义在方法内部的类称为局部内部类
只有当前方法可以使用 出了这个方法不能使用
如果不是静态方法 可以访问外部类找那个的所有变量与方法
静态方法中只能访问静态方法与变量

匿名内部类
就是没有名字的内部类 使用较多
匿名内部类必须继承一个抽象类或实现一个实现一个借口
不能定义静态成员与静态方法
内部类必须实现或继承，接口或父类的所有抽象方法

对象与值

1.相等
== 的作用是判断两个对象的地址是不是相等 就是判断两个对象是不是来自同一个对象的
如果是基本数据类型 是值的比较，对于引用数据类型 比较的是内存地址

equals方法
object类中的equals方法用于检测一个对象是否等于另一个对象
string类中的equals方法用于比较对象的值
两种情况 类中没有覆盖此方法 比较的是对象是否来自同一个对象
类中覆盖此方法 比较的是对象内容是否相等

对象的相等 是比较内存中的内容是否相等
引用的相等 是比较指向的内存地址是否相等

2.值与对象的传递与对象中的拷贝
一个对象当做参数传递到一个方法之后 此方法改变对象的属性 并返回变化后的结果 此类的是值传递 Java中方法的调用只支持值的传递 传递时参数的值就是该对象的引用 对象的属性可以在过程中被改变 但对象引用的改变是不会影响到调用者。

方法中参数是值的传递时：

public static void main(String[] args){
	int a=1;
	int b=2;
	jiaohuan(a,b);   //输出的a,b是还是 1,2
}

例子中 jiaohuan中的值是a,b的复制，并不会影响主方法中的a,b的值
方法不能修改一个基本数据类型的参数

方法中的参数是对象时:

public static void main(String[] args){
  int[]  a1 = {1,2,3,4}
	jiaohuan(a1);   //把a1[0]中的改成0  输出的a1[0]=0
}

这个例子中是对象的引用 是一种对象的拷贝 方法中的对象与a1指向的是同一个对象的地址
对对象的属性改变是会改变。改变对象的参数的值 只要得到对象引用的拷贝 对象引用及其他的拷贝同时引用同一个对象。

3.方法中传递对象并交换对象

public static void main(String[] args){
   	S1 A = new S1("A1");
   	S2 B = new S2("B1");
   	swap(A,B);
   	输出内容;    A1  B1
}
public static void swap(S1 A,S2 B){
   S1 temp = x;
   x = A;
   A = B；
   B = x;
   输出内容;   B1  A1
}

方法并没有改变内存中A与B中的对象的引用，交换的函数只是交换的是对象引用的拷贝
没有在地址中交换对象。

Java中的对象是按值传递的
方法不能改变基本数据类型的参数
方法中可以改变对象参数的属性
方法中不能让对象参数引用到新的对象

值传递的是 值的拷贝
引用传递的是 对象引用的地址的传递

常用API

常用的包
java.lang:系统的基础类
java.io:输入输出有关类
java.net:网络相关类
java.util:系统的工具辅助类 如集合
java.sql:数据库操作类

string类中的方法与主要知识点

1.主要方法
创建: String s1 = “String”;

length() 返回字符串长度
replace() 字符串替换
split() 分割字符串 返回的是字符
equals() 字符串比较
indexOf() 返回指定字符串的索引
charAt() 返回指定索引处的字符
trim() 去除字符串两端空白
getBytes() 返回字符串的byte类型数组
substring() 截取字符串

字符型常量 是单引号引起的一个字符 相当于一个整型值(ASCII值) 一个字节
字符串常量 是双引号引起的若干字符 可以代表的是一个地址值 若干个字节

String与char有关
String不是基本的数据类型 基本数据类型 byte short int long float double char boolean
此外的都是引用类型

基本的数据类型中描述文本类型数据的是char 如‘a’ ‘是’ ‘字’ ‘母’等 但是想要组成一个句子
可以使用char数组 char[] char1 = {‘a’,‘是’,‘字’,‘母’}; 所以String可以简化char类型的数组
String底层就是char数组

String 是不变的 要改变的话能截取字符或使用+来拼接 其实拼接的改变是从原地址指向 另一个地址 是只读的 被final来修饰的类 不能被继承
String的底层被final修饰的char[]的字符数组

String Stringbuffer StringBuilder的区别是什么

Stirng中是字符数组保存 private final char value[] String是不可变的
StirngBuffer StirngBuilder是继承的AbstractStringBuilder类中 也是使用字符数组保存 char[] value 这两个对象是可变的

StringBuffer与StringBuilder是内存的缓冲器 容器可以使用append方法
String的拼接 截取都是改变指针指向新的String对象 StringBuffer对象本身不是新对象的改变

处理少量数据 使用String
单线程的使用 StringBuilder
多线程的使用 StringBuffer

包装类的知识点

包装类 把基本数据类型包装起来 的类叫包装类

装箱:把基本数据类型包装成引用类型的包装类
拆箱:把引用类型的转化为基本数据类型

Java希望把基本的数据类型当成对象操作

数据类型 int short long float double char boolean
包装类型 Integer Short Long Float Double Character Boolean

对应的包装对象 == 是比较的是对象的内存地址
基本数据类型 == 比较的是内容的值

日期时间类
java.util.Data类中的方法获取日期
Data data1 = new Data(); 获取当前日期

DateFormat类 日期格式化中的SimpleDateFormat(String,pattern)

SimpleDateFormat dateFormat = new SimpleDateFormat(“yyyy年MM月dd日 HH:mm:ss”) ; //使用了默认的格式创建了一个日期格式化对象。
String time = dateFormat.format(date); //可以把日期转换转指定格式的字符串

Calender日历类
无法直接创建对象 但里有一个静态方法getInstance()可以返回clalender类的子类对象
Calendar calendar = Calendar.getInstance(); //获取当前的系统时间。
System.out.println(“年：”+ calendar.get(Calendar.YEAR));
System.out.println(“月：”+ (calendar.get(Calendar.MONTH)+1));
System.out.println(“日：”+ calendar.get(Calendar.DATE));
System.out.println(“时：”+ calendar.get(Calendar.HOUR_OF_DAY));
System.out.println(“分：”+ calendar.get(Calendar.MINUTE));
System.out.println(“秒：”+ calendar.get(Calendar.SECOND));