🏀 final关键字

它是一个修饰符，代表最终的意思，可以修饰变量，类，方法

final关键字的特点

  1. 被final关键字修饰的变量是常量

常量的分类：

  • 字面值常量
    • 整数常量
    • 小数常量
    • 字符常量
    • 字符串常量
    • 空常量
    • 布尔常量
  • 自定义常量
    • 被final修饰的变量

  1. 被final修饰的类不能被继承

  2. 被final修饰的成员方法不能被重写

final的注意事项

如果一个成员变量，在被定义的时候，并没有给初始值，会编译报错，我们必须给其赋值

赋值方式有几种？

  1. 显示初始化 final int age = 18;
  2. 有参构造赋值 public void eat(int age){ this.age=age}

🚵‍♀️ 代码块

由一对花括号括号起来的，就称为代码块

代码块的分类

  1. 局部代码块
  2. 构造代码块
  3. 静态代码块
  4. 同步代码块(学习多线程的时候讲解)

局部代码块

定义在方法中的代码，就称为局部代码块

  1. class Demo {
  2.     public void print() {
  3.         {
  4.             //局部代码块
  5.         }
  6.     }
  7. }
  • 局部代码块的作用是什么？

能够让局部变量，更早的在内存中消失，节省内存空间

构造代码块

定义在类中，方法外的代码块，就称为构造代码块

  1. class Demo {
  2.     {
  3.         //构造代码块
  4.     }
  6.     public void print() {
  7.         //构造方法将在构造代码块后执行，与顺序无关
  8.     }
  9. }

构造代码块是在创建对象的时候执行，并且是优先于构造方法先执行

  • 构造代码块的作用是什么？

可以将构造方法中的共性内容进行抽取，放入到构造代码块中，节省代码的编写

  1. 举例子：
  2. public class Demo06 {
  3.     public static void main(String[] args) {
  4.         Child c1 = new Child();
  5.         Child c2 = new Child("张三");
  6.         Child c3 = new Child("哪吒", 18);
  7.     }
  8. }
  10. class Child {
  11.     {
  12.         System.out.println("哭"); //抽取代码块
  13.     }
  15.     public Child() {
  16.         //System.out.println("哭");
  17.     }
  19.     public Child(String name) {
  20.         //System.out.println("哭");
  21.     }
  23.     public Child(String name, int age) {
  24.         //System.out.println("哭");
  25.     }
  26. }

静态代码块

被静态修饰的构造代码块，就称为静态代码块

  1. class Demo {
  2.     static {
  3.         //静态代码块
  4.         //这里写 加载配置文件的一些代码
  5.     }
  6.     public void print() {
  8.     }
  9. }
  • 静态代码块的作用是什么？

给数据进行初始化，当数据只需要被初始化一次的时候，之后可以重复使用的时候，就可以使用静态代码块

  • 静态代码块是什么时候执行的？

当.class文件从本地磁盘加载到方法区中形成字节码文件对象的时候，静态代码块会随之执行

  • 为什么静态代码块只会执行一次？

因为字节码文件只加载一次，并且优先于所有的对象存在于内存中，比构造方法先执行
image.png

🥁 抽象类

被abstract关键字所修饰的类就是个抽象类

有抽象方法的类就是抽象类

  • 什么是抽象方法？

没有方法体的方法，且被abstract关键字修饰的方法就是抽象方法

抽象类的特点

  1. 抽象类和抽象方法都要由abstract关键字来修饰 ```java abstract class Person { //抽象类 public abstract void eat(); //抽象方法,没有方法体
    1.  //正常情况下,方法体永远不会执行
    }

class Student extends Person { public void eat() { System.out.println(“吃肉”) } }

class Teacher extends Person { public void eat() { System.out.println(“吃米饭”); } }

class Demo { public static void main(String[] args) { Student s = new Student();

  1.     Person p = new Student();
  3.     Teacher t = new Teacher();
  4. }

}

  2. 2. 抽象类可以没有抽象方法，但是有抽象方法的类一定是抽象类
  3. ```java
  4. abstract class Person {
  5.     public void eat() {}
  6.     public void sleep() {}
  7.     public abstract void drink();
  8. }

如果一个抽象类中没有任何抽象方法，适配器设计模式
构造方法都是public修饰，但是如果是private修饰的话，要么是工具类，提供了static的成员方法，可以通过类名调用，要么就是单例设计模式

  1. 抽象类因为没有方法体，所以不能创建对象
  2. 一个类想要继承一个抽象类，要么该类也是一个抽象类，要么该类是一个普通类，但是必须重写所有的抽象方法

抽象类的成员特点

  1. 成员变量

里面可以有静态的成员变量
里面可以有非静态的成员变量
里面可以自定义常量

  1. 成员方法

抽象类中可以有抽象方法，也可以里面可以有成员方法（非抽象方法）。

  1. 构造方法

有构造方法，但是，抽象类不能创建对象，为什么会有构造方法？
因为抽象类的构造方法是用来让子类去调用的，然后给抽象类中的成员变量进行初始化，好提供给子类使用

  1. abstract class Person {
  2.     int i;
  4.     public Person() {
  5.     }
  7.     public abstract void eat();
  8.     public abstract void play();
  10.     public void sleep(){
  11.     }
  13.     public void drink(){
  14.     }
  15. } 
  17. class Student extends Person {
  18.     public Student(){
  19.         super();
  20.     }
  21. }

abstract关键字和不能哪些关键字共存

  1. abstract不能和private关键字共存：

因为被abstract关键字修饰的方法是抽象方法，子类是一定要重写的，如果该方法同时又被private修饰的话，子类还重写不了，所以冲突

  1. abstract class Fu {
  2.    private abstract void print();//报错
  3. }
  5. class Zi extends Fu {
  6.    public void print() {
  7.    }
  8. }
  1. abstract不能和static关键字共存：

因为被static关键字所修饰的方法可以通过类名直接调用，但是同时被abstract关键字修饰的方法，没有方法体的，调用一个没有方法体的方法？？？

  1. abstract class Fu {
  2.     public abstract static void print();//报错
  3. }
  5. Fu.print();
  1. abstract不能和final关键字共存：

因为被abstract关键字修饰的方法是抽象方法，子类是一定要重写的，如果该方法同时又被final修饰的话，子类还重写不了，所以冲突

  1. abstract class Fu {
  2.     public final abstract void print();//报错
  3. }
  5. class Zi extends Fu {
  6.     public void print() {
  8.     }
  9. }

image.png

🤼‍♂️ 接口

比抽象类更加抽象的表现形式，就是接口

接口的定义格式

  1. interface 接口名 {
  3. }

接口不是类

接口的使用格式

  1. interface Inter {
  3. }
  5. class Zi implements Inter {
  7. }

接口的特点

  1. 接口不能创建对象

  2. 一个类想要实现一个接口，要么该类是一个抽象类，要么该类是一个普通类，就必须重写接口中的所有的抽象方法

    1. public class demo03 {
    2.  public static void main(String[] args) {
    3.      Zi zi = new Zi();
    4.      zi.print();
    5.  }
    6. }
    7. interface Inter {
    8.  public abstract void print();
    9.  public abstract void show();
    10. }
    11. class Zi implements Inter {
    13.  @Override
    14.  public void print() {
    15.      System.out.println("重写后的print方法");
    16.  }
    18.  @Override
    19.  public void show() {
    20.      System.out.println("重写后的show方法");
    21.  }
    22. }

接口的成员特点

  1. 成员变量：

接口中的所有的变量全部都是自定义常量
默认修饰符：public static final

  1. (public static final) int i = 1;
  2. static final int j = 1; 
  3. int x = 1;
  1. 成员方法：

接口中的所有的方法都是抽象方法(错误的解释)
默认修饰符：public abstract

  1. public abstract void aaa();
  2. abstract void bbb();
  3. public void ccc();
  4. void ddd();
  1. 构造方法：

接口中没有构造方法
继承的是object方法

接口与接口，类与类，接口与类之间的关系

  1. 类与类：继承关系，单继承，不可以多继承，也可以实现其他的接口 ```java class Fu { public void eat() {
    1.  System.out.println("吃肉");
    } }

class Zi extends Fu {

}

  2. 2. 类与接口：实现关系，支持单实现，也可以多实现
  3. ```java
  4. interface Inter {
  6. }
  8. interface Inter1 {
  10. }
  12. class Zi implements Inter, Inter1 {
  14. }
  1. 接口与接口：继承关系，支持单继承，也可以多继承 ```java interface A { public abstract void eat(); }

interface B {

}

interface C extends A, B {

}

class Zi implements C { public void eat() {

  1. }

}

  3. <a name="uhHQq"></a>
  4. ## 我们什么时候使用接口，什么时候使用类(包含抽象类)
  6. 1. 当两个类之间存在"is a"，就要定义类，两个类之间是继承关系
  7. 1. 接口是额外扩展的功能，本身该类不具备这个功能，而且还不是"is a"的关系，就需要去实现这样的接口了
  9. 举例子：
  10. ```java
  11. public class demo04 {
  12.     public static void main(String[] args) {
  13.         Dog d = new Dog();
  14.         d.eat();
  15.         d.fly();
  16.         d.play();
  17.     }
  18. }
  20. abstract class Animal {
  21.     public abstract void eat();
  22.     public void drink() {
  23.         System.out.println("喝水");
  24.     }
  25. }
  27. class Dog extends Animal implements Fly{
  28.     public void play(){
  29.         System.out.println("捡骨头");
  30.     }
  31.     public void eat(){
  32.         System.out.println("狗食");
  33.     }
  34.     public void fly(){
  35.         System.out.println("上下飞");
  36.     }
  37. }
  38. class Cat extends Animal implements Fly{
  39.     public void sleep() {
  40.         System.out.println("睡觉");
  41.     }
  42.     public void eat(){
  43.         System.out.println("猫食");
  44.     }
  46.     public void fly() {
  47.         System.out.println("斜着飞");
  48.     }
  49. }
  50. class Pig1 extends Animal implements Fly {
  51.     public void gong() {
  52.         System.out.println("拱树");
  53.     }
  54.     public void eat() {
  55.         System.out.println("猪食");
  56.     }
  57.     public void fly(){
  58.         System.out.println("横着飞");
  59.     }
  61. }
  63. interface Swin {
  64.     public abstract void swimming();
  65. }
  66. interface Fly {
  67.     public abstract void fly();
  68. }

image.png

🏆 包

包本质上就是文件夹

怎么创建包

文件夹与文件夹之间用.来分隔
com.woniu

包命名规则

一般都是公司的域名倒着写，去掉www
com.woniuxy.XXXOOO

注意：包名都是小写的

导包

  1. import 包名.类名

如果两个类不再同一个包的下面，类A想使用类B，就要先导入类B

com.aaa
-A
com.bbb
-B

🛀 访问权限修饰符

public > protected > 默认的(什么都不写) > private

修饰符 同一个类 同一个包不同类 不同包有继承 不同包无继承
private yes
default yes yes
protected yes yes yes
public yes yes yes yes

以后开发，一个类的各个组成部分都都什么修饰符来修饰：

  • 类是用public修饰的
  • 属性是用private修饰的
  • 构造方法是用public修饰的
    • 偶尔会用private修饰的
  • 成员方法是用public修饰的

🥇 内部类

一个类写在另外一个类的里面，里面的类就是内部类

内部类的特点

内部类可以直接访问外部类的成员，包括私有的
但是，外部类不能直接使用内部类的成员，但是可以间接使用

内部类的分类

成员内部类

  • 定义在类中，方法外的内部类

    1. class Outer {
    2.   class Inner {
    4.   }
    5. }

  • 成员内部类的使用

public/protected/默认：

  1. class Demo {
  2.     public static void main(String[] args) {
  3.         Outer.Inner oi = new Outer().new Inner();
  4.         System.out.println(oi.i);
  5.         oi.print();
  6.     }
  7. }
  9. class Outer {
  10.     class Inner {
  11.         int i = 1;
  13.         public void print() {
  14.             System.out.println("约吗");
  15.         }
  16.     }
  17. }
  1. class Outer {
  2.     static class Inner {
  3.         int i = 1;
  5.         public void print() {
  6.             System.out.println("约吗");
  7.         }
  8.     }
  9. }
  11. class Demo {
  12.     public static void main(String[] args) {
  13.         Inner inner = new Inner();
  14.         System.out.println(inner.i);
  15.         inner.print();
  16.     }
  17. }
  1. import com.inner.Outer.Inner;
  3. class Demo {
  4.     public static void main(String[] args) {
  5.         Outer.Inner oi = new Outer.Inner();
  6.         System.out.println(oi.i);
  7.         oi.print();        
  8.     }
  9. }
  11. class Outer {
  12.     static class Inner {
  13.         int i = 1;
  15.         public void print() {
  16.             System.out.println("约吗");
  17.         }
  18.     }
  19. }
  1. class Demo {
  2.     public static void main(String[] args) {
  3.         Outer outer = new Outer();
  4.         outer.show();
  5.     }
  6. }
  8. class Outer {
  9.     private class Inner { //
  10.         int i = 1;
  12.         public void print() {
  13.             System.out.println("约吗");
  14.         }
  15.     }
  17.     public void show() {
  18.         Inner inner = new Inner();
  19.         System.out.println(inner.i);
  20.         inner.print();
  21.     }
  22. }

局部内部类

  • 定义在方法中的内部类

    1. class Outer {
    2.   public void print() {
    3.       class Inner { //局部内部类
    5.       }
    6.   }
    7. }

  • 局部内部类怎么使用？ ```java class Demo { public static void main(String[] args) {

    1.   Outer outer = new Outer();
    2.   outer.print();

    } }

class Outer { public void print() { class Inner { int i = 2; public void show() { System.out.println(“滚犊子”); } }

  1.     Inner inner = new Inner();
  2.     System.out.println(inner.i);
  3.     inner.show();
  4. }

}

  3. <a name="U1iVa"></a>
  4. # 🚴 匿名内部类
  6. > 没有名字的局部内部类，也叫做匿名子类对象
  9. <a name="XoXVr"></a>
  10. ## 匿名内部类的定义格式
  11. ```java
  12. new 类名/接口名() {
  13.     //重写的方法
  14.     //自定义的方法
  15. };
  17. new Person() {
  19. };

我们什么时候可以使用匿名子类对象？
当一个方法的形参是接口或者抽象类的时候，我们就可以选择使用匿名子类对象

  1. interface Inter {
  2.     public abstract void print();
  3. }
  5. class Demo {
  6.     public static void main(String[] args) {
  7.         show(new Inter() {
  8.             public void print() {
  9.                 System.out.println("真棒");
  10.             }
  11.         });
  12.     }
  14.     public static void show(Inter inter) {//Inter inter = new Inter() {
  15.                                           //    public void print() {
  16.                                           //        System.out.println("约吗");
  17.                                           //    }
  18.                                           //};
  19.         inter.print();
  20.     }
  21. }

面试题？

  1. public class Demo01 {
  2.     public static void main(String[] args) {
  3.         new Fu() {
  4.             //方法的重写
  5.             public void show(Inter inter) {
  6.                 inter.print();
  7.             }
  8.         }.show(new Inter() {
  9.             //方法的重写
  10.             public void print() {
  11.                 System.out.println("约吗");
  12.             }
  13.         });
  14.     }
  15. }
  17. abstract class Fu {
  18.     public abstract void show(Inter inter);
  19. }
  21. interface Inter {
  22.     public abstract void print();
  23. }
  1. public class Demo02 {
  2.     public static void main(String[] args) {
  3.         Tool.getInstance().show();//在控制台上打印出一句话
  4.     }
  5. }
  7. interface Inter {
  8.     public abstract void show();
  9. }
  11. class Tool {
  12.     public static Inter getInstance() {
  13.         return new Inter() {
  14.             public void show() {
  15.                 System.out.println("约吗");
  16.             }
  17.         };
  18.     }
  19. }

五子棋

落子功能
1.棋子如果做出来的，怎么能够实现恰好放到交叉点上
a.落在交叉点上
b.鼠标点哪个交叉点，棋子就落在哪个点上面
2.如何做棋子，放到棋盘上

任务：
1.做到黑白交替
2.在同一位置不能被覆盖

1.Object类
Object类是所有类的直接或者间接的超类

public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。
一般我们使用equals是用来比较两个对象是否相同(不是地址值的相同，是两个对象的属性是否完全一致)

==：
==如果两边是基本数据类型数据，比较的就是数值的大小
==如果两边是引用数据类型数据，比较的就是地址值

public String toString()：返回该对象的字符串表示。
注意：当我们在输出语句中打印一个对象的时候，会默认调用该对象toString()方法

2.五子棋
判断胜负

重新开局
退出
保存棋谱
打谱(复盘)