CoreJAVA核心个人见解.docx
《CoreJAVA核心个人见解.docx》由会员分享，可在线阅读，更多相关《CoreJAVA核心个人见解.docx（29页珍藏版）》请在冰豆网上搜索。
CoreJAVA核心个人见解
CoreJava核心技术
一、概念：
1、配置Java的运行环境
在.bash_profile中添加环境变量：
exportCLASSPATH=.:
$CLASSPATH（系统去查找字节码，按字节路径搜索）ExportJAVA_HOME=./opt/jdk/（jdk的安装目录）exportPATH=$PATH:
$JAVA_HOME/bin:
$HOME/bin（按命令搜索的路径/jdk/bin类库文件：
rt.jar中有很多.class文件）想要在多个终端中使用需要source.bash_profile之后重启.且机器上装有JDK（用于开发里头的bin用于连接数据库文件lib用于java的归档文件）和JRE（由于运行）和JVM（用于跨平台）
没有主（main）方法的类是不可运行的，但可以编译
2、JAVA的特点：
简单（java可自动的回收垃圾）、安全（可以使用指针，但不可以对指针进行操作）、跨平台（通过JVM的技术从源码—字节码—jvm—系统通过字节码可在多种系统中运行java屏蔽了底层平台的差异统一了运行的环境）。
其产生于1995-5-23日
3、标识符命名规则
1）可以用数字、字符、字母、组成，不可以使用关键字
2）必须以下划线（_）或“$”或字母开头
3）严格区分大小写
a）类名和方法名一般都以大写开头之后的单词以首字母大写命名
b）变量和方法名一般都以首个单词小写后单词的首字母大写命名
c）常量一般都是大写的单词与单词之间以下划线（_）隔开，用final关键字定义
d）Java中有50个关键字，true、flaseh和null不是关键字但也不可用;goto、const是关键字但也不用再程序中使用；
Abstract
Continue
For
New
Switch
Assert
Default
Goto
Package
Synchronized
Boolean
Do
If
Private
This
Break
Double
Implements
Protected
Throw
Byte
Else
Import
Public
Throws
Case
Enum
Instanceof
Return
Transient
Char
Extends
Int
Short
Try
Char
Final
Interface
Static
Void
Class
Finally
Long
Strictfp
Volatile
Const
Float
native
Super
vhile
4、对类的定义（类名一般是以大写字母开头后面的单词的首字母大写）
在java文件中可以定义多个类，但最多只能有一个public类，而且该public类的类名必须与文件名一致
Java源文件在变异后形成的字节码文件数与该源文件中定义的类的个数相同，每个类的编译后形成对应的字节码文件
一个可运行的java必须包含一个main方法，该方法是程序运行的入口方法，main方法不一定包含在public的类中
PublicclassFirstJava{
Publicstaticvoidmain（String[]args）{
System.out.println（“hiMyFirstJava!
”）;
}
}
编译：
javacFirstJava.java
运行：
JavaFirstJava
Java的运行顺序：
1启动JVM虚拟机；2装载包（从当前类所在的包中找，在从jre/bin/***.jar中找，再从CLASSPATH中的路径中找；先找到那个就是用那个后面就不找了，如果找不到测出错）；3运行
5、package包的定义：
它可以大量的存放字节码功能相似或相同的类放在一个包中（一般的包名是小写）只有在java.lang包下的类可以无需导入其他都要用import导入一次可导入多个包importjava.util.*
1packagecom.tool;
PublicclassFirstJava{
Publicstaticvoidtest（）{
System.out.println（“hiMyFirstJava!
”）;
}
}
2packagecom.tool;
Importcom.tool.FirstJava;//调用包
PublicclassTestJava{
Publicstaticvoidmain（String[]args）{
FirstJava.test（）;
}
}
编译：
javacFirstJava.java–d.javacTestJava.java
Javadoc:
把取出注示文档放入一个.html文件中
把firstjava类打包成test.jar包放在个目录下:
jar–cvftest.jar.（-c:
创建；-v：
可视化；-f:
文件名）
删除com文件夹，改环境变量exportCLASSPATH=$CLASSPATH:
/home/soft01/myjava/test.jar在任何的目录下都可运行JavaTestJava
6、数据类型
类名
几位（bit）
范围
定义是标识
Boolean（布尔型）
True或False
Byte（字节型）
8
-2^7~2^7-1或-128~127
Chart（unidcod值）只有正数
16
0~2^16-1或0~65536
‘’
Short
16
-2^15~2^15-1或-32768~32767
Int
32
-2^31~2^31-1
Long
64
-2^63~2^63-1
L
Float
32
F或f
Bouble
64
D
注意：
Char、byte、short、int、long统称为整型，其中char是用补码存储的-1—11111111；127—01111111；-128—10000000其他是正的就是二进制源码，负的是源码取反加1；chara=’a’;intb=97;a=’\u0061’=’a’=b;Ox123:
表十六进制；o12433：
表八进制;char没有负数；
自动转化的从范围小的到大的Byte—>short—>int—>long—>float—>double以及char—>int也可自动转化；其他情形需要强制转化（类型），但boolean型无法强制转换成整型或浮点型，强制转换可能有数据和精度的丢失（与存储的空间的结构有关），也可能改变正负,大的取前几位，小的去后几位
Java的数据类型有三种：
基本数据类型（8种）。
引用数据类型（类、接口、枚举、标注A那你太anwtion。
Void；
7、对象引用
一个引用一次只能引用一个对象（一个地址；其保存的是一个空间的地址）；多个引用可以指向一个对象；没有任何引用的对象则该对象会被垃圾回收；引用对象的值为null时则会出现空指针异常
定义一个引用就是：
向系统申请一个新的内存空间
8、运算符的先后次序：
++、--、-（负）、+（正）、~（按位求反，单）、！
（逻辑非，单）、（数据类）、【算术】*、/、%、+、-、【移位】<<、>>、>>>、【关系】<、>、<=、>=、instanceof、==、!
=、【按位】&与（有0就是0，都为1时才是1；高4变0，低4不变）、^异或（相同的为0，不同的为1，高4不变低4求反）、|或（都0是为0，有1就是1；高4不变，低4变1）、【逻辑】&&、||、【条件】？
：
、【赋值】=、*=、/=、+=、-=、<<=、>>=、>>>=、&=、^=、|=
Inta=1;Inti=a++;则i=1；a=2
Inta=1;intb=++a;则i=2;a=2
9、
10、
二、程序
1、单层循环
1.If（条件）{语句1；}else{语句2；}
2.Switch（表达式或变量）{
Case值1：
语句1；break;
Case值2：
语句2；break;
Default：
语句n；
}
3.For（类型变量=初始值；条件；修正）｛
循环语句；
｝
4.While（条件）｛
循环语句；
｝
5.Do｛
循环语句；
｝while（条件）；
2、循环嵌套
For（inti=1,i<10,i++）{
For（intj=1,j<10,j++）{
System.out.print（i+”*”+j+”=”+（i*j））;
}
System.out.println（）;
}
三、方法
PublicstaticvoidfangFa（chara）{
}
四、面向对象
PublicclassOop（）{
PublicOop（）{//构造方法，方法名跟类名相同
}
PublicOop（inta）{//构造方法的重载
}
PublicstaticvoidfangF（）{
}
PublicstaticvoidfangF（ints）{//方法的重载，方法名相同，但参数的类型，个数，顺序要不同
}
}
PublicclasscarextendsOop（）{//继承类要加（extends）
}
方法的定义：
1.方法定义的类型与return返回值的类型匹配
2.方法定义中所声明的形参要与调用时的实参类型相同（能够自动转化也可以，比如调用的是double类型，返回的是int类型）
3.方法调用的语句要与他所处的上下文环境匹配
対形参的操作不会影响实参的值，丝毫不会影响主方法里的值
如果要对实参有影响
1）如果方法有返回值，主方法就又要使用了它
2）多个方法在操作同一个全局变量
3）方法使用了对象/引用类型作为形参，也会受到影响
实参——>形参传递过程：
（1）给主方法分配空间
（2）给方法分配空间
（3）给形参分配空间
（4）把实参转入形参中
（5）方法的代码执行完或碰到return，再跳回主方法，如果return有值，带回
（6）方法释放
构造方法的定义：
1.构造方法无返回值类型
2.不需要写任何返回值类型
作用：
生成对象，给对象的属性赋初值；
定义类时，如果程序员不定义构造方法，系统会自动给定义一个缺省的构造方法无参，实践
只有程序员自己定义了构造方法，缺省的构造方法也就不存在了
1、一旦确定关系，子类的构造方法一定会去调用父类的构造方法？
因为子类对象声称一定会生成一个父类的对象，创造一个子类对象就创造了一个父类对象。
This.类的内部用的
Super.子类与父类
构造方法的第一份只能出现this（）或super（），不能出现别的语句，如果程序员不写，系统会自动加上
重载：
一个类内部
方法覆盖：
父子类之间，方法的实现不同，同名
1.父子类方法同名，同参，返回值类型相同
2.子类访问控制修饰符不能比父类更封闭（）
3.子类抛出异常处理不能比父类宽泛
多态：
把子类对象当成父类对象使用时，只能调用父类里面有定义的属性和方法
调用子类中的move的方法，子类中的move方法父类中有定义，子类方法把父类方法覆盖了，调用的是子类覆盖之后的方法
强制转换前提是a本身要是个子类
编译器不会报错，强制转换不会由编译器检查，但运行时会异常（在强制转换前用instanceof来判断）
静态属性是类加载时候，当生成对象时，已经加载了静态类
在静态方法中不能访问非静态成员
静态的构造方法是不能被修饰的。
构造方法是与对象相关联的：
类也不能能用静态去修饰（有一些特殊的类可以修饰：
内部类）
方法中定义局部变量，也是不可以的
方法中的形参也不能去静态去修饰
一段静态代码块，相当于静态方法，这个方法没有名字，是无名静态方法，是被系统自动调用的，程序员是没办法去调用取它
静态代码块在类加载的时候，自动执行
实例代码块：
与后面的方法是并列的关系
每当创建对象的时候，会自动执行，程序员也没有方法去调用取它
Static：
实例
静态
访问方式
A.name
Animal.count
空间分配时机
创建对象时
类加载
空间分配个数
有多个对象就有多少空间
只有一个
不能访问非静态成员，属性、方法、内部类，静态代码块（没有名字）
类加载的时机：
1生成类的实例
2访问类的静态成员
3手动加载
Final：
修饰一个类，是一个最终的类，不能有子类
修饰一个属性：
值不可改变
修饰一个方法：
不能被子类覆盖
局部变量（形参）值是不可变的，即是一个常量
Publicfinalstaticinta=10；//只能在定义中赋值是用来说明类的特征不是用来说明对象特征
Finalstaticinta=10；//可在构造方法中赋值
Abstract:
抽象类的构造方法是为了子类的调用；
一个类，如果包含有抽象方法，那么这个类必须定义为抽象类，一个类没有抽象方法也可为抽象类。
抽象方法：
只有方法的声明，没有方法的实现，但它的子类可以使用抽象方法，可以满足多态的定理，抽象类必然要有子类，不然这个类就失去了意义abstract和final是不可以对立的，即不可同时使用
抽象类与普通类的最大区别是不能被实例化
抽象类的意义：
抽象类的子类可以实例化
PublicabstractclassAnimal{
PrivateStringname;
PrivateAnimal（Stringname）{
This.name=name;
}
Publicabstractvoidmove（）;
}
接口（implements）
1.所用方法必须是抽象方法
2.接口中所有定义的属性都是静态常量（staticfinal）
3.接口没有构造方法，不能实例化
4.一个类只能继承一个父类，但可以同时实现多个接口
5.一个接口可以同时继承多个接口（多继承）
接口：
是为了分离服务提供者和服务使用者，降低程序的耦合度，对上做了个承诺，对下定义了一个标注
子类
父类
关系
类
类
单一继承
类
接口
用implements多重继承
接口
接口
用extends多重
这个类实现了接口，实现方法相当于覆盖，相当于一个变向继承
1接口是没有构造方法
2接口也不能被实例化
3满足多态定理
PublicinterfaceAttackable{
Publicvoidattack（）;
}
PublicinterfaceMobile{
Inta=0;
Publicvoidmove（）;
}
PublicclassTankimplementsMobile,Attackable{
Publicvoidmove（）{
System.out.println（“tankmoving”）;
}
Publicvoidattack（）{
System.out.pirntln（“tankattacking”）;
}
}
PublicinterfaceWeaponextendsMobile,Attackable{
}
PublicclassTest{
Publicstaticvoidmain（String[]args）{
Tankt1=newTank（）;
T1.move（）;
T1.attack（）;
Mobilem1=newTank（）;
Attackablea=newTank（）;
M1.move（）;
M1.attack（）;//出错
}
}
Public
Protected
缺省
Private
Static
Final
Abstract
顶层类
可
可
属性
可
方法
可
局部变量
可（表：
常量）
成员式内部累
可
可
可
可
可
可，（表类内部不能有子类）
可
局部式内部累
可
可
四种数据控制符
内部类（insideclass）
同一个包下（thesamepackage）
继承的子类subclass
其它（other）
Public
都可以
Protected
可以
不可
Default（默认）
可
不可以
Private
可
不可以
其中接口只能用public和default修饰
Protected：
有两种保护，在包内可见，在保外不可见，在类的继承关系中可见
Private：
只在类的内部可见，不能用来修饰顶层类（顶层类是独立存在的类）
Default：
缺省权限在同一个包下可见，其它不可见、
Public：
可修饰属性、方法、类，但不能定义局部变量
【访问控制修饰符都不能修饰局部变量】
类只能用default和public来修饰（在用public的前提是有修改CLASSPATH环境变量指向这个类）
对象类：
Objectclone（）:
返回对象的拷贝（产生的是一个新的对象）
类的拷贝前提是：
１让类实现cloneable接口，２让类覆盖object clone（）方法public3当类中拷贝的是string对象是个引用类时，浅拷贝和深拷贝的效果是一样的
publicclassStudentimplementsCloneable{/
publicObjectclone（）throwsCloneNotSupportedException{
returnsuper.clone（）;
//要抛出异常,覆盖系统本身的clone（）
}
publicbooleanequals（Objectobj）{//对equals方法的覆盖，比较这个类的是否相同，在原始的equals方法是用==的结果，它满足反生性、传递性、一致性、对于任何非空引用值、对杂尔性
if（objinstanceofStudent）{
Students=（Student）obj;
if（this.name.equals（s.name）&&this.age==s.age）{
returntrue;
}
}
returnfalse;
}
}
publicStringtoString（）{//覆盖tostring方法
returnname+":
"+age;
}
publicstaticvoidmain（String[]args）throwsException{//把所有异常都抛出
Students=newStudent（"zhn",21）;
Students2=（Student）s.clone（）;//重写方法clone，再次调用，要抛出异常
System.out.println（s.toString（））;
System.out.println（s）;//自动调用tostring方法
//在没有覆盖tostring方法时，输出的是包名.类名@地址值，覆盖后则
｝
分浅拷贝和深拷贝
浅拷贝：
一般是值对值的拷贝；是内存空间的一对一的拷贝，如果拷贝则只考了地址值，那么它们的地址指向的是原来的地址
深拷贝：
把拷贝的对象所有的引用的对象都复制了一遍，从物理上完全分解开了
Finallize（）
方法被垃圾收集器自动调用，垃圾收集器可能根本不执行，此方法不能保证一定执行
它与构造方法相反，它是负责对象消亡时的资源释放，构造方法负责对象创建后的初始化。
Tostring
字符串常用的有：
string，stringBuffer，stringBuilder
在平凡改变值是用stringBuffer和stringBuilder，当用
在内存中形成一个对象池,把这个类放入了对象池，对象池为了提高系统
//s3是不会在对象池中找的，只会在创建一个新的字符串对象，跟一个普通的类一样
//在news3时系统创建了两个对象，有双引号的字符在池中找，new出来的对象
Strings4=null;
Strings3=newString（s4="hello"）;//当s3在后面是则只创建一个对象
Stringsa="hello";
Stringsa2="hello";
//s5,sa是同一个对象，这是编译器把s5优化为s5＝“hello”所以sa跟s5是相等的
Strings5="he"+"llo";
Strings6="he";
Strings7=s6+"llo";//因为s6是个变量，编译器不会优化
System.out.println（s5==s7）;//false:
System.out.println（s5==sa）;//true:
System.out.println（s7==sa）;//false:
System.out.println（s3==s4）;//说明news3时创建了两个对象
System.out.println（sa==sa2）;//在同一个对象池中的地址
System.out.println（sa==s3）;//要是用equals则都相同
字符串对象的值是不可改变的，
Stringa="hello";
a=a+"hehe";//不是改变了值，创建了新的对象，原来的a还在对象池中
System.out.println（a）;
StringBuffer有thread.Safe（线程安全的字符序列）
在多线程的环境中，对数据访问的代码加锁，支持多线程访问，效率底；
多线程：
多条并发执行的工作程序，对单个CPU的没有多线程，在多个CPU多线程执行，同时访问一个数据是可能被覆盖
StringBuilder
线程不安全，对数据访问的没有加锁，不支持多线程，实现效率低
但以上的完成的功能是一样的
Varargs（方法的可变长参数）
…表：
一个或多个参数
主方法的参数：
其实是一个字符串数组，它是由JAVA的虚拟机jvm传入的，也可以用命令行传入。
设置主方法传入的参数右击——run——runconfiguration——选argument选项卡——在programarguments中输入——ok；
把主方法中的参数改为：
string…arg也可以运行
/**
*String[]和String...的区别
*String...即可传数组作参数也可以用一个或多个字符
*而String[]只能传数组
*/
//虚拟机把多个参数包装成数组传给主方法参数
publicstaticvoidmain（String[]args）{//把主方法的参数该为String...args也可以运行
//TODOAuto-generatedmethodstub
String[]ss={"hello","haha","hehe"};
m1（"a
升级会员 