Java学习(static静态,继承extends,final,多态,抽象类abstract,接口interface,内部类)

---

前言

---

本篇文章主要讲Java面向对象的基础知识
static,继承,final,多态,抽象类,interface,内部类

---

一、static 关键字

---

1.static 被该类的所有对象共享

2.static 被该类的所有对象共享

①、先创建一个 Student 类

class Student {

    public String name;
    public int age;
    public static String country;
}

②、主方法里 new Student

public static void main(String[] args) {
        //static关键字
        // 1. static 被该类所有的对象共享
        // 2. static可以被类名调用
        Student s = new Student();
        s.name = "张三";
        s.age = 23;
        Student.country = "印度";//这里s.country 背景变色，可以直接用类名调用
        String c = Student.country;//背景不变色
        //static可以被类名直接调用

        Student s1 = new Student();
        s1.name = "李四";
        s1.age = 24;
        Student.country = "中国";

        System.out.println(Student.country);//中国
        System.out.println(Student.country);//中国
        //static 被该类所有的对象共享,内存地址中只有一个country的地址
    }

二、继承 extends

---

子类继承了父类，就能使用父类的属性，也可以重写父类的方法

①、先创建父类 Person ，子类 Student

class Person {
    public String name;
    public void show(){
        System.out.println("我是："+name);
    }
}
class Student extends Person{//子类继承了父类
    @Override//子类重写了父类的方法
    public void show() {
        System.out.println("我是：" + name);
    }

    public void study() {//子类特有的方法
        System.out.println("好好学习,天天向上");
    }
}

②、主方法 分别 new 父类 、子类

public static void main(String[] args) {
        Person p = new Person();
        p.name = "老张";
        p.show();//我是：老张

        Student s = new Student();
        s.name = "小明";
        s.show();//我是：小明
}

三、final

---

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

2、final 修饰的方法 不能被重写

3、final 修饰的变量 就变成了常量(不能再次被赋值)

final class Person {
}
class Student /*extends Person*/ {//这里报错 final 修饰的类    不能被继承
}

class Person1 {
    public final void show() {
        System.out.println("Person1");
    }
}
class Student1 extends Person1{
    /*public void show() {//这里报错 final 修饰的方法  不能被重写
        System.out.println("Student1");
    }*/
}

class Person2 {
   /* final int a;*/ //报错 final 修饰的变量  就变成了常量(不能再次被赋值)
    final int b = 10;//编译正常
}

四、多态

---

多态的前提

1. 多态必须是继承或实现关系

2. 父类的变量 接收 子类的对象

3. 方法的重写(可有可无)

①、创建 父类 Animal 子类 Cat，并让子类重写父类的方法

class Animal {
    public void show() {
        System.out.println("我是 Animal");
    }
    public void method() {
        System.out.println("Animal 的 method 方法");
    }
}

class Cat extends Animal {
    @Override
    public void show() {
        System.out.println("我是 Cat");
    }

    public void catchMouse() {
        System.out.println("Cat 抓 老鼠");
    }
}

②、 主方法里创建父类，子类

public static void main(String[] args) {
        Animal a = new Cat();
        a.show(); // 我是 Cat
        a.method(); // Animal 的 method 方法
        /*a.catchMouse();*/ //报错 //子类特有的方法

        Cat c = new Cat();
        c.show(); // 我是 Cat
        c.method(); // Animal 的 method 方法
        c.catchMouse(); // Cat 抓 老鼠
       
}

③、多态的应用：
能提高代码的 复用性 和扩展性。提高效率！

五、抽象类 abstract

---

①、创建一个抽象父类 Animal 和 子类 Cat
继承了带有抽象方法的抽象类，子类必须要对父类里所有抽象方法进行重写，不然就会报错

abstract class Animal {
    public void show() {
        System.out.println("Animal");
    }

    public abstract void method();
}

class Cat extends Animal {//继承了带有抽象方法的抽象类，子类必须要对父类里所有抽象方法进行重写，不然就会报错
    @Override
    public void method() {
        System.out.println("method");
    }
}

②、主方法里 new 对象
很显然这里报错，抽象类abstract 的使用细节：

public static void main(String[] args) {
        /*
            抽象类 abstract
            1.  抽象类不能创建对象
            2.  子类继承了带有抽象方法的抽象父类，
                子类必须要对父类里所有抽象方法进行重写，
                不然就会报错
         */

        /*Animal a = new Animal();*/ //报错，抽象类不能创建对象
    }

六、接口 interface

---

接口的使用细节：

1. 无法创建对象

既然 有抽象方法的类：抽象类都不能创建对象，那么 接口就更不能创建对象了

2. 接口里没有变量都是常量

①、在创建属性的时候 public static final 在接口中是默认的
                因此变量属性变成了常量
②、接口中只有抽象方法，并且没有方法体；(没有{}及里边的东西)
                所有的接口都会默认在方法前边给出 public abstract 关键字

3. 接口里方法都是抽象的

子类实现接口，要把接口中的所有抽象方法  全部重写

4. 类实现接口可以多实现

①、子类可以多实现接口，因为接口里的方法都是抽象方法，
②、子类在实现的时候就要把父类的所有抽象方法全部重写
③、所以编译器知道子类在调用方法的时候是用的子类的方法
④、但是子类只能单继承，因为父类有同样的方法，子类不重写的话，
            会导致编译器不知道你要用的是哪个父类的方法

①、这里创建接口 子类

interface Face {
    void show();
    //前边的 public abstract 是默认给出的关键字，编写时可忽略
    void method();

}

class Student implements Face {

    @Override
    public void show() {
        System.out.println("子类的show方法");
    }

    @Override
    public void method() {
        System.out.println("子类的method方法");

    }
}
interface Face1 {
    int a = 10;
    void show();
}
interface Face2 {
    void show();
}

class Student1 implements Face1, Face2 {
    @Override
    public void show() {

    }
}

②、在主方法里测试

public static void main(String[] args) {      
        /*Face f = new Face();*/ //编译报错 接口无法创建对象
        Student s = new Student();
        s.show();    //子类的show方法
        s.method();  //子类的method方法
}

七、内部类

---

1、成员内部类

在类的 内部 里的 类

//成员内部类
class Student {
    int age = 20;
    class Study {
        int age = 18;
        public void show() {
            System.out.println(age);
        }
    }
    public void method() {
        System.out.println(new Study().age);
    }
}

2、局部内部类

在类的 方法 里的 类

//局部内部类
class Phone {
    int a = 6666;
    public void show() {
        int a = 8888;
        class applePhene {
            final int a = 9999;
            public void show(){
                System.out.println(a);
            }
        }
    }
}

3、匿名内部类

没有类名 在被调用时或自己调用自己的方法时被使用

①、匿名内部类(重点)(最常用)

interface Face {
    void show();
}

②、在主方法里测试

public static void main(String[] args) {
        show(new Face() {
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        });
        //lambda表达式：
        show(()->{ System.out.println("Lambda：匿名内部类"); });
}
public static void show(Face f) {
        f.show();
}

4、Lambda 表达式

/*
            ()  表示重写方法的参数小括号
            ->  表示传入    方法的参数传入到 方法体中去使用
            {}  表示 方法体的{}

            Lambda 表达式的前提条件：
            1.  必须是接口才能使用Lambda
            2.  接口中必须必须！只能有！一个！抽象！方法，才能用Lambda 表达式
            3.  必须要有上下文的推导逻辑，
                比如要传入的参数正好是具有一个抽象方法的接口
*/

---

总结

以上就是Java面向对象的基础知识
static,
继承 extends,
final,
多态,
抽象类 abstract,
接口 interface,
内部类
1.成员内部类
2.局部内部类
3.匿名内部类

虽然只写了个大概。。。后期慢慢的更新
希望有大佬带带我 \狗头滑稽 😂