java基础_面向对象高级-CSDN博客

static
●叫静态，可以修饰成员变量、成员方法。
成员变量按照有无static修饰，分为两种：
类变量：有static修饰，属于类，在计算机里只有一份，会被类的全部对象共享。
实例变量（对象的变量）：无static修饰，属于每个对象的。

1、static修饰的成员方法叫什么？如何使用？
类方法（静态方法）
属于类，可以直接用类名访问，也可以用对象访问
        类名.类方法（推荐）
        对象名.类方法（不推荐）
2、无static修饰的成员方法叫什么？如何使用？
实例方法（对象的方法）
属于对象，只能用对象访问  对象.实例方法

类方法的常见应用场景

类方法最常见的应用场景是做工具类。
工具类是什么？
工具类中的方法都是一些类方法，每个方法都是用来完成一个功能的，工具类是给开发人员共同使用的。
使用类方法来设计工具类有啥好处？
提高了代码复用；调用方便，提高了开发效率。

使用类方法、实例方法时的几点注意事顶
类方法中可以直接访问类的成员，不可以直接访问实例成员。
实例方法中既可以直接访问类成员，也可以直接访问实例成员。
实例方法中可以出现this关键字，类方法中不可以出现ths关键字的。

代码块

代码块概述
代码块是类的5大成分之一（成员变量、构造器、方法、代码块、内部类)。
代码块分为两种：
静态代码块：
格式：static{ }
特点：类加载时自动执行，由于类只会加载一次，所以静态代码块也只会执行一次。
作用：完成类的初始化，例如：对类变量的初始化赋值。

实例代码块：
格式：{}
特点：每次创建对象时，执行实例代码块，并在构造器前执行。
作用：和构造器一样，都是用来完成对象的初始化的，例如：对实例变量进行初始化赋值。

2.继承

Java中提供了一个关键字extends,用这个关键字，可以让一个类和另一个类建立起父子关系。
public class B extends A{

}
A类称为父类（基类或超类）。
B类称为子类（派生类）。
继承的特点
●子类能继承父类的非私有成员（成员变量、成员方法）。
继承后对象的创建
●子类的对象是由子类、父类共同完成的。

继承相关的注意事项

1.权限修饰符

2.单继承和Object类

①单继承

java是单继承，java类不支持多继承，但是支持多层继承、

②Object

所有类都是Object类的子类或者子孙类

3.方法重写

什么是方法重写？
当子类觉得父类中的某个方法不好用，或者无法满足自己的需求时，子类可以重写一个方法名称
参数列表一样的方法，去覆盖父类的这个方法，这就是方法重写。
注意：重写后，方法的访问，Java会遵循就近原则。

方法重写的其它注意事项
●重写小技巧：使用@Override注解，他可以指定jva编译器，检查我们方法重写的格式是否正确，代码可读性也会更好。

●子类重写父类方法时，访问权限必须大于或者等于父类该方法的权限(public>protected>缺省)。
●重写的方法返回值类型，必须与被重写方法的返回值类型一样，或者范围更小。
●私有方法、静态方法不能被重写，如果重写会报错的。

在子类方法中访问其他成员（成员变量、成员方法），是依照就近原则的。
●先子类局部范围找。
●然后子类成员范围找。

●然后父类成员范围找，如果父类范围还没有找到则报错。

如果子父类中，出现了重名的成员，会优先使用子类的，如果此时一定要在子类中使用父类的怎么办？
●可以通过super:关键字，指定访问父类的成员：super.父类成员变量/父类成员方法

4.子类构造器的特点：

●子类的全部构造器，都会先调用父类的构造器，再执行自己。

子类的构造器第一行都默认有一个super()方法，来调用父类的无参构造器

●如果父类没有无参数构造器，则我们必须在子类构造器的第一行手写super(…),指定去调用父类的有参数构造器。
public class Text2 {
    public static void main(String[] args) {
        Teacher teacher = new Teacher("wwl",19,"java");
        System.out.println(teacher.getName());
        System.out.println(teacher.getAge());
        System.out.println(teacher.getSkill());

    }
}

class Teacher extends People{
    private String skill;

    public Teacher(String name,int age,String skill){
        super(name,age);
        this.skill = skill;
    }

    public String getSkill() {
        return skill;
    }

    public void setSkill(String skill) {
        this.skill = skill;
    }
}

class People{
    private String name;
    private int age;

    public People() {
    }

    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
补充知识：this()调用兄弟构造器

●任意类的构造器中，是可以通过this(...)去调用该类的其他构造器的。
public class Text3 {
    public static void main(String[] args) {
        //掌握在类的构造器中，通过this()实现调用兄弟构造器
        Student student = new Student("wwl",19,"清华大学");

        //需求：如果没有写学校的话，那么学校默认是清华大学
        Student st2 = new Student("zn",11);

        //解决方法，在Student里，再创建一个构造器
        System.out.println(st2.getName());
        System.out.println(st2.getAge());
        System.out.println(st2.getSchoolName());
    }
}

class Student{
    private String name;
    private int age;
    private String schoolName;

    public Student() {
    }

    public  Student(String name ,int age){
    //通过this调用兄弟构造器，最后在赋值默认值
        this(name,age,"清华大学");
    }


    public Student(String name, int age, String schoolName) {
        this.name = name;
        this.age = age;
        this.schoolName = schoolName;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSchoolName() {
        return schoolName;
    }

    public void setSchoolName(String schoolName) {
        this.schoolName = schoolName;
    }
}

3.多态

什么是多态？

多态是在继承/实现情况下的一种现象，表现为：对象多态、行为多态。
多态的具体代码体现

编译看左边，执行看右边
//编译看左边，执行看右边
People p1 = new Student();
p1.run();
People p2 = new Teacher();
p2.run();
多态的前提

有继承/实现关系；存在父类引用子类对象；存在方法重写。
多态的一个注意事项
●多态是对象、行为的多态，Jva中的属性（成员变量）不谈多态。

使用多态的好处

●在多态形式下，右边对象是解耦合的，右边的对象可以随时更改，更便于扩展和维护。

●可以使用父类类型的变量作为形参，可以接收一切子类对象。
public class People {
    public void run(){
        System.out.println("人会跑~");
    }
}
public class Student extends People{
    @Override
    public void run() {
//        super.run();
        System.out.println("学生跑的很快~");
    }
    public void text(){
        System.out.println("学生需要考试~");
    }
}
public class Teacher extends People{
    @Override
    public void run() {
//        super.run();
        System.out.println("老师跑的气喘吁吁~");
    }

    public  void teach(){
        System.out.println("老师需要教书~");
    }

}
public class Text {
    public static void main(String[] args) {
        People p1 = new Student();
        p1.run();
//        p1.test(); 报错

    }
}
多态下会产生的一个问题，怎么解决？
多态下不能使用子类的独有功能。

类型转换

自动类型转换：父类变量名 = new 子类()
例如：People p=new Teacher();
强制类型转换：子类变量名 =（子类）父类变量
例如Teacher t=(Teacher)p;

强制类型转换的一个注意事项
●存在继承/实现关系就可以在编译阶段进行强制类型转换，编译阶段不会报错。
●运行时，如果发现对象的真实类型与强转后的类型不同，就会报类型转换异常(ClassCastException)的错误出来。

强转前，Java建议：使用instanceof关键字，判断当前对象的真实类型，再进行强转。
p instanceof Student 
判断p是否是Student类型，是的话，会返回true
People p1 = new Student();
        p1.run();
        if(p1 instanceof Student){
            Student p2 = (Student)p1;
            p2.text();
        }else {
            Teacher p2 = (Teacher) p1;
            p2.teach();
        }

4.Final

final关键字是最终的意思，可以修饰（类、方法、变量）
修饰类：该类被称为最终类，特点是不能被继承了。
修饰方法：该方法被称为最终方法，特点是不能被重写了。
修饰变量：该变量只能被赋值一次。

final修饰变量的注意
final修饰基本类型的变量，变量存储的数据不能被改变。
final修饰引用类型的变量，变量存储的地址不能被改变，但地址所指向对象的内容是可以被改变的。

5.常量

●使用了static final修饰的成员变量就被称为常量：
●作用：通常用于记录系统的配置信息。
public class Text2 {
    public static final String MY_NAME = "彭于晏";
    public static void main(String[] args) {
        System.out.println(MY_NAME);
    }
}
注意！常量名的命名规范：建议使用大写英文单词，多个单词使用下划线连接起来。
使用常量记录系统配置信息的优势、执行原理
●代码可读性更好，可维护性也更好。
●程序编译后，常量会被“宏替换”：出现常量的地方全部会被替换成其记住的字面量
这样可以保证使田堂景知直接田字面景的性能是一样的

6.抽象

什么是抽象类？

●在到java中有一个关键字叫：abstract,它就是抽象的意思，可以用它修饰类、成员方法。
●abstract修饰类，这个类就是抽象类；修饰方法，这个方法就是抽象方法。
修饰符abstract class类名{
    修饰符 abstract 返回值类型 方法名称（形参列表）;
}

public abstract class A{
//抽象方法：必须abstract修饰，只有方法签名，不能有方法体。
    public abstract void test();
}
抽象类的注意事项、特点

抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。
类该有的成员（成员变量、方法、构造器）抽象类都可以有。
抽象类最主要的特点：抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现。
一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。

7.接口

认识接口

接口的好处

弥补了类单继承的不足，一个类同时可以实现多个接口。
让程序可以面向接口编程，这样程序员就可以灵活方便的切换各种业务实现。
public class Text {
    public static void main(String[] args) {
        Driver s1 = new A();
        s1.run();

    }
}
//A继承了Student，并且实现了Driver和Singer接口
class A extends Student implements Driver,Singer{

    //实现接口的时候必须重写方法
    @Override
    public void run() {
        System.out.println("司机开车");
    }

    @Override
    public void Sing() {
        System.out.println("歌手唱歌");

    }
}
class Student{

}
interface Driver{
    void run();
}
interface Singer{
    void Sing();
}
jdk 8开始接口里新增的方法

一个接口可以继承多个接口

接口其他注意事项（了解）
1、一个接口继承多个接口，如果多个接口中存在方法签名冲突，则此时不支持多继承。
2、一个类实现多个接口，如果多个接口中存在方法签名冲突，则此时不支持多实现。
3、一个类继承了父类，又同时实现了接口，父类中和接口中有同名的默认方法，实现类会优先用父类的。
4、一个类实现了多个接口，多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可。

8.内部类

是类中的五大成分之一（成员变量、方法、构造器、内部类、代码块），如果一个类定义在另一个类的内部，这个类就是内部类。

1.成员内部类
public class Outer {
    private int age;
    public class Inner{
        private String name;

        public void run(){
            System.out.println(age);
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }
    public void tun2(){
        System.out.println(age);
    }

}
public class Text {
    public static void main(String[] args) {
        //调用内部类
        Outer.Inner in = new Outer().new Inner();
        in.setName("wwl");
        System.out.println(in.getName());
    }
}
1.成员内部类是什么？如何创建其对象？
就是类中的一个普通成员，类似前面我们学过的普通成员变量、成员方法
●外部类名.内部类名对象名=new外部类(…).new内部类(…);
2.成员内部类的实例方法中，访问其他成员有啥特点？
●可以直接访问外部类的实例成员、静态成员
可以拿到当前外部类对象，格式是：外部类名.this。

2.静态内部类

3.局部内部类

4.匿名内部类

匿名内部类在开发中的使用场景
●通常作为一个参数传输给方法。