标签：默认 通过 情况 比较 语法 匹配 als 自动类型转换 tar
总结：学习Java这门课程已经一学期了，也学习到了一些Java的知识。个人感觉Java还是一门计较重要的课程。Java的概念太多了，对于Java方面的概念不太清楚。觉得多打代码会提高自身的水平，还是需要多打代码。
Java中的包、类、方法、参数和变量的名字，可由任意顺序的大小写字母、数字、下划线（_）和美元符号（$）组成，但标识符不能以数字开头，不能是Java中的保留关键字。
1、在Java中goto和const没有任何的意义
2、assert是在JDK 1.4之后增加进来的
3、enum是在JDK 1.5之后增加进来的
各种数据类型的数据可以放在一起进行混合运算，运算时，不同类型的数据先转换为相同类型的数据再进行运算。
数据类型之间的转换分为自动类型转换和强制类型转换。
自动类型转换
从低级到高级发生自动类型转换。
强制类型转换
由高级向低级数据类型转换时，需要进行强制类型转换，在变量前面，把需要转换的“目标类型”放到圆括号（）内。
数组是一组相关数据的集合，一个数组实际上就是一连串的变量，数组按照使用可以分为一维数组、二维数组、多维数组。
方法的定义格式：
public static 返回值类型 方法名称（类型 参数1，类型 参数2，…）{
方法的主体
程序语句 ；
[return 表达式]；
}
方法的重载就是方法名称相同，但参数的类型和参数的个数不同，通过传递参数的个数及类型不同以完成不同功能的方法调用
System.out.println()方法也属于重载方法
递归调用是一种特殊的调用形式，是方法自己调用自己 。
面向对象的三大特征:
封装（Encapsulation）:
对外部不可见
继承（Inheritance）:
扩展类的功能
多态（Polymorphism）:
方法的重载
对象的多态性
class 类名称{
数据类型 属性 ;
….
public 返回值的数据类型 方法名称（参数1，参数2…）{
程序语句 ;
[return 表达式;]
}}
类名 对象名称 = null ; // 声明对象
对象名称 = new 类名() ; // 实例化对象
类名 对象名称 = new 类名() ;
访问属性：对象名称.属性名
访问方法：对象名称.方法名()
为属性封装：private 属性类型 属性名称 ;
为方法封装：private 方法返回值 方法名称(参数列表){}
对象的产生格式：
类名称 对象名称 = new 类名称()
class 类名称{
访问权限 类名称（类型1 参数1，类型2 参数2，…）{
程序语句 ;
… // 构造方法没有返回值
}
}
构造方法的名称必须与类名称一致
构造方法的声明处不能有任何返回值类型的声明
不能在构造方法中使用return返回一个值每个类中肯定都会有一个构造方法。
如果一个类中没有声明一个明确的构造方法则会自动生成一个无参的什么都不做的构造方法。
只使用一次的对象，称为匿名对象。
匿名对象只在堆内存中开辟空间，而不存在栈内存的引用。
直接赋值
通过关键字new
String的比较有两种方式。
==：地址值比较。
equals()方法：内容比较。
String类中的常用方法
表示类中的属性
可以使用this调用本类的构造方法
this表示当前对象
如果一个类中有多个构造方法的话，也可以利用this关键字互相调用。
假设现在要求不管类中有多少个构造方法，只要对象一被实例化，就必须打印一行“新对象实例化”的信息出来，很明显，此时如果在各个构造方法中编写此输出语句肯定不合适，所以此时就可以利用this的概念完成。
使用this调用构造方法必须也只能放在构造方法的第一行。
在程序中使用static声明属性的话，则此属性称为全局属性
使用static声明方法
static既可以在声明属性的时候使用，也可以用其来声明方法，用它声明的方法有时也被称为“类方法”。
static调用限制
非static声明的方法可以去调用static声明的属性或方法的。但是static声明的方法是不能调用非static类型声明的属性或方法的。
public：表示此方法可以被外部所调用。
static：表示此方法可以由类名称直接调用。
void：主方法是程序的起点，所以不需要任何的返回值。
main：系统规定好默认调用的方法名称，执行的时候，默认找到main方法名称。
String args[]：表示的是运行时的参数。
参数传递的形式：java 类名称 参数1 参数2 参数3 ….
在Java中使用extends关键字完成类的继承关系，操作格式：
class 父类{} // 定义父类
class 子类 extends 父类{} // 使用extends关键字实现继承
继承的限制
在Java中只允许单继承，不能使用多重继承，即：一个子类只能继承一个父类。但是允许进行多层继承，即：一个子类可以有一个父类，一个父类还可以有一个父类。
访问限制
在使用继承的时候也应注意的是：子类是不能直接访问父类中的私有成员的，但是子类可以调用父类中的非私有方法，但是不能直接调用父类中的私有成员。
在继承的操作中，对于子类对象的实例化也是有要求的：“子类对象在实例化之前必须首先调用父类中的构造方法之后再调用子类自己的构造方法”。
方法的覆写
在继承的关系中也存在着方法覆写的概念，所谓的方法覆写就是指子类定义了与父类中同名的方法，但是在方法覆写时必须考虑到权限，即：被子类覆写的方法不能拥有比父类方法更加严格的访问权限。
如果在父类中使用public定义的方法，子类的访问权限必须是public，否则程序会无法编译。
属性的覆盖
在继承中除了方法可以覆写之外，属性也可以覆盖，所谓的属性覆盖就是指子类声明了与父类同名的属性。
方法的重载与覆写的区别
super关键字的作用
使用super可以从子类中调用父类中的构造方法、普通方法、属性。
this与super的区别
可以使用final关键字声明类、属性、方法。
使用final声明的类不能有子类；
使用final声明的方法不能被子类所覆写；
使用final声明的变量即成为常量，常量不可以修改。
使用static final关键字联合声明的变量称为全局常量：
包含一个抽象方法的类必须是抽象类；
抽象类和抽象方法都要使用abstract关键字声明；
抽象方法只需声明而不需要实现；
抽象类必须被子继承，子类（如果不是抽象类）必须覆写抽象类中的全部抽象方法。
抽象类的定义格式
abstract class 抽象类名称{
属性 ;
访问权限 返回值类型 方法名称(参数){ // 普通方法
[return 返回值] ;
}
访问权限 abstract 返回值类型 方法名称(参数) ; // 抽象方法
// 在抽象方法中是没有方法体的
}
一个抽象类不能使用final关键字声明
子类在实例化之前肯定是先要对父类进行实例化的
接口是java中最重要的概念，接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。
接口的定义格式
interface 接口名称{
全局常量 ;
抽象方法 ;
}
实现接口
与抽象类一样，接口要使用也必须通过子类，子类通过implements关键字实现接口。
实现格式：
class 子类 implements 接口A,接口B,...{
}
继承抽象类实现接口
一个子类可以同时继承抽象类和实现接口。
格式如下：
class 子类 extends 抽象类 implements 接口A,接口B,...{}
接口和抽象类的使用限制
在java中允许一个抽象类实现多个接口的
接口的继承
一个接口不能继承一个抽象类，但是却可以通过extends关键字同时继承多个接口，实现接口的多继承。
格式：
interface 子接口 extends 父接口A,父接口B,...{}
多态性在面向对象中中是一个最重要的概念，在java中面向对象主要有以下两种主要体现：
方法的重载与覆写
对象的多态性
对象的多态性
对象的多态性主要分为以下两种类型：
向上转型：子类对象 ? 父类对象
对于向上转型，程序会自动完成，格式：
对象向上转型：父类 父类对象 = 子类实例 ;
向下转型：父类对象 ? 子类对象
对于向下转型时，必须明确的指明要转型的子类类型，格式：
对象向下转型：子类 子类对象 = (子类)父类实例 ;
在进行对象的向下转型之前，必须首先发生对象向上转型才可以，否则将出现对象转换异常。
在java中可以使用instanceof关键字判断一个对象到底是那个类的实例。
对象 instanceof 类 ? 返回boolean类型
抽象类与接口之间的关系
在Java中所有的类都有一个公共的父类就是Object类，一个类只要没有明显的继承一个类，则肯定是Object类的子类。如下两种代码表示的含义都是一样的：
class Person extends Object{}
class Person{}
Object类中的主要方法
toString()方法
在直接输出对象时会默认调用类中的toString()方法
equals()方法
equals()方法的主要功能是进行对象的比较操作。
String本身也是Object类的子类，所以已经覆写了此方法。
异常是导致程序中断运行的一种指令流
异常处理格式
try{
// 有可能出现异常的语句
}catch(异常类 异常对象){
// 编写异常的处理语句
}[ catch(异常类 异常对象){
// 编写异常的处理语句
} catch(异常类 异常对象){
// 编写异常的处理语句
} …. ]
[finally{
一定会运行到的程序代码 ；
}]
异常类的继承结构
在整个java的异常结构中，实际上有以下两个最常用的类：Exception、Error，这两个类全都是Throwable的子类。
Exception：一般表示的是程序中出现的问题，可以直接使用try…catch处理。
Error：一般指的是JVM错误，程序中无法处理。
Java的异常处理机制
一旦产生异常，则首先会产生一个异常类的实例化对象；
在try语句中对此异常对象进行捕捉；
产生的异常对象与catch语句中的各个异常类型进行匹配，如果匹配成功，则执行catch语句中的代码。
在定义一个方法的时候可以使用throws关键字声明，使用throws声明的方法表示此方法不处理异常，而交给方法的调用处进行处理 。
throws使用格式
public 返回值类型 方法名称(参数列表…) throws 异常类{}
与throws不同的是，可以直接使用throw抛出一个异常。抛出的时候直接抛出异常类的实例化对象即可。
这两个类的区别如下：
Exception在程序中是必须使用try…catch进行处理。
RuntimeException可以不使用try…catch进行处理，但是如果有异常产生，则异常将由JVM进行处理。
在Java中已经提供了大量的异常类，但是这些异常类有些时候也很难满足开发者的要求，所以此时用户可以根据自己的需要定义自己的异常类，定义异常类，只需要继承Exception类即可。
在Java中要想实现多线程代码有两种手段：
一种是继承Thread类
另一种就是实现Runnable接口
Thread类是在java.lang包中定义的，一个类只要继承了Thread类，此类就称为多线程操作类。在Thread子类之中，必须明确的覆写Thread类中的run()方法，此方法为线程的主体。
多线程的定义语法：
class 类名称 extends Thread{ // 继承Thread类
属性… ; // 类中定义属性
方法… ; // 类中定义方法
// 覆写Thread类中的run()方法，此方法是线程的主体
public void run(){
线程主体;
}
}
如果要想正确的启动线程，是不能直接调用run()方法的，应该调用从Thread类中继承而来的start()方法，才可以启动线程。
mt1.start(); // 启动多线程
mt2.start(); // 启动多线程
在Java中也可以通过实现Runnable接口的方式实现多线程，Runnable接口中只定义了一个抽象方法：
public void run() ;
通过Runnable接口实现多线程：
class 类名称 implements Runnable{ // 实现Runnable接口
属性… ; // 类中定义属性
方法… ; // 类中定义方法
public void run(){ // 覆写Runnable接口里的run()方法 线程主体 ;
}
}
如果一个类继承Thread类，则不适合于多个线程共享资源，而实现了Runnable接口，则可以方便的实现资源的共享。
实现Runnable接口相对于继承Thread类来说，有如下显著的优势：
适合多个相同程序代码的线程去处理同一资源的情况。
可以避免由于Java的单继承特性带来的局限。
增强了程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。
要想实现多线程，必须在主线程中创建新的线程对象。任何线程一般具有五种状态，即创建、就绪、运行、阻塞、终止。
一个多线程的程序，如果是通过Runnable接口实现的，则意味着类中的属性将被多个线程共享，那么这样一来就会造成一种问题，如果这多个线程要操作同一资源的时候就有可能出现资源的同步问题。例如，以之前的卖票程序来讲，如果多个线程同时操作的时候就有可能出现卖出票为负数的问题。
在代码块上加上“synchronized”关键字的话，则此代码块就称为同步代码块。
同步代码块格式：
synchronized(同步对象){
需要同步的代码 ;
}
除了可以将需要的代码设置成同步代码块之外，也可以使用synchronized关键字将一个方法声明成同步方法。
同步方法定义格式：
synchronized 方法返回值 方法名称(参数列表){}
标签：默认 通过 情况 比较 语法 匹配 als 自动类型转换 tar
原文地址：https://www.cnblogs.com/hltltp/p/12032171.html
