Java基础

2017-03-13 20:52:04   0  举报





仅支持查看

AI智能生成

Java是一种面向对象的编程语言，由Sun Microsystems在1995年首次发布。Java的设计目标是“一次编写，到处运行”，即编写的Java程序（后缀为.java的文件）在任何支持Java的设备上都能运行，无需重新编译。Java语言具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用、Web应用、移动应用（Android系统）和嵌入式应用等。Java的基础语法包括数据类型、运算符、控制流程、数组、方法、类和对象等。

java

作者其他创作

大纲/内容

介绍

JavaEE企业版

JavaSE标准版

JavaME小型版

JDK、JRE、JVM的关系

JDK：Java开发工具包

JRE：Java运行环境

JVM：JAVA虚拟机（翻译）

JDK安装目录

bin：存放编译运行Java程序可执行文件

lib：存放Java文件

demo：存放演示文件

jre：存放Java运行环境文件

include：供C语言使用的文件

编写、编译、运行

DOS命令

D：进入D盘

cd目录：进入文件夹

cd\：返回最上级目录

cd..：返回上一级

cls：清屏

exit：退出

命名

命名规范

1.只能使用数字，字母，下滑线，美元符号

2.数字不可以作为开头

3.命名不可以是关键字

4.区分大小写，没有长度限制

命名方法

大驼峰命名法：HelloWorld

小驼峰命名法：helloWorld

匈牙利命名法：hello_word

注释

//单行注释

/*多行注释*/

/**文档注释*/

\n换行

\t水平制表符

数组

什么是数组：存储多个同一个数据类型的容器，实现对数据的统一管理

数组是引用数据类型，所以放在堆中存放

数组常见问题

ArrayIndexOutBoundsException☞数组越界异常，你访问了不存在的索引

数组的定义方法

数据类型[] 变量名=new 数据类型[个数或者长度]

数据类型变量名 []=new 数据类型[个数或者长度]

数据类型 [] 变量名 = new 数据类型[] {元素1、元素2、元素3...}

数据类型[] 变量名={元素1，元素2，元素3,...}

数组操作：获取最值

int max=a[0]; for(i=0;i<a.length;i++){ if(max<a[i]){ max=a[i]}}

数组的遍历

数组遍历：获取数组中的所有元素

把数据存储起来就是为了使用，而要使用数组中的数据，就必须通过索引

如果数组太长，我们没办法一个个的去数，为此，Java提供了一个属性：length

数组名.length

例题：写功能（函数）完成数组的遍历

import java.util.Arrays;
数组排序：
for (int i = 0; i < b.length; i++) {
Arrays.sort(b);
System.out.println(b[i]);
}
数组复制：
int []a={1,2,3,4,5};
int []b=Arrays.copyOf(a,a.length+1);

（OOP面向对象程序语言）
object oriented programming
OOA面向对象程序分析
OOD面向对象程序设计

面向对象的三大特性：封装、继承、多态

面向对象思想特点：
1、更符合人类思考方式
2、将复杂简单化

类和对象

成员变量与局部变量

成员变量：
1、Java会给成员变量一个初始值。
2、作用域在整个内部是可见的。
3、同一方法中，不允许有同名成员变量。
4、堆里面放置。随着对象的创建而存在，随着对象的消失而消失。
5、定义位置：类中，方法外面。

局部变量：
1、Java不会给局部变量赋予初始值。
2、局部变量作用域仅限于他的方法。
3、不同方法中允许同名局部变量。
4、栈里面放置。随着方法调用而存在，随着方法的调用完毕而消失。
5、方法中或者方法声明上的形参。

成员变量与局部变量的区别：
1、初始值不同：成员变量有默认值，局部变量无默认值，使用前必须初始化。
2、作用域不同：成员变量定义类中，在整个类中可以使用，局部变量定义在方法中，只能在方法中使用。
3、储存位置不同：成员变量在堆中放着，局部变量在栈中放着。
在同一个方法中不允许有同名的局部变量，在不同的方法中可以。
局部变量可以和成员变量同名，并且局部变量的优先级更高

静态代码块

JVM加载类时，加载静态代码块
静态代码块的作用：初始化类，给类的静态变量赋值

public class Main{
   static int a =3;
   static int b;
   static{
      System.out.println("Static block initialized.");
      b=a*4;
   }
}

父节点

分类：
静态代码块：在java中使用static关键字声明的代码块。静态块用于初始化类，为类的属性初始化。每个静态代码块只会执行一次。由于JVM在加载类时会执行静态代码块，所以静态代码块先于主方法执行。如果类中包含多个静态代码块，那么将按照“先定义的代码先执行，后定义的代码后执行”。
注意：

静态代码块会在类被加载时自动执行。
静态代码块只能定义在类里面，不能定义在方法里面。
静态代码块里的变量都是局部变量，只在块内有效。
一个类中可以定义多个静态代码块，按顺序执行。
静态代码块只能访问类的静态成员，而不允许访问实例成员。

局部（普通）代码块：在方法或语句中出现的{}就称为普通代码块。
普通代码块和一般的语句执行顺序由他们在代码中出现的次序决定--先出现先执行

构造代码块：直接在类中定义且没有加static关键字的代码块称为{}构造代码块。
构造代码块在创建对象时被调用，每次创建对象都会被调用，并且构造代码块的执行次序优先于类构造函数

属性和方法

类用来模拟现实生活，使用的是属性和方法
类中的属性和方法统称为类成员

属性：对象的特征

例子：public class Student{
int a ;//属性
public int b[]{reutrn a;}//方法
}

方法：对象执行操作的行为

方法是由，访问修饰符+返回值+方法名+参数列表组成的

方法的调用：
调用自身普通方法可以直接调用
调用其他类的普通方法需要创建对象

访问修饰符：public，protected，默认修饰符，private
其他地方>子类>同包>同类
从大到小排列

方法返回值：无返回值，void
有返回值，创建方法是添加返回值，有返回值需要return同类型的值

参数

1.方法有参无参与返回值无关
2.有参方法可以有多个参数，每个参数用逗号隔开
3.参数的名字可以随便起
4.方法定义处的参数叫做形参，调用处的叫做实参
5.实参和形参的名字可以不一样，但数据类型和顺序要一样

封装

通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装；我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，指向外界提供最简单的编程接口（可以想想普通洗衣机和全自动洗衣机的差别，明显全自动洗衣机封装更好，因此操作起来更简单；我们现在使用的只能手机也是封装得足够好的，因为几个按键就搞定了所有的事情）
老师笔记：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。在设计一个类的时候，应该对成员变量的访问做出一些限定，不允许外界随意访问，这就需要实现类的封装。
java就给你提供了一个修饰符private。
private：是一个关键字，表示私有的意义。可用于修饰成员变量和成员方法。被它修饰完毕后的内容，在其他类中是不能直接访问的。
private仅仅是封装的一种体现。因为类，函数等其实也是一个封装的体现。
但是一般的校验都是客户端校验，或者浏览器校验，咱的java是服务器校验，所以说讲了那么多事干嘛，是引出get/set方法使用private关键字来修饰，私有属性只能在本类访问。为了能让外界访问访问私有属性，需要提供一些使用public修饰的方法，其中包括用于获取属性值getXxx();设置属性值setXxx();（getXxx和setXxx是规范）

构造方法
Student s=new Student(); Student()是一个方法，调的是一个方法，但是没有看到这个类的方法，为什么没有看到呢？
所以接下来学习心得知识点，今天来学习一下构造方法
1、方法名必须和类名一致
2、没有返回值类型
3、没有具体的返回值
构造方法的作用？
给对象进行初始化。
如果你没有给出构造方法，系统将默认给出一个无参构造方法 public Student(){}
只要你给出了构造方法，系统将不再提供无参构造。
推荐做法：请永远手动给出无参构造。

继承中的构造关系：子类的构造方法默认都去访问了父类的无参构造方法；在子类中的构造方法中都有一行默认语句：super（）
记住一点：在构造子类时，一定会调用到父类的构造方法。
所以父类要么有一个默认的无参数构造，这样Java会就自动调用这个无参数的构造。如果父类没有无参数的构造，那么就要你自己在子类的构造中，通过super（）的方式调用父类的构造。
1、子类构造方法没有通过super调用父类的有参构造方法，也没通过this调用自身其他构造方法系统默认调用父类的无参构造方法。
2、子类构造方法通过super调用父类的有参构造方法，执行父类相应构造方法，而不执行父类无参构造方法。
3、子类构造方法通过this调用自身其他构造方法，在相应构造方法中应用以上两条规则。

static:java提供的一个关键字，可以修饰成员变量可以修饰成员方法。
多个对象共用一个数据时候，我们就用静态修饰
特点：
1、随着类的加载而加载
2、优先于对象而存在
3、为什么要使用静态呢？如果某个内容是被所有对象所共享，那么，该内容就应该用静态修饰。没有被静态修饰的内容，其实是属于对象的特殊描述。
4、可以直接被类名调用

封装的好处

1.便于使用者正确使用系统
2.有助于系统之间的松耦合，提高系统独立性
3.提高软件的可重用性
4.降低了构建大型系统的风险

封装的方法

1.修改属性的可见性，将访问修饰符改为private。
2.、设置get/set方法
3、设置属性的存取限制

例子：
private String name;
public String getAge(){
return get;
}
public void steAge(int age){
this.age=String.valueOf(age);
}

this.代表所在方法的所属对象的引用
理解：哪个对象调用方法，在方法内部就有一个隐含的this代表代表这个对象
谁调用，this就代表谁
set里面需要加get里面不需要加是因为，局部范围没有name就不需要加name，局部范围有name就需要加

java中包（package）的作用：import导入包

1.允许类组成较小的单元（类似文件夹），易于找到相应的文件。
2、防止命名冲突区分名字相同的类。
3、有助于实施访问权限控制

多态性

多态性是指允许不同子类型的对象对同一消息做出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的服务，那么运行时的多态性可以解释为：当A系统访问B系统提供的服务时，B系统有多种提供服务的方式，但一切对A系统来说都是透明的（就像电动剃须刀是A系统，它的供电系统是B系统，B系统可以使用电池供电或者用交流电，甚至还有可能是太阳能，A系统只会通过B类对象调用供电的方法，但并不知道供电系统的底层实现是什么，究竟通过何种方式获得了动力），方法重载（overload）实现的是编译时的多态性(也称为前绑定)，而方法重写（override）实现的是运行时的多态性（也称为后绑定）。运行时的多态是面向对象最精髓的东西，要实现多态需要做两件事：
1、方法重写（子类继承父类并重写父类中已有的或抽象的方法）
2、对象造型（用父类型引用引用子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为）

//编译时期是Person状态，运行时期是Student
Person p=new Student();
p.setName（"张三"）//子类重写
//p.set（"张三"）父类引用不能向子类独有的方法

//静态方法不能被重写，静态方法编译时期看左边，运行时期看左边
//属性同上

多态间的成员特点：方法有重写，而变量没有。
成员变量，静态方法看左边；非静态方法：编译看左边，运行看右边
当父类变量引用子类对象时，在整个引用变量指向的对象中，他的成员变量和静态方法与父类是一致的，他的非静态方法，在编译时是与父类一致的，运行时却与子类一致（发生了重写）

多态：父类引用指向子类对象

前提条件：
1、要有继承关系
2、要有方法重写
3、要有父类引用指向子类对象

多态性是指允许不同子类型的对象对同一消息做出不同的响应

编译时多态

方法重载属于编译时多态

运行时多态

方法重写属于运行时多态

多态的应用

多态的优势：可替换性，可扩充性，接口性，灵活性，简化性

多态在程序中的主要应用形式：使用父类作为方法的形参和使用父类作为方法的返回值

子类转换成父类的规则

向上转型

1、将一个父类的引用指向一个子类对象，即子类类型转换为父类类型，称为向上转型，自动类型转换
2、通过父类的引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法
3、通过父类的应用变量无法调用子类特有的方法

向下转型

将一个指向子类对象的父类引用赋给一个子类的引用，即父类类型转换为子类类型，称为向下转型，强制转换类型

instanceof：用来判断当前对象是否是指定类所创建的对象，对象名 instanceof 类名
返回值是：boolean类型 true，false

作用：减少在向下转型的过程中，没有转换为真实子类类型的类型转换异常

例子：person p=new Person()
boolean a=p instanceof Person;//true
Boy b=new Boy();
boolean a1=b instanceof Person;//true

Person p=new Boy();
boolean a2=p instanceof Person;//true
boolean a3=p instanceof Boy;//true

可以用if判断调用不同对象的方法

注意事项

对象的类型必须和instanceof后面的参数所指定的类在继承上有上下级关系

不使用instanceof可能会发生 java.lang.ClassCastException类型转换异常

关键字abstract
抽象类：定义两个子类，里面有相同的方法，我们可以提取方法的声明，包含抽象方法的类就是抽象类，抽象就是不具体的意思。使用关键字abstract修饰的类，就是抽象类

抽象方法：只有方法的声明，没有方法的实现，也就是没有方法体

注意：在java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类

1、抽象方法所在的类必须是抽象类，抽象类里面不一定有抽象方法
2、普通类继承抽象类必须重写抽象类里面的抽象方法
3、抽象类里面有成员变量，和常量，也可以有构造方法

abstract不能与private、static、final、native并列修饰同一个方法。

特点：
1、抽象方法和类都必须使用abstract关键字
格式：抽象类：abstract class 类名{
抽象方法：修饰符 abstract 返回值类型方法（参数）}

2、有抽象类不一定有抽象方法，但是有抽象方法的类一定是抽象类
public void eat();针对没有方法体的方法java提供了一种形式叫抽象方法

3、抽象类不能实例化
注意：没有抽象方法的抽象类，有意义吗？有

如何创建对象
通过多态的方式完成，通过子类去实例化
抽象类的子类：要么是抽象类，要么是具体类，重写抽象类中所有的抽象方法，具体类可以创建对象
注意：静态的不能被抽象，因为抽象需要重写，而静态方法不能被重写，抽象类不能被实例，就不能被分配空间，静态跟着类一起走被分配空间了

interface接口
这个抽象类中，只有抽象方法。针对这种情况，java就提供了一种更加抽象的表示形式：接口。
有了接口怎么用？
必须也要有具体的类来实现，类与类之间强调的是继承关系，类别与接口之间强调的是实现关系

特点：
1、接口不能被实例化（可以声明都不写，可以是一个空的）
2、接口中的方法要被实现，多态的前提，要有继承或者实现关系

接口的成员问题
1、成员变量：接口中没有成员变量，只有常量，默认是final，通过接口可以直接调用变量，他其实是被静态修饰的
总结：接口中的成员变量有默认的修饰符
public static final int x; 推荐自己永远给出修饰符
接口很重要，用久了好多人都不知道接口的特点了，因为接口里面的数据是都静态的，随着类的加载而加载，不需要初始化，不需要初始化，不需要初始化，因为一开始必须给值，所以构造没有意义。
2、没有构造方法
但是会暴露一个问题，他的super是谁呢？
任何类如果没有继承父类，那么这个类就继承自Object类
接口中的成员方法都是抽象，方法默认都是抽象的，所以在接口中 public void eat();默认都是抽象的，推荐永远给出修饰符，因为你不给会误导人。

什么时候使用抽象类呢？
当你有些方法相同但功能一点不同，我们可以使用抽象类，节省代码，同时也有继承关系，提高代码的复用性

好处

接口的思想特点
1、接口是对外暴露规则：理解为usb口，只要是通过usb口的都可以接过来，都可以用，usb口都是规定好的，就告诉你必须按我的去做，否则用不了。
2、接口是程序的功能扩展：因为是接口多态，所以一样有程序的扩展
3、接口的出现降低耦合性：耦合：关系越强耦合越强，降低耦合，一个类的改变对其他影响比较小。内聚：一般指自己完成一段代码的功力特别强，一般不连累其他人。
4、接口可以用来多实现

类与类的关系：继承关系，所有类都直接或者间接的继承来自object类，只能是单继承可以是多层继承

类与接口的关系：实现关系，可以单实现。并且在继承一类的同时，实现多个接口。

接口与接口的关系：接口和接口之间是继承关系，既可单继承，又可多继承，不会出现调用不明确的问题，因为都是抽象的

面试基本必面
1、成员特点：
抽象类
成员变量：可以是变量，也可以是常量
构造方法：有构造方法
成员方法：可以是抽象方法，也可以是非抽象方法
2、接口
成员变量：只能是常量
成员方法：只能是抽象方法

继承

继承的特点：
A：Java只支持单继承，不支持多继承（为什么呢？因为如何可以多继承，就会出现调用不明确的问题）
B：Java支持多层（重）继承（继承体系）

叫法：
Person：父类，基类，超类
Student,Teacher：子类，派生类
注意：子类可以直接访问父类中的非私有的属性和行为。
继承的好处：
1、提高了代码的复用性。
2、让类与类之间产生了一个关系，是多态的前提。

方法的重写：@override
子父类方法重写的注意问题：
1、父类中的私有方法不可以被重写
2、子类方法访问权限一定要大于等于父类方法访问权限
3、静态的方法只能被静态方法重写。这个其实不能算对象的关系
4、覆盖的应用：当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类的特有的内容
方法重写：子父类中，出现方法相同的情况。返回值，方法名，参数都要求一模一样。
方法重载：同一个类中，方法名相同，参数列表不同，跟返回值无关。

super关键字
和this的用法很像，supper代表父类的内存空间的标识。（可以理解为父亲的对象引用）
this 和super的使用
成员变量： this.变量 --当前类的变量      super.变量   --父类的变量
构造方法：用在构造方法中的。 this(参数)   --本类的构造方法    supper（参数） --父类的构造方法
成员方法：this.方法名（） --本类的方法    super.方法名（） --父类的方法

关键字final

根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类，非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。
final类不能被继承，没有子类，final类中的方法默认是final的。
final方法不能被子类的方法覆盖，但可以被继承。
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
final不能用于修饰构造方法。
注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。

1、final类
final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类的时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会再被扩展，那么就设计为final类。
2、final方法
如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。
使用final方法的原因有二：
第一、把方法锁定，防止任何继承类修改它的意义和实现。
第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。
3、final变量（常量）
用final修饰的成员变量表示常量，值一旦给定就无法改变！
final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。另外final变量定义的时候，可以先声明，而不给初值，这种变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须初始化。但是，final空白在final关键字的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却又保持其恒定不变的特征。
4、final参数
当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。

4月13日 day137有例子

三大特征的优缺点

1、继承的优点：提高了代码的复用性
继承的弊端：最大的弊端是强耦合；很多子类都继承父类，父类只要一改动，儿子必须跟着改动
2、封装的好处：我们可以通过封装，防止外界肆意访问，做一些非法数据的校验。
缺点：外界不能直接访问变量。
3、多态好处：提高代码的扩展性和可维护性
缺点：父类引用不能使用子类特有功能

String引用类型

String是引用类型，放在字符串常量池。字符串常量池直接把地址给String 的名字。注意：字符串是常量，它们的值在创建之后不能更改。
String不New，如果New的话，得需要先从堆中找地址，堆要去字符串常量池中找，内存中开辟两个空间，需要找两次，比较耗内存。

String s="abc";
int length=s.length();返回字符串的长度
boolean equals = s.equals("abcd");比较字符串内容是否相等，区分大小写。

"=="：比较两个变量是否相等，当变量是引用类型的时候比较地址值
equals:比较的是内容

布尔功能：
1.equals();//比较字符串内容是否相同，区分大小写
2.equalsIgnoreCase();//不区分大小写
3.contains();//判断字符串对象是否包含给定的字符串
4.isEmpty();//判断字符串对象是否为空。当且仅当length()为0时返回true

获取功能：
1.length();//获取字符串的长度
2.substring(int a);//截取字符串，返回从指定位置开始截取后的字符串，从a（包含a）以后的字符串
3.substring(int a,int b);//包左不包右，截取字符串，返回从指定位置开始到指定位置结束截取后的字符串
4.indexOf(String a);//返回在此字符串中第一次出现指定字符的索引
5.intdexOf(String a,int b);//返回在此字符串中第一次出现指定字符串的索引，从指定的索引开始搜索。

转换功能：
1.tolowerCase(无参);大写转小写
2.toUpperCase(无参);小写转大写

替换功能：
1.replace();用新的字符串去替换指定的旧字符串

去空功能：
trim();去除字符串左右两边的空格，中间的空格不去空。

拼接功能：
concat();字符串的拼接，等效于String s=new String("您好！"); s=s+"张三";缺点：耗内存。
字符串升级功能：StringBuffer
StringBuffer s=new StringBuffer();
s.append("abx");//.append().append();可以无限拼接，优点：消耗内存小。相当于添加了一个容器，这个容器可以修改原来的String字符串。

//插入功能：
StringBuffer insert =s.insert(2,"ddd");//abdddx,包右

//删除功能：delete(int start,int end);
StringBuffer delete=s.delete(1,3);//删除指定位置的字符串，包左不包右。addx，删除1,2

//替换功能：StringBuffer 也有replace
StringBuffer replace = s.replace(1,4,"ggg");//包左不包右，aggg
//反转功能：
StringBuffer reverse=s.reverse();

//转String类型
toString；

//切割功能：
split();

正则表达式：能让解析，扫描和分割字符串变得非常容易，Java常用的正则表达式-Patter,Matcher和Scanner类

笔记本系统恢复方法：
如果出现系统崩溃等问题，可使用系统自带的还原方法如下：
联想ThinkPad 开机按F11--疑难解答--重置此电脑--保留我的文件或删除所有内容。即可；

ACER宏碁笔记本开机按Alt+F10--疑难解答--重置此电脑--保留我的文件/删除所有内容。即可

运算符

1.算数运算符

+ - * /（取整数）加减乘除，%取余数，++值+1，--值-1

补充：a++，++a不同，若a=10,b=++a则为a=11,b=11。若a=10，b=a++,则a=11，b=10.

2.赋值运算符

=，+=，-=，/=，%=

栗子：若a=10,a+=20, 则a=30

3.关系运算

> , < , <= , >= , == , !=不等于

4.逻辑运算符