前言：

本笔记参考于学友：Estella1024 ；本笔记仅做学习与复习使用，不存在刻意抄袭。

------------------------------------------------------------------------------------------------------------

给各位学友强烈推荐《遇见狂神说》他的整套Java学习路线使我获益匪浅！！!

点击跳转至遇见狂神说哔哩哔哩首页

如果你也是狂神的小迷弟，可以加我好友一起探讨学习。

目录

前言：

Java流程控制

用户交互Scanner

循环结构

面向对象

封装

继承

多态

抽象类（abstract）

接口(interface)

内部类

 异常

 简单分类

异常体系结构​编辑

 Error

 运行时异常

 捕获和抛出异常

 自定义异常

本篇文章，不阐述基础doc，jdk等，我们直接上代码！

Java流程控制

用户交互Scanner

• Java给我们提供了一个工具类Scanner，可以获取用户的输入（java学习基础阶段，开发者与机器的人机交互，今后使用会很少）。
• java.util.Scanner是Java5的新特征，我们通过Scanner类来获取用户的输入。
• 基本语法

Scanner sc = new Scanner(System.in); 

• 通过Scanner类的 next()与 nextLine()方法获取用户的字符串，
• 读取前一般用hasNext()与hasNextLine()判断是否还有输入的数据。

package com.example.demo1.demo;

import java.util.Scanner;

/**
 * @author liar
 */
public class ScannerTest {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用next方法接收：");
        //判断用户有没有输入字符串
        if(scanner.hasNext()){//还有输入
            //使用next方式接收
            String sstr = scanner.next();
            System.out.println("输出的内容为："+sstr);
        }
        //凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯，用完就关掉
        scanner.close();

    }

}

其运行结果为：

 输入kuangshen  666

根据以上例子可总结：

1. 一定要读取到有效字符才可以结束输入
2. 对输入有效字符之前遇到的空白，next()方法会将其去掉
3. 只有输入有效字符后才将其后面输入的空白作为结束符
4. next()不能得到带有空格的字符串

nextLine()

  public static void main(String[] args) {
        //从键盘接收数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用nextLine方法接收：");
        //判断用户有没有输入字符串
        if(scanner.hasNextLine()){//还有输入
            //使用next方式接收
            String sstr = scanner.nextLine();
            System.out.println("输出的内容为："+sstr);
        }
        //凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯，用完就关掉
        scanner.close();
    }

输入kuangshen  666

根据以上例子可总结：

1. 以Enter作为结束符，即返回输入回车之前所有的字符
2. nextLine()可以获取空白

这里不再多说Scanner，进入下一个知识点。

循环结构

• while循环

package com.example.demo1.demo;

/**
 * @author liar
 */
public class WhileTest {
    public static void main(String[] args) {
        //使用while计算1+2+3+......+100的结果
        //自定义一个i，与while(i < 100)结合使用，其目的是循环100次
        int i = 0;
        //定义一个count用来保存每次的计算结果
        int count = 0;
        //循环从i到100，直到i!<100时停止循环
        while(i < 100){
            //让i自增，现在i的值已经是1了
            i++;
            //count = count + i 的缩写
            count+=i;
        }
        //输出计算结果
        System.out.println("count:"+count);
    }
}

我们来看看结果

do while 与while的区别，实质上就是，while先判断，条件成立后才执行代码，而do while无论如何都会先执行代码一次再进行判断。这里不再阐述do while.

• for循环

//（初始化；条件判断；迭代）
for(int i = 0;i <100;i++){
	i++;
	sum+=i;
}
for(;;){...}//死循环

• 增强for循环

int[] numbers = {10,20,30,40,50};//定义一个数组
        for(int x:numbers){
            System.out.println(x); //遍历数组的元素10 20 30 40 50
        }
        //相当于
        for(int i = 0;i < 5;i++){
            System.out.println(numbers[i]);
        }

这里简述一下与循环类似的递归，说着相似，其实质是不同的，递归的核心是自己调用自己，这里用汉诺塔来简述一下递归。

package com.example.demo1.demo;
import java.util.Scanner;
public class TowersOfHanoi {
    static int m =0;//标记移动次数
    //实现移动的函数
    public static void move(int disks,char N,char M)
    {
        System.out.println("第" + (++m) +" 次移动 : " +" 把 "+ disks+" 号圆盘从 " + N +" ->移到->  " + M);
    }
    //递归实现汉诺塔的函数
    public static void hanoi(int n,char A,char B,char C)
    {
        if(n == 1) {//圆盘只有一个时，只需将其从A塔移到C塔
            TowersOfHanoi.move(1, A, C);//将编b号为1的圆盘从A移到C
        }
        else
        {//否则
            hanoi(n - 1, A, C, B);//递归，把A塔上编号1~n-1的圆盘移到B上，以C为辅助塔
            TowersOfHanoi.move(n, A, C);//把A塔上编号为n的圆盘移到C上
            hanoi(n - 1, B, A, C);//递归，把B塔上编号1~n-1的圆盘移到C上，以A为辅助塔
        }
    }
    public static void main(String[] args) {
        Scanner imput = new Scanner(System.in);
        char A = 'A';
        char B = 'B';
        char C = 'C';
        System.out.println("******************************************************************************************");
        System.out.println("这是汉诺塔问题（把A塔上编号从小号到大号的圆盘从A塔通过B辅助塔移动到C塔上去");
        System.out.println("******************************************************************************************");
        System.out.print("请输入圆盘的个数：");
        int disks = imput.nextInt();
        TowersOfHanoi.hanoi(disks, A, B, C);
        System.out.println(">>移动了" + m + "次，把A上的圆盘都移动到了C上");
        imput.close();
    }
}

其运行结果是

 接下来就是java的重点了：面向对象。

面向对象

封装

• 该露的露，该藏的藏

  - 我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据细节由自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

• 封装（数据的隐藏）

     - 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，称为信息隐藏。

• 作用

      1. 提高程序的安全性，保护数据     
      2. 隐藏代码的实现细节     
      3. 统一接口     
      4. 系统可维护性增加了

例子：

实体类：Student

package com.example.demo1.demo;
/**
 * @author liar
 */
//类 private私有
public class Student {
    //    属性私有
    private String name; //名字
    private int id;//学号
    private char sex;//性别
    private int age;//年龄
    //提供一些可以操作这个属性的方法！
    //提供一些public的get、set方法
    //get 获得这个数据
    public String getName(){
        return this.name;
    }
    //set 给这个数据设置值
    public void setName(String name){
        this.name = name;
    }
    //alt+insert
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age > 120 || age <0 ){

            this.age = 3;
        }else{
            this.age = age;
        }
    }
}

为什么用这个类来说明封装呢？我们发现其他的类是无法直接给student类中的属性赋值的，只能通过student类提供的set方法为其赋值。这就可以简单的理解封装的概念了。

继承

• 继承的本质是对某一批类的抽象，从而实现对世界更好地建模。
• extends的意思是”扩展“。子类是父类的扩展，使用关键字extends来表示。
• Java中类只有单继承，没有多继承！一个类只能继承一个父类。
• 继承是类与类之间的一种关系，此外还有依赖、组合、聚合等。
• 继承关系的两个类，一个为子类（派生类），一个为**父类（基类）**子类继承父类。
• 子类和父类之间，从意义上讲应该具有”is a“的关系。

//学生类(子类)继承 人类(父类)
public class Student extends Person{ /*Person extends Object*/
    ...
}

• 子类继承了父类，就会拥有父类的全部方法，而private私有属性及方法无法继承。
• 在Java中，所有类，都默认直接或间接继承Object类 (Ctrl+H 可以查看类关系)
• 被final修饰的类，无法被继承（断子绝孙）。

Person类

//Person 人 ：父类
public class Person {
    private int money = 10_0000_0000;
    public void say(){
        System.out.println("Hello World!");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

Student类

//学生 is 人：派生类，子类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{

}

super & this

• super()调用父类的构造方法，必须在构造方法的第一个
• super必须只能出现在子类的方法或构造方法中
• **super()和this()**不能同时调用构造方法，因为this也必须写在第一行

super与this的区别：

super代表父类对象的引用，只能在继承条件下使用；this调用自身对象，没有继承也可以使用。

构造方法：
this();本类的构造
super（）；父类的构造

super(); //隐藏代码，默认调用了父类的无参构造，要写只能写第一行

方法的重写

• 重写：子类的方法必须与父类方法必须一致，方法体不同。
• 重写是方法的重写，与属性无关
• 重写方法只与非静态方法有关，与静态方法无关（静态方法不能被重写）

public class B {
    public static void test(){ //静态方法
        System.out.println("B==>test()");
    }
}

public class A extends B{ //继承
    public static void test(){
        System.out.println("A==>test()");
    }
}

public class Application {
    public static void main(String[] args) {
        //方法的调用之和左边定义的类型有关
        A a = new A();
        a.test(); //打印 A==>test()

        //父类的引用指向了子类，但静态方法没有被重写
        B b = new A();
        b.test(); //打印 B==>test()
    }
}

修改A.java, B.java

public class B {
    public void test(){ //非静态方法
        System.out.println("B==>test()");
    }
}
public class A extends B{
    @Override //重写了B的方法
    public void test() {
        System.out.println("A==>test()");
    }
}

//父类的引用指向了子类
B b = new A(); //子类重写了父类的方法，执行子类的方法
b.test(); //打印变成了 A==>test()
/* 
静态方法是类的方法，非静态方法是对象的方法
有static时，b调用了B类的方法，因为b是b类定义的
没有static时，b调用的是对象的方法，而b是A类new出来的对象，调用A的方法
*/

• 重写：需要有继承关系，子类重写父类的方法！

• 静态方法属于类，非静态方法属于对象

• 注意点：

 1、方法名、参数列表必须相同
 2、修饰符范围可以扩大，不能缩小（public>protected>Default>private）
 3、抛出的异常 范围可以被缩小，不能扩大 ClassNotFoundException-->Exception(大)
 4、被**static(属于类，不属于实例)，final(常量方法)，private(私有)**修饰的方法不能重写
为什么需要重写：
1、父类的功能：子类不一定需要，或者不一定满足！
Alt+Insert: override;

方法的重载
区别：重载实现于一个类中;重写实现于子类中。

重载(Overload)：是一个类中多态性的一种表现，指同一个类中不同的函数使用相同的函数名，但是函数的参数个数或类型不同。可以有不同的返回类型;可以有不同的访问修饰符;可以抛出不同的异常。调用的时候根据函数的参数来区别不同的函数。

重写（Override):父类与子类之间的多态性，是子类对父类函数的重新实现。函数名和参数与父类一样，子类与父类函数体内容不一样。子类返回的类型必须与父类保持一致；子类方法访问修饰符的限制一定要大于父类方法的访问修饰（public>protected>default>private）；子类重写方法一定不能抛出新的检查异常或者比被父类方法申明更加宽泛的检查型异常。

多态

• 动态编译：类型

• 即同一方法可以根据发送对象的不同而采用不同的行为方式(多态的意义)

• 一个对象的实际类型是确定的，但可以指向对象的引用可以有很多（一般指父类，有关系的类）

• 多态存在条件

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

注意点：

• 多态是方法的多态，没有属性的多态
• 父类和子类，有联系 类型转换异常: ClassCastException
• 存在条件：继承关系，方法需要重写(若不重写，调用的都是各自自己的方法，那就没有任何区别了)，父类引用指向子类对象！father s1 = new Son();

不能重写，不能实现多态的情况：

1、static 方法属于类，它不属于实例
2、final常量
3、private方法；

instanceof和类型转换

• instanceof 引用类型比较，判断一个对象是什么类型

public class Application {

    public static void main(String[] args) {
//        //Object> Person>Student
//        //Object> Person>Teacher
//        //Object>String
//        Object object = new Student();
//        //System.out.println(X instanceof Y);//能不能编译通过！
//
//
//        System.out.println(object instanceof Student);//true
//        System.out.println(object instanceof Person);//true
//        System.out.println(object instanceof Teacher);//false
//        System.out.println(object instanceof String);//false
//        System.out.println("===================================");
//        Person person = new Student();
//        System.out.println(person instanceof Student);//true
//        System.out.println(person instanceof Person);//true
//        System.out.println(person instanceof Object);//true
//        System.out.println(person instanceof Teacher);//false
//        //System.out.println(person instanceof String);//编译就报错
//        System.out.println("===================================");
//        Student student = new Student();
//        System.out.println(student instanceof Student);//true
//        System.out.println(student instanceof Person);//true
//        System.out.println(student instanceof Object);//true
//        //System.out.println(student instanceof Teacher);//编译就报错
//
//
        //类型之间的转化：基本类型转换 高低（64、32、16、8）
        //高转低强转，低转高，不需要
        //类型之间的转化： 父  子    高-->低
        Person student = new Student();
        //student将这个对象转化为Student类型，我们就可以使用Student类型的方法了
        ((Student)student).go();

        //子类转换为父类，可能会丢失自己本来的一些方法
        Student student1 = new Student();
        student1.go();
        Person person = student;
    }

类型转换
1、父类引用指向子类的对象
2、把子类转换为父类，向上转型，会丢失自己原来的一些方法
3、把父类转换为子类，向下转型，强制转换，才调用子类方法
4、方便方法的调用(转型)，减少重复的代码，简洁。

抽象：
封装、继承、多态
抽象类、接口

static
静态变量可以直接用类名访问，也称类变量。
静态变量(或方法)对于类，所有对象（实例）所共享。
 

public class Student{
    private static int age;//静态的变量
    private double score;//非静态的变量

    public void run2(){

    }
    public static void sing(){

    }

    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(Student.age);
        System.out.println(s1.age);
        System.out.println(s1.score);
        sing();
    }

}

• 静态区代码 加载类时一起被初始化，最早执行且只执行一次（第一次new）。

package kuangshen.demo04;

public class Person {
    //2、赋初始值
    {
        //代码块（匿名代码块）
        System.out.println("匿名代码块");
    }
    //1、
    static {
        //静态代码块，类加载直接执行，永久执行一次
        System.out.println("静态代码块");
    }
    //3、
    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("================");
        Person person2 = new Person();

    }
}
/*
静态代码块
匿名代码块
构造方法
================
匿名代码块
构造方法
 */

• Math->随机数:

//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
    public static void main(String[] args) {
        //第一种随机数，不用导包
        System.out.println(Math.random()); //0.7562202902634543
        
        //第二种随机数，静态导入包
        System.out.println(random());
        System.out.println(PI);
    }
}
/*
0.15872988354589912
3.141592653589793
 */

抽象类（abstract）

• abstract修饰的类就是抽象类，修饰的方法就是抽象方法。
• 抽象类中可以没有抽象方法，但有抽象方法的类一定要声明为抽象类。
• 抽象类不能使用new来创建对象，它是用来让子类继承的。
• 抽象方法只有方法的声明，没有实现，让其子类实现。
• 子类继承抽象类，必须实现抽象类的所有方法，否则该子类也要声明为抽象类。

//abstract 抽象类：类 extends: 单继承（接口可以多继承）
public abstract class Action {
    //约束~有人帮我们实现~
    //abstract,抽象方法，只有方法名字，没有方法的实现！
    public abstract void doSomething();

    //1.不能new抽象类，只能靠子类去实现它，仅作为一个约束
    //2.抽象方法只能出现在抽象类中，抽象类可以有普通方法
    //抽象的抽象：约束
    //3.抽象类有构造器，可以派生子类
    //4.抽象类的意义：约束，提高开发效率。但是类只能单继承，所以有局限 用的不多
    
}

//抽象类的所有方法，继承了它的子类，都必须要实现它的方法

public class A extends Action{
    @Override
    public void doSomething() {

    }
}

接口(interface)

• 普通类：只有具体实现
• 抽象类：具体实现和规范(抽象方法)都有
• 接口：只有规范，没有方法实现，专业的约束！约束与实现分离：面向接口编程~
• 接口就是规范，定义的是一组规则，"你是什么…必须做什么…"的思想。
• 接口的本质是约束，就像人间法律一样，制定好大家都遵守。

//interface 定义的关键字,接口都需要有实现类
public interface UserService {
    //接口中的所有定义其实都是抽象的 public abstract
     void add(String name);
     void delete(String name);
     void update(String name);
     void query(String name);
}

//类 可以实现接口 implements 接口
//实现接口的类，就需要重写接口中的方法
public class UserServiceImpl implements UserService{

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}

精简：

//interface接口,接口都要有继承类
//实现类（implements 可以继承多个接口）
//多继承，利用接口实现多继承
public interface UserService {
    //定义的属性都是常量,默认修饰 public static final
    public static final int AGE = 99; //一般不用
    //所有的定义的方法都是抽象的 默认public abstract
    public abstract void run();
    void add();
    void query();
    void delete();
}

作用：
1、约束
2、定义一些不同的方法，让不同人的实现
3、public abstact
4、public static final
5、接口没有构造方法，不能被实例化
6、实现类必须要重写接口中的方法
7、实现类（implements） 可以实现多个接口

内部类

• 内部类就是在一个类的内部再定义一个类，比如A类中定义了一个B类，那么B就是A的内部类，而A相对B来说就是外部类

1、成员内部类：可以操作外部类的私有属性及方法

 2、静态内部类：static修饰，不能访问外部类私有属性

 3、局部内部类：外部类的方法里定义的类

 4、匿名内部类：没有名字初始化类

 异常

 运行时异常：

 简单分类

• 检查型异常：最具代表性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如用户要打开一个不存在的文件时引发的异常，这些异常在编译时不能被简单地忽略。
• **运行时异常：**是可能被程序员避免的异常，与检查性异常相反，运行时异常可以在编译时忽略。
• **错误Error：**错误不是异常，而是脱离程序员控制的问题。错误在代码经常被忽略。例如当栈溢出，一个异常就发生了，它们在编译也检查不到。

异常体系结构

 Error

 运行时异常

 捕获和抛出异常

 注：finally 可以不要finally ,假设IO，资源，关闭！

• 抛出异常
• 捕获异常
• 异常处理关键字：try、catch、finally、throw、throws

public static void main(String[] args) {
    int a = 1;
    int b = 0;

    try { //try监控区域
        System.out.println(a/b);
    }catch (ArithmeticException e){ //catch 捕获异常
        System.out.println("程序出现异常，变量b不能为0");
    }catch (Exception e){
        e.printStackTrace();
    }finally { //一定会执行，处理善后工作，如关闭资源
        System.out.println("finally");
    }
    
    if(b==0){ //抛出异常一般在方法中使用
        throw new ArithmeticException(); //主动抛出异常
    }
}
//Ctrl+Alt+T 快捷键插入 try-catch

throw,throws区别

 自定义异常

到此就结束了，再次声明，此文，只作本人复习使用。如有侵权，请联系我，将妥善处理。

邮箱：719167291@qq.com