恶补 Java 基础

当前位置:

首页 > 编程开发 > Java教程 >

恶补 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中文网站：https://www.java.com/zh-CN/

3、Java程序运行机制

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

5、Java关键字

6、Java标识符

Java所有组成的部分都需要名字。类名、变量名以及方法名就称为标识符。
所有的表示符都应该以字母(A-Z或者a-z)，美元符 $ 、或者下划线 _ 开始。
不能使用关键字作为变量名或方法名
标识符对大小写敏感

7、什么是字节

位（bit）：是计算机内部数据 存储的最小单位，11001100是一个八位二进制数
字节（byte）：是计算机中 数据处理 的基本单位，习惯上用大写 B 来表示。
1B （byte，字节）=8bit
字符：是指计算机中使用的字母、数字、字和符号

8、Java数据类型

强类型语言

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

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

基本数据类型
引用数据类型

数据类型的默认值

9、变量

什么是变量

Java是一种强类型语言，没一个变量都需要声明其类型
Java变量是程序中最基本的存储单位，其要素包括变量名，变量类型和作用域

10、变量名的命名规范

11、运算符

12、包

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

其中：

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

13、JavaDoc

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

14、Scanner对象

Java提供了一个工具类，可以获取用户的输入
基本语法

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

15、流程控制语句

if
if else
switch
which循环（先判断，后执行）
do ...which循环（先执行，后判断，至少执行一次）
for循环
增强版for循环
- 主要用于数组【返回没有下标】或集合
break
- 可以控制循环流程，用于强行退出循环
continue
- 用于终止某次循环，然后继续执行下一次循环

16、Java方法

1. 什么是Java方法

Java方法是语句的集合，他们在一起执行一个功能
- 方法是解决一类问题的步骤的有序组合
- 方法包含在类或对象中
- 方法在程序中被创建
一个方法最好只完成一个功能，这样有利于后期的扩展

2.方法的定义

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

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

3、方法的重载

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

17、方法调用

调用方法：对象名.方法名（实参列表）
Java有两种调用方法的方式，是根据是否有返回值来选择的
- 当有返回值是
- 返回值为 void 时
  - 执行的是一条语句

18、可变参数

在方法声明中，在指定参数类型后面加上一个省略号（...）
一个方法只能指定一个可变参数，他必须是方法的最后一个参数。其他普通方法都要在它前面声明。

19、递归

什么是递归？

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

20、数组的定义

1.什么是数组？

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

2.数组声明创建

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

Java语言中使用new操作符来创建数组
语法：

获取数组长度：

3、数组的特点

4、图解数组

5、数组的创建

静态创建
动态创建

6、数组的边界

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

7、小结

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

21、多维数组

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

定义：

22、Arrays类

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

常用功能：

23、冒泡排序

24、面向对象（OOP）

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

1、面向过程思想：

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

2、面向对象思想：

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

3、什么是面向对象：

面向对象编程（OOP）
本质：以类的方式组织代码，以对象的组织（封装）数据。

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关键字创建对象

使用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调用构造方法也必须放在构造方法的第一行）

不同：

1、代表对象不同
- this 代表本类这个对象
- super 代表父类的对象
2、使用前提不同
- 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、接口

普通类：只有具体实现

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

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

声明类的关键字是class，声明接口的关键字是interface
接口就是规范，定义的是一组规则，实现了现实世界中 “ 如果你是，那么必须能。。。”的思想
接口本质是契约，就像我们人间的法律一样，制定了就必须要去遵守
接口是OO的精髓，是对对象的抽象
接口不能被实例化，因为接口中没有构造方法
implements 实现可以多接口
方法默认被 public abstract 修饰（抽象）
属性默认被 public static final 修饰（常量）
实现类中，必须要重写接口的方法

接口一

//接口关键字 interface
public 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、内部类

什么是内部类

内部类就是在一个类的内部在定义一个类，比如在A类中在定义一个B类，那么B相对于A 来说就称为内部类,而A类相对于B类来说就称为外部类
1、成员内部类
2、静态内部类
3、局部内部类
4、匿名内部类

成员内部类

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异常层级关系：

33、异常处理机制

处理方法

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

异常处理五个关键字：

try 、catch 、 finally 、 throw 、 throws

捕获异常

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可以不要
        
    }

}

来源：https://www.cnblogs.com/myhes/p/15544254.htmlava

栏目列表

首页 > 编程开发 > Java教程 >