java基础最全(包括jdk,ecilpse各个软件的安装下载步骤以及下载地址)

2019/7/24 16:06:42 人评论 次浏览 分类:学习教程

在这里插入图片描述

项目构建:

环境搭建:先安装JDK

   下载地址:

http://www.oracle.com/technetwork/java/javase/archive-139210.html
JDK注意事项:
1.jdk文件夹 jre:(建议用jdk里面的jre) bin目录: java命令和javac命令 src: java的源代码
2.jre文件夹 jvm lib类库: 要注意rt.jar这个包

环境搭建:安装eclipse

       Eclipse下载地址:

http://mirrors.ibiblio.org/pub/mirrors/eclipse/eclipse/downloads/drops/

1.解压就可以
2…metadata,存储的eclipse的配置
3.eclipse跟jdk绑定 默认绑定外部的jre 建议绑定内部的jre
eclipse跟jre绑定,改成绑定内部的jre的步骤:
windows-preference-java-installed jres- add(standard vm)–选择一个jdk中的jre
4.设置整个eclipse工作环境的编码
-eclipse配置整个工作空间的编码
windows-preference-general-workspace-text fileencoding-utf-8
5.设置jdk编码等级(有时我们需要在工作时需要适应别的版本的jdk,就需要我们降低等级)
方式一:统一对当前工作空间中的所有的项目做编译等级的设置
windows-preferences-java-complier-jdk compliance level
方式二:对指定的项目做编译等级设置
右击单机要设置的项目名称 windows-preferences-java-complier-jdk compliance level
6.注意:创建java工程包名必须小写,例如:wo.project.test 包名用.间隔,事实是文件夹和子文件夹
7.创建类的名字, 要满足帕斯卡命名法
帕斯卡命名法:所有单词的第一个字母为大写,一般情况下用对类名的定义
8.根据实际的业务写java代码 run as —>java application

java基本语法

1.java的注释:目的是:给出提示性语言,标记某些代码不生效
//单行注释
//多行注释
/
*/文档注释
2.java的数据类型:
规定八种基本数据类型的目的(重点)?
限定数据范围
占用内存空间
java是强类型语言,任何数据必须指定类型
八种基本数据类型:
byte 1个字节
char 2个字节(字符型)
short 2个字节
int 4个字节
long 8个字节(以L或l结尾)
float 4个字节(以F或f结尾)(浮点型)
double 8个字节(浮点型)
boolean (布尔型)
定义变量的规范:可以有数字,字母,_和$
就是不能以数字开头
变量的定义:数据类型 变量名
数据类型 变量名=值
3.运算符:
赋值运算符 =
算数运算符+ - * / % ++ – += -= *= /= %=
类型转换: 大容器=小容器 自然转换
小容器=大容器 强制转换(需要强转)
逻辑运算符:& | ! && ||(短句操作建议使用)
关系运算符: > >= < <= == !=
这几种运算符的优先级:()>!>算数>关系>逻辑(&&>||)>赋值
三元运算符: 类型 变量=(条件)? 表达式1 : 表达式2
(其本质是一个if -else)
4.if结构:
if(条件){
//条件成立执行此处
}else{
//条件不成立执行此处
}
if(条件1){
//条件1成立执行此处
}else if(条件2){
//条件2成立执行此处
}
5.switch结构:
多数用于等值判断
switch(表达式){
case 常量1:
代码块
break;
case 常量2:
代码块
break;

case 常量n:
代码块
break;
defalut:
代码块
break;
}
表达式类型:整型,字符型,枚举型, 注意:字符串(jre版本1.7及以上才能使用字符串)
6.循环结构:while(条件)循环,do-while(条件);循环,for循环,增强for循环,我们一般经常使用while循环
7.debug(必须掌握,重点):
F5 step into进入方法里面
F7从方法里面跳出来
F6 step over下一步
F8 resume结束或者恢复
8.数组:
(1)数组的特点:
所有的数组元素的类型必须是同一个类型
在内存中要开辟连续的空间
优点:能够存储多个同一类型的数据
缺点:不能存储多个不同类型的数据,不能动态增长数组的空间
需要用System.arraycopy() java.util.Arrays.copyOf()增长数组空间
System.arraycopy() java.util.Arrays.copyOf()具体使用步骤见此链接
https://blog.csdn.net/weixin_45386575/article/details/96307701
(2)数组的使用步骤:
声明数组 类型[] 数组名称 数组没有申请内存空间,在程序中能使用,但是会报NullPointerException
申请堆空间 数组名称=new 类型[长度]
注意数组的默认值 数字类型 0 字符型 \u0000 对象型 null
给数组元素赋值,根据需求 数组名[下标索引]=新值
特殊: int[] ages=new int[]{1,2,3,4,5}
int[] ages={1,2,3,4,5}
(3)数组的排序和复制: https://blog.csdn.net/weixin_45386575/article/details/96307701
(4)二维数组:由多个一维数组组成的,在内存中还是连续的空间

面向对象:

面向对象的目的: 把现实世界的物或事转换到计算机中
把现实世界的物或事对应到计算中的"类"上

什么是类: 类是一种数据结构
程序员根据实际需求转成类
定义类语法简单,但类中写属性和方法是难的
通过类类型去堆内存中申请(new)内存空间
一个类类型,可以申请很多的对象的空间
例如:
Student stu1=new Student();
Student stu2=new Student();
用类把现实世界对象和内存的对象联系起来

类和对象在内存中的存储机制:
方法区:类的定义,静态内容,常量池
堆区:数组的数据,对象的数据,能 new 的都放在堆区,是由程序员通过栈来访问堆区
栈区:八种基本数据了类型,堆区中的地址,弹栈了,不能使用基本数类型或对象类型
访问关系:在栈区取出堆区的地址或直接使用八种基本数据类型
从栈区取出堆中的地址,就可以访问对中的数据
用对象名调用方法,事实上访问的方法区的方法
给对象存储数据并保证安全:
属性是私有的,方法是公有的(getter setter )公有方法中可以写严密的逻辑
构造方法,只能给对象存储数据
成员变量,和局部变量:
成员变量存储在堆里面,而局部变量存储在栈里面
值传递和引用传递:(本质一份内存空间还是两份内存空间的问题)
值传递:方法的参数传递的是基本数据类型 栈中的数据,2份内存空间
引用传递:方法的参数传递的是数组或对象 堆中的数据,1份内存空间
this.和this() :
this指向是当前对象 , this在不同的时候指向的是不同的对象
this在哪个方法里,且这个方法 被哪个对象调用,this就只想那个对象
this() 调用本类其他的构造函数
代码块:类中的代码块和方法中的代码块
类中的代码块:执行在构造函数体之前,其实执行的时候先到构造,但不执行构造体
方法中的代码块:限定变量的作用域
final:
final修饰在变量 成员变量声明的时候必须给初值,
局部变量 可以先声明,后赋值,赋值只能赋值一次
final修饰在方法上:final方法不能被重写
final修饰在类上:final类不被继承,例如:String类就final类 不能被继承

静态static:
static修饰成员变量,不能修饰局部变量,在方法区中
static修饰在方法上 用类名访问静态方法(建议)
static修饰在代码块 静态代码块在类加载的时候执行
访问规则 在静态方法中不能使用this
static+final:
静态且常量,一般是公有的
名字一般都是大写的,但是单词间用_间隔
一般在整个系统中写一个系统常量类
重载:
在同一个类内
方法名字要一样
参数的个数和类型不能一样
访问的修饰符:
public 本类中,子类中,同包类中,其他类中
protected 本类中, 子类中,同包类中
默认 本类中,同包类中
private 本类中

equals和==:
==两边是基本数据类型,判断的是变量中的值
==两边是对象,判断的是对象的地址是否相等
equals是Object类中的方法,且是判断的是地址
在子类重写equals方法,方法内容由程序员定制

instanceof运算符:
左边是对象
右边是类类型
判断左边对象是否是右边的类型的对象
返回结果boolean类型
面向对象特点:
封装:把属性和方法封装到一个类中
方式一
私有的属性
公有getter and setter 构造
适合存储数据
方式二
类中封装功能方法
方法所有需要操作的从方法的参数组合
用类的属性组合
继承:用extends关键字来继承,且只能继承一个类,单一继承
使用继承可以做代码复用
继承中的数据存储
new子类对象的时候,先调用父类的构造方法,
不但出现了子类对象,还出现了父类对象
各存储各自的数据
子类不是拥有长辈的东西,只是对长辈的方法或属性具备访问性
继承中的方法的处理:在子类中重写长辈类中的方法
一般情况下长辈和子辈的方法声明一样即可
方法声明不一样规则:
方法重写的若干要求
1.子类重写的方法的权限修饰符必须大于等于父类
2.子类中重写的方法的返回值类型必须小于等于父类
3.如果父类中的方法的返回值是基本数据类型或void
那么子类在重写方法的时候,返回类型必须一致
4.如果父类的返回类型是最终类(final),那么子类
在重写方法的时候,返回类型必须一致
super关键字
少用继承多用组合,用组合的方法:1.在类的属性中组合2.在类中的方法参数组合
抽象类:是由abstract修饰
部分方法是抽象方法,即没有方法体
类中只要有一个抽象方法,此类就是抽象类
抽象类不能实例化
抽象类只能做父类
在子类中重写长辈抽象方法
直到所有的抽象方法都给了具体的实现,才卡伊实例化对象
接口:
用interaface关键字
子类用哪个implements关键字实现接口
子类类可以实现多个接口,接口间用逗号间隔
接口中是可以放属性,但默认是public static final
不适合存储数据
接口放置方法,但方法都是抽象的public abstract的方法
适合表达功能
子类必须实现接口中的所有的方法
接口是对象项目功能规范
接口就是功能规范
接口不能实现接口,但可以继承接口,可以继承多个接口,多个接口用逗号间隔
接口中没有构造方法
多态:
判断多态的原则:
跨类且继承
子类重写长辈类的方法
子类对象赋值长辈的引用
用长辈的引用打点调用方法:
能调用出哪些方法取决于左边类或接口中有哪些方法
如果重写过,就执行子类中的重写过的方法
如果没有重写过,就执行,本引用自己的方法
应用的场景:
以长辈作为函数或方法的参数
以长辈作为函数或方法的返回值
对象的多态:
用长辈的引用,可以引用不同子类对象
用长辈的引用,可以引用不同子类对象
方法的多态:就一个方法,可以有不同子类实现的功能
应用:
所有的子类共有的方法抽象到接口中,只适合放功能方法
做抽象类实现接口,放置共用的属性或重写接口的方法,或添加新的方法
再做子类继承抽象类
… 直到多有的方法都给上实现,就可以实例化对象了
内部类:
类里放类
外部类中访问内部类
在外部类中实例化内部类的对象,用对象打点调用内部类的属性和方法
通过内部类的对象访问内部类中的所有的属性和方法,
前提是在外部类中实例化内部类的对象
OuterClass.InnerClass ic=new OuterClass().newInnerClass();
内部类中访问外部类
直接使用外部类中的内容
方法里放类:
外部类访问内部类
在内部类中定义的下面,实例化内部类的对象,
通过内部类对象打点调用内部类里所有属性和方法
内部类的作用域,从定义开始到第一个右大括号结束
内部中访问外部类
直接访问外部类中的内容
匿名内部类:
没有类名字,但有{属性和方法}
new 长辈(){重写的方法}
一般情况实现功能只有一次的是用匿名内部类
单元测试:
测试程序员写方法是否正确
单元测试的代码都写在test的sourcefolder中
需要依赖junit的jar包
junit3:
测试类继承自junit.framework.TestCase
测试方法必须以test开头
setUp方法,所有测试方法前执行的,做初始化工作的
junit4:
建议测试方法以test开头
测试方法前些注解@Test
@Before,所有测试方法前执行,做初始化工作的
异常 :
java中有三种错误:
1.语法错误/编译错误:
在ide(集成开发环境)工具中(eclipse,myeclipse等)
中写代码,代码写错了,在工具用红波浪线或红叉来表示
如果显示红波浪线,此代码是不能通过工具进行编译的,不能编译,就不能执行

				      2.逻辑错误:
					     前提没有语法错误,程序能编译,能运行,但结果是错误的
						 一般原因就是代码的逻辑写错了,最中结果也是错的
				         
						 
					  3.运行错误/异常/例外:
					      前提是逻辑没有错误,但在运行期间以内因为某种原因导致错误,程序意外终止,
						  这种错误就叫做异常
						  一定要注意,异常是运行期间发生的
						  比如:
						   int num1,num2;//这两个值需要从键盘录入
						   int result=num1/num2;
						      如果num2录入的是非零值,程序可以正常运行,没有异常
							  如果num2录入的是零值,程序能正常运行,代码逻辑正确,有异常,且程序终止
					有了异常,最直接的结果,就是结果终止了,这不是程序的目的
				所以要处理异常,处理异常的目的有两个:
				   1.避免程序意外终止
				   2.如果出现了异常,程序不能终止,还要给一个有好的提示
				程序意外的终止:就是程序执行到某一个位置的时候,不执行了
				jvm就不再执行这个程序了
				
				处理的方案有两种:
				方案一:
				    用java代码提供的异常处理机制 try catch finally
				fanganer:
				   用java的代码逻辑来处理,即用java代码的容错	
				
				 用java的try catch finally的一些相关的注意事项
				   一般情况下try块中监视的代码,需要程序员猜测try块中
				   有多少种可产生的异常,在try块中代码可能有n种异常
				   那么就在try块的下面写n个catch,且catch抓取的异常类型是不同的
				   如果发生了异常但是没有catch来抓住,程序还是意外终止
				   为了解决这个问题,需要添加第n+1个catch,这个catch的异常类型是
				   Exception异常类型,即catch(Exception e),且此catch必须放在
				   所有的catch的最后
				   
				   一个try可以有零个或一个或多个catch
				   一个try可以没有catch,但必须有finally
				   
				   什么是finally:
				   finally快中放置若干java代码,一般情况下,finally块中的代码
				   是用来释放try块中申请的内存空间
				   
				   
				   try块中如果有异常,会抛出异常,在某一个catch块接收到系统抛出的异常
				   (必须保证catch抓取的异常类型,跟抛 出的异常类型相同)
				   ,然后对应catch块中的代码就别执行了,catch块一般有类代码,
				   一个是栈的轨迹,另一个是友好的交互或提示的代码
				   执行完当前的catch块中的代码后,会跳出所有的catch块,执行finally块中的代码,
				   执行完finally块中的代码后,继续执行finally块后面的代码,
				   即没有异常,最终都会执行finally,用户销毁内存空间
				   
				   
				   异常的继承层次:
				      顶级类:Throwable
					  Throwable类有两个子类
					  Error:不是程序员能使用的,一般情况下是jvm使用的
					         比如:
							    要往u盘中写入一个文件,但没有u盘这个设备
								异常错要抛给jvm来处理
					  Exception类:是程序员能够写代码的异常的根类
					  分为两类别:
					  
					     -免检异常:不是必须添加try catch finally的 
						            程序是能够编译和执行 ,执行时
						            触发的符合的异常程序还是意外终止
								RuntimeException   运行时异常
								ArithmethicException    算数异常
								NullPointerException    空指针异常
								ArrayIndexOutofBoundsException  数组下标越界异常
								NumberFqrmatException  数字格式异常
								InputMismatchException   
						 -必检异常:必须添加try catch finally  如果不添加,
						    则会有红波浪线提示,说明程序不能编译和执行
				   
				          Exception    所有程序猿能够处理的异常的根类
						  SQLException  sql异常
						  ClassNotFoundException 类没有有发现异常
						  FileNotFoundException  文件没有发现异常
						  
						  .....
						  
						 如果判断异常时时免疫还是必检
						   如果程序员在写代码的时候,代码没有错误,但报了红波浪线并提示
						   "Unhandled exception typoe XXXException"
						   无法处理    异常    类型   具体的异常类型
						   
						   只要提示这句话,那么就属于必检异常
						   
						   必检异常必须添加 try  catch.否则红波浪线不会消失
						   快捷键alt+shift+z
				   
				   
				throw:在java中,有一个Exception类,这个类有很多的子类
				每个子类都对应一种异常类型,这些异常类型都是java
				类库自带的异常类型
				
				NullPointerException
				ArrayIndexOutofBoundsException
				类似这些异常都是java的低昂一万的规则,触犯规则就跑异常
				即,系统定义的规则,系统检测到就由系统抛出
				
				java中不可能把所有的项目中遇到的异常都是先写好异常类
				
				由程序员根据实际业务需求抛出异常
				  比如:
				    要求年龄在1到100岁之间,如果不在范围内就抛出相应的异常
					程序员定规则,程序员用java代码检测,由程序员抛出
					实现的方式有两种:
					  方式一:
					  用try catch  finaly
					  方式二:
					    用java的逻辑代码来处理
				
				
				
				      
				
				throws:   
				throws关键字放在方法声明的后面,可以写很多个异常类型
				之间用逗号间隔,表明此方法体可能会抛出异常,这些异常类型都是java不在当前的方法体中
				用try catch finally处理,谁调用此方法
				谁就用try catch finally来处理
				
				注意:Exception类型必须放在throws后所有异常类型的后面
				
				throws的应用场景:一般情况下写类库的时候,类库是提供给其他项目使用的,类中的方法如果有异常
				就适合用throws抛出
				然后谁调用方法,谁就用try catch来处理.
				自定义异常:
				程序员自己创建的java类,但是必须继承自Exception及其子类中
				的任何类都可以,那么此类就适自定义异常类
				自定义异常类,是作为本项目的异常类型补充
				
				应用场景:
				  java不可能把所有的项目中出现的异常,都事先准备好
				  所以,程序员根据需求自定义异常类,在自定义的异常类
				  提供异常错误信息				

垃圾收集管理器GC:
收集的是堆内存的数据
堆内存分类
新生代
伊甸园区 Eden 8
所有的对象创建在此区中
幸存区 survivor 1
扫描一次,eden区,对象存在就移到本区
幸存区 survivor 1
长期系统保留
老生代
经过多次扫描还在,就移到本区

api:

集合api:
List接口和Set接口继承自Cillection接口
List接口:有下标内容无序,位置有序
ArrayList类实现了List接口,异步,线程不安全,速度快,有下标查询速度快
LinkedList类实现了List接口,不适合查询,适合增和删
Vector:同步,线程安全,速度慢
Set接口:数据的内容无序,位置也无序,但内容不能重复
HashSet实现了Set接口,注意Hashcode,集合越小,便利的速度和效率就越好
HashTree实现了Set接口,集合是要求集合中的数据排序
要求要存储的元素对象对应的类必须实现Coparable接口
Map接口的两个子实现:
HashMap:可以存储null,线程不安全,异步
Hashtable类:不可以存储null,线程安全,同步
Iteratro迭代器 : 是基于迭代器设计模式实现的 ,可以把多种集合转换成一种集合方式
Iterable接口告知具备可迭代,Iterator接口告知如何迭代数据
Collection和Collections区别:(面试)
Collection接口:是List接口和Set接口的父接口,接口中
规范了List和Set集合的操作方式
Collections类:在类中有很多的方法,这些方法都是用来操作集合的,可以看成集合的工具类
且很多的方法是静态方法
集合的排序:
List集合排序:
-Collections.sort(List);
-Collection.sort(List,Comparator);
如果就一种排序原则,用Comparable接口,并重写CopareTo方法
如果有多个比较原则,就用Comparator接口(回调函数,匿名内部类,多态,策略设计模式) .
常用的api:
Object类:
-getClass() 获取制定对象的Class类型的对象
-equals(Object) 判断地址
-hashCode() 返回指定对象的哈希值
-toString() 输出对象的类型+@哈希值
-finalize() 在gc收集对象之前会自动调用此方法
注意(重点):
final和finaly和finalize的区别
final关键字:
修饰在变量上,就是常量
修饰在方法上,不能被重写
修饰在类上,不能被继承
finally关键字
在异常处理中用于释放资源的
finalize方法
在gc收集对象前调用此方法
String类 :-java.lang.String使用的final修饰的类,不能被继承
-字符串底层封装的是字符数组,以及操作字符数组的api方法
-字符串一旦创建,对象将无法更改,但字符串的引用可以重新复制
-java字符串采用unicode编码
注意:String 名=“字符串序列” 开辟的空间在方法区,为了提高性能
String 名=new String(“字符串序列”) 在堆中开辟了空间(在常量池也开辟空间)
api方法:
-int indexOf(String str)
在字符串中检索str,返回第一次出现的的位置如果没有找到,就返回-1
-int indexOf(String str,int fromIndex)
从fromIndex位置开始检索strlastIndexOf方法:
用户在字符串中检索另一个字符串(从后往前找)
-int lastIndexOf(String str)
在字符串中检索str,返回第一次出现的的位置 如果没有找到,就返回-1
-int lastIndexOf(String str,int fromIndex)
从fromIndex位置开始检索str ,indexOf方法和lastIndexOf方法返回结果都是整数,
找到字符串的位置没有找到返回-1
-String subString(int beginIndex,int endIndex)
返回一个子字符串(包头不包尾)
-String subString(int beginIndex)
从beginIndex开始一直到末尾
-trim方法用于去掉字符串两边的空格
返回结果String trim();
charAt方法,返回指定位置的字符
-char charAt(int index);
如果超出范围会报数组下标越界异常StringIndexOutBoundException
startsWith方法,检测一个字符串是否以指定的字符串开头
-boolean startsWith(String str)
endsWith方法 检测一个字符串是否以指定的字符串为尾部
-boolean endsWith(String str)
toUpperCase方法,转换字符串中的所有字符串为大写
toLowerCase方法,转换字符串中的所有字符串为小写
valueOf方法,将其他类型转换成字符串类型(静态方法)
split方法,根据指定的规则,拆分字符串
-String[] split(String str)
equals方法,判断内容,因为重写多了Object的equals方法
equalsIgnoreCase方法,忽略大小写比较内容
StringBuilder类:
-StringBuilder append(String str) ;//追加字符串
-StringBuilder insert(int destOffset,String str);//插入字符串
-StringBuilder delete(int start,int end);//删除指定的开始到结尾字符串
-StringBuilder replace(int start,int end,String str);
-StringBuilder reverse();字符串反转
StringBuffer类:
StringBuffer类跟StringBuilder类用法基本相同
String StringBuilder StringBuffer区别
-String字符串序列不可变, 里边的字符数组是final
-StringBuilder 和 StringBuffer都是字符串序列可以改变
-StringBuilder线程不安全,异步,速度快
-StringBuffer线程安全,同步,速度慢
-如果频繁对字符串的内容做增删改
首选StringBuilder或StringBuffer
-如果字符串内容不改变,首选用String
正则表达式:用于验证字符串是否符合规则
封装类:
八种基本数据类型对应封装的数据类型
可以用类中的方法来操作数据
拆箱
把对象中的数据拆成基本数据类型的数据
装箱
把基本数据类型的数据装箱成对象类型
拆箱和装箱要注意jre的版本
1.5以前 手动拆箱和装箱
1.5以后,自动装箱和拆箱

相关资讯

  • 那些我们不愿意承认的事

    很久没有见的老朋友,准确的说应该是很久没有见过的老师,一个比我大两岁的老师,我上初中的时候他从高中回来教我了一年。后来又回去上高中,我上高中的时候他上大学,现在我刚大学毕业他创办了公司。昨日一见依然如故,他还是热爱销售,而我却成了纯粹的技术人员。 看到他…

    2015/6/22 13:12:47

学习教程

共有访客发表了评论 网友评论

验证码: 看不清楚?
    -->