恶补 Java 基础

JAVA概述：

Java是一种高级计算机语言，它是由SUN公司（已被Oracle公司收购）于1995年5月推出的一种可以编写跨平台应用软件、完全面向对象的程序设计语言。Java语言简单易用、安全可靠、主要面向Internet编程，自问世以来，与之相关的技术和应用发展得非常快。在计算机、移动电话、家用电器等领域中，Java技术无处不在。

为了使软件开发人员、服务提供商和设备生产商可以针对特定的市场进行开发，SUN公司将Java划分为三个技术平台，它们分别是JavaSE、JavaEE和JavaME。

Java SE（Java Platform Standard Edition）标准版，是为开发普通桌面和商务应用程序提供的解决方案。JavaSE是三个平台中最核心的部分，JavaEE和JavaME都是从JavaSE的基础上发展而来的，JavaSE平台中包括了Java最核心的类库，如集合、IO、数据库连接以及网络编程等。

Java EE(Java Platform Enterprise Edition) 企业版，是为开发企业级应用程序提供的解决方案。JavaEE可以被看作一个技术平台，该平台用于开发、装配以及部署企业级应用程序，其中主要包括Servlet、JSP 、JavaBean 、JDBC、EJB、Web Service等技术。

Java ME(Java Platform Micro Edition) 小型版，是为开发电子消费产品和嵌入式设备提供的解决方案。JavaME主要用于小型数字电子设备上软件程序的开发。例如，为家用电器增加智能化控制和联网功能，为手机增加新的游戏和通讯录管理功能。此外，Java ME提供了HTTP等高级Internet协议，使移动电话能以Client/Server方式直接访问Internet的全部信息，提供最高效率的无线交流。

2、JDK与JRE

JDK(Java Development Kit)：Java的开发工具

• JRE(Java runtime Environment)：Java程序的运行环境
  • JVM(Java Virtual Machine)：Java虚拟机

Java中文网站：

3、Java程序运行机制

Java语言是一门编译型语言也是一门解释型语言

5、Java关键字

6、Java标识符

7、什么是字节

8、Java数据类型

强类型语言

• Java规定变量的使用要严格符合规定，所有的变量必须先定义后才能使用

Java的数据类型分为两大类：

数据类型的默认值

9、变量

什么是变量

10、变量名的命名规范

11、运算符

12、包

• 为了更好地组织类，Java提供了包机制，用于区别类名的命名空间
• 语法格式为：

其中：

为了能使用某一个包的成员，我们可以导入包“import”

13、JavaDoc

• javadoc命令是用来生成自己的API文档的

• 

14、Scanner对象

• • 1. 一定要读取到有效字符后才可以结束输入
  • 1. 在遇到有效字符之前遇到的空白，next()会将其去掉
    2. 在有效字符之后识别到空格之后，next（）会将空格作为分隔符或结束符
    3. next不能得到带有空格的字符串
• 1. 以Enter（回车键）为结束符也就是说 nextLine（）方法返回的是输入回车之前的所有字符
  2. 可以获取到空白字符串

15、流程控制语句

• if

• if else

• switch

• which循环（先判断，后执行）

• do ...which循环（先执行，后判断，至少执行一次）

• for循环

• 增强版for循环

  • 主要用于数组【返回没有下标】或集合

• break

  • 可以控制循环流程，用于强行退出循环

• continue

  • 用于终止某次循环，然后继续执行下一次循环

16、Java方法

1. 什么是Java方法

• • 方法是解决一类问题的步骤的有序组合
  • 方法包含在类或对象中
  • 方法在程序中被创建

2.方法的定义

• 方法包含一个方法头和一个方法体

• ​
  • 修饰符：这是可选的，告诉编译器如何调用该方法
  • 返回值类型：方法可能会返回值，有返回值就定义返回值，没有就用 void
  • 方法名： 方法的实际名称
  • 参数类型：方法像是一个占位符，当被调用时，传递值给参数，这个值就被称为实参或者变量。参数列表是指方法的参数类型。顺序和参数个数，参数是可选的，方法可以不包含任何参数
    • 形式参数： 在方法被调用时用于接收外界输入的数据
    • 实参：调用方法是实际传给方法的数据
  • 方法体：方法体，包含具体的语句，定义该方法的功能

3、方法的重载

• 1、什么的重载？
  • 重载就是在一个类中，有相同的函数名，但形参不一样
• 规则：
  • 方法名必须相同
  • 参数列表必须不同（个数不同或类型不同、参数排序顺序不同等）
  • 方法返回的；诶新可以相同，也可以不相同
  • 仅仅返回类型不同，不足以成为方法的重载

17、方法调用

• • • 执行的是一条语句

18、可变参数

19、递归

什么是递归？

• ​ A方法调用B方法，我们容易理解
• ​ 递归就是：A方法调用A方法，自己调用自己

• 

20、数组的定义

1.什么是数组？

• 数组是相同类型的有序集合
• 每个数据称为数组的元素，每一个元素可以通过一个下标来访问他，下标索引从 0 开始。

2.数组声明创建

• 首先必须声明数组变量，才能在程序中使用数组
• 语法：

获取数组长度：

3、数组的特点

4、图解数组

5、数组的创建

6、数组的边界

• 数组下标的合法区间：[ 0，length-1 ],如果业界就会报错：

• 

7、小结

• 数组是相同数据类型的有序集合
• 数组也是对象，数组元素相当于对象的成员变量
• 数组的长度是确定的，不可变的，如果越界，就会报错

21、多维数组

• 多维数组可以看做是数组的数组，比如二维数组就是特殊的一维数组，其中，二维数组中的每一个元素都是一维数组

定义：

22、Arrays类

• 数组的工具类java.util.Arrays
• Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用

常用功能：

23、冒泡排序

24、面向对象（OOP）

• 在面向之前，先了解一下面向过程

1、面向过程思想：

• 步骤清晰简单，第一步做什么，第二步做什么，由上到下
• 面向过程适合处理一些较为简单的问题

2、面向对象思想：

• 物以类聚，分类的思维模式，思考问题首先会解决问题需要那些分类，然后对这些分类进行单独思考。最后才对某个分类下的细节进行面向过程的思索。
• 面向对象适合处理复杂的问题，适合处理需要多人协作的问题。

3、什么是面向对象：

4、三大特性

• 封装
• 继承
• 多态

25、加强方法

方法的定义：

修饰符 返回值类型 方法名（参数。。。）{  方法体 return 返回值;}

• 返回值要和返回值类型相同
• return 结束方法，返回一个结果
• 方法名：要注意规范，要做到见明知意
• 参数定义：（参数类型 参数名，。。。）
• 异常抛出

break和return的区别

break：跳出switch，结束循环

return 结束方法，返回一个结果

方法调用：

非静态方法：

// 非静态方法 public void student(){  System.out.println("学生很开心"); } =======================================//  非静态方法调用//  调用需要实例化 new这个Java_09_FangFa3类  Java_09_FangFa3 fa3 = new Java_09_FangFa3();  fa3.student();

静态方法：

// 静态方法 public static void student1(){  System.out.println("大数据牛！！！"); } =========================================//  静态方法调用//  类.方法名  Java_09_FangFa3.student1();

形参和实参

//      形参 public static int min(int a ,int b){  return a+b; }

值传递和引用传递

this关键字

26、创建与初始化对象

使用new关键字创建对象

• • 必须和类的名字相同
  • 必须没有返回类型，也不能写void

无参构造：

public class Person {// 一个类即使什么都不写，他也会存在一个方法 String name;// 无参构造器// 实例化初始值// 1、使用new关键字必须要有构造器，new的本质就是调用构造器 public Person() { }

有参构造：

public class Person {// 一个类即使什么都不写，他也会存在一个方法 String name;// 有参构造// 一旦有了有参构造，就必须要有无参构造 public Person(String name) {  this.name = name; } }

• 一旦有参构造生成了，无参构造就会失效

调用：

//  构造器的使用  Person person = new Person("xioahe");  System.out.println(person.name);

内存分析：

Pet类

public class Pet { String name; int age ;// 默认就有无参构造 public Pet() { } public void shout(){  System.out.println(this.name+ "叫了一声"); }}

程序入口：

Pet dog = new Pet();dog.age=3;dog.name="wangcai";dog.shout();// cat没有赋值Pet cat = new Pet();

小结

• 1、类和对象
  • 类是一个模板：抽象的概念
  • 对象是一个具体的实例
• 2、方法：定义、调用
• 3、对象的引用
  • 引用类型 ：基本类型有八个
  • 对象是通过引用来操作的：栈-->堆
• 4、属性 ：字段 成员变量
  • ​ 默认初始化
    • 数字 ：0 0.0
    • char ：u0000
    • boolean：false
    • 引用：null
  • 修饰符 属性类型 属性名 =属性值；
• 5、对象的创建和使用
  • 必须使用new 关键字创造对象，构造器 Person xiaohe = new Person();
  • 对象的属性 xiaohe.name
  • 对象的方法 xiaohe.add();
• 6、类
  • 静态的属性 --> 属性
  • 动态的行为 -->方法

27、OOP三大特性

1、封装

概念：

• 该露的露，该藏的藏
  • 我们设计程序要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：紧紧暴露少量的方法给外部使用；
• 封装数据（数据的隐藏）
  • 通常，应尽早直接访问一个对象中数据的实际表示，而通过操作接口来实现访问，这称为信息影藏
• 属性私有，get/set

优点：

• 提高程序安全性
• 影藏代码细节
• 统一接口
• 程序可维护性增加

2、继承

• 关键字：extends
• 子类会继承父类，子类就会拥有父类的所有方法
• Java中类只有单继承，没有多继承
• 在Java类中，所有的类都会继承 object类

父类

public class Person {}

子类

//     继承关键字public class Student extends Person { }//     继承关键字public class Teacher extends Person{}

super关键字 VS this关键字

super：

• super必须在继承关系下才能使用
• super调用父类的构造方法必须放在构造方法的第一行
• super只能出现在子类的方法或者构造方法中
• super和this不能同时调用构造方法（this调用构造方法也必须放在构造方法的第一行）

不同：

• • this 代表本类这个对象
  • super 代表父类的对象
• • this没有继承也可以使用
  • super：只能在继承的条件下使用
• • this（）；调用的是本类的方法
  • super（）；调用的是父类的方法

父类

//这是一个人 类public class Person { protected String name = "lisi"; public Person() {  System.out.println("person无参执行了"); } //私有的东西无法被继承 public void print(){  System.out.println("Java是一门好语言1！"); }}

子类

//这是一个学生类// 子类会继承父类，就会拥有父类的所有方法// 在Java类中，所有的类，都会默认继承Object类//     继承关键字public class Student extends Person {  private String name = "myhes"; public Student() {  //隐藏代码，调用了父类的无参构造，必须放在子类构造器·第一行  super();  System.out.println("student无参执行了"); } public void print1(){   System.out.println("Java是一门好语言2！");  }  public void test(String name){   System.out.println(name);//xiaohe  程序输入的name   System.out.println(this.name);//myhes 获取本类中的name   System.out.println(super.name);//lisi 获取父类的name  }  public void test1(){   this.print1(); //this指向本类方法   super.print(); //super指向父类方法  }}

方法重写

• 重写需要有继承关系，子类重写父类的方法！
• 方法名必须相同
• 修饰符：范围可以扩大，但不能缩小： public > protected > default >private
• 抛出的异常：范围，可以被缩小，但不能扩大

一句话：子类的方法和父类的方法必须一致：方法体不同

为什么要重写：

• 父类的功能，不满足于子类的需求

父类

public class A { public void add(){  System.out.println("A>>>B"); }}

子类

public class B extends A{// 静态方法和非静态方法区别很大 // 静态：方法的调用只和A，B，定义的类型有关 //非静态： 非静态的方法才叫重写，// Override 重写 @Override //注解：有功能的注解 public void add() {  System.out.println("大数据"); }}

启动

//  重写  B b = new B();  b.add();//  父类的引用指向了子类  A a = new B();//子重写了父类的方法  a.add();

3、多态

概念：

• 一个方法可以根据发送对象的不同而采用多种不同的方式
• 一个对象的实际类型是确定的，但是可以指向的类型可以有很多
  • 指向的类型可以有：父类：有关系的类

多态存在的条件：

• 有继承关系
• 子类重写父类的方法
• 父类引用指向子类对象

注意：

多态是方法的多态，属性没有多态

Person父类

//多态public class Person { public void sun(){  System.out.println("这是一个加法"); }}

student子类

 public class Student extends Person{	@Override public void sun() {  System.out.println("增强加法"); } public void jian(){  System.out.println("这是一个减法"); }}

程序类

//  多态//  子类能调用的方法都是自己的和父类的  Student student1 = new Student();//  指向父类//  父类型，可以指向子类，不能调用子类独有的方法  Person student2 = new Student();//  爷爷  Object student3 = new Student();//  方法重写时，父类调用的方法也走子类的方放  student1.jian();  ((Student) student2).jian(); }

instanceof（类型转换）

//  instanceof//  Object > Person >Student//  Object > String//  存在继承关系才true  Object obj = new Student();  System.out.println(obj instanceof Student);//true  System.out.println(obj instanceof Person);//true  System.out.println(obj instanceof Object);//true  System.out.println(obj instanceof String);//false

28、static 关键字

Student类

public class Student { private static int age;//静态变量 private double score; //非静态变量// 非静态方法 public void run(){ }// 静态方法 ,静态属性和静态属性 类一起加载的，所以能直接调用 public static void add(){ } public static void main(String[] args) {//  Student s1 = new Student();  System.out.println(s1.score); //通过对象访问//  age //静态变量可以直接调用//  Student.age // 类变量  Student s2 = new Student();  s2.run();// 通过对象访问非静态方法  add();// 静态方法可以直接调用 }

Person类

//静态代码块public class Person { { // 匿名代码块,在构造器之前  System.out.println("这是一个匿名代码块"); } static { //静态 代码块 ，只执行一次  System.out.println("这是一个静态代码块"); } public Person(){  System.out.println("构造方法"); } public static void main(String[] args) {  Person person1 = new Person();  System.out.println("============================");  Person person2 = new Person(); }//结果 /*这是一个静态代码块  这是一个匿名代码块 构造方法============================ 这是一个匿名代码块   构造方法  */

小结：

• 静态属性、静态方法，可以直接在类中直接调用（因为静态属性是和类生成时一起加载的，所以能直接调用)
• 而，非静态的属性、方法，则需要通过对象来调用
• 静态代码块只执行一次

29、abstract 抽象类

• abstract 修饰符也可以修饰类
• 抽象类中可以写普通方法，单抽象方法必须卸载抽象类中
• 抽象类不能使用new 关键字来创建对象
• 抽象方法，只有方法的声明，没有方法的实现，它使用子类来实现的（约束）

30、接口

普通类：只有具体实现

抽象类：具体实现和规范（抽象方法）都有！

接口：只有规范，自己不能够写方法

接口一

//接口关键字 interfacepublic interface UserService {// public void run(){ } //接口中所有的定义都是抽象的 使用的是public abstract 修饰// public abstract void run(); void add(String name); void delete(String name); void update(String name); void query(String name);}

接口二

public interface TimeService { void time();}

实现类

//这是一个接口实现类// 类通过 implements 接口    JAVA是单继承的，但是可以通过接口实现多继承public class UserServiceImpl implements UserService,TimeService {//实现了接口的类，就需要重写接口中的方法 @Override public void add(String name) {  System.out.println("今天星期五"); } @Override public void delete(String name) { } @Override public void update(String name) { } @Override public void query(String name) { } @Override public void time() { }}

31、内部类

什么是内部类

成员内部类

public class Outer { private int age = 18; public void run(){  System.out.println("这是外部类"); }// 内部类 public class add{  public void add(){   System.out.println("这是一个內部类");   //  内部类可以获得外部类的私有属性/方法  public void e1(){   System.out.println(age);  }  } }}

静态内部类

 // 静态内部类 public static class add{  public void add(){   System.out.println("这是一个静态內部类");  }

局部内部类

// 局部内部类// 在方法里面再写一个类 public void run1(){  class Inner{     } }

匿名内部类

public class Test { public static void main(String[] args) {//  没有名字实例化类，不用将实例保存到变量中//  匿名内部类  new Outer().run(); }}

32、异常（Exception）

什么是异常

异常的体系结构

Java异常层级关系

处理方法

• 抛出异常（ throw 、 throws）
• 捕获异常（try 、catch 、 finally）
• 抛出异常就是不处理异常，捕获异常就是要处理异常

异常处理五个关键字：

public class Test { public static void main(String[] args) {  int a = 1;  int b = 0;//  捕获异常//  如果要捕获多个异常 ： 要按照异常层级关系 从小到大  try { //监控异常区域   System.out.println(a/b);  } catch (Exception e) { //catch 捕获异常   System.out.println("程序出错"); //捕获异常后执行代码块  }finally { //处理善后工作   System.out.println("finally");  }//  finally可以不要   }} 

小伙伴们有兴趣想了解内容和更多相关学习资料的请点赞收藏+评论转发+关注我，后面会有很多干货。
我有一些面试题、架构、设计类资料可以说是程序员面试必备！所有资料都整理到网盘了，需要的话欢迎下载！私信我回复【07】即可免费获取
 

原文出处：www.shaoqun.com/a/1235287.html