java面对对象编程-类与对象 知识点总结

1丶面向对象的特点：

1、封装性
2、继承性
3、多态性

2丶类与对象

类是对象的抽象，它用于描述一组对象的共同特征和行为
类中可以定义成员变量和成员方法，其中成员变量用于描述对象的特征，也被称为属性，成员方法用于描述对象的行为，称为方法。定义在方法内的变量称为局部变量。

3丶对象内存

栈内存：存放的是局部变量
堆内存：保存的是真正的数据，即对象的属性信息

4丶错误

对象（引用数据类型）必须在实例化后调用，否则会产生NullPointerExpection（运行时错误），编译时不会出错（出现此类异常，就根据出错位置查看引用类型变量是否初始化）。

5丶private实现封装

private String name；
private int age；

6丶this关键字

1.调用本类属性，2.调用本类方法，3.表示当前对象

问：你是怎么理解this？
答：this是当前对象的引用（当前对象的内存地址）

this.name=name'
this.age=age;

7丶对象属性的初始化方式

1.提供一系列的get和set方法（public）
2.提供合适的构造函数（通过构造函数）
3.静态代码块（static），实力代码块{ }

对象的初始化顺序：.静态代码块===》实例代码块===》构造函数

8丶对象的产生需要2步：

1.为对象开辟内存
2.调用合适的构造函数（构造函数不止一个）

9丶静态代码块只会被初始化一次（只能打印出来1次）
static所修饰的在加载时就执行
static所修饰的不依赖对象（先被执行）

10丶内部类和外部类

定义：所谓的内部类就是在一个类的内部进行其他类结构的嵌套的操作。
分类：1.成员内部类 2.静态内部类 3.方法内部类 4.匿名内部类
在外部类内部创建内部类：Inner in = new Inner（）;
实例内部类：

class OuterClass {
    public int data1 = 77;
    private int data2 = 20;
    int data3 = 30;//包访问权限
    public static int data4 = 40;

    public OuterClass() {
        System.out.println("OuterClass.inti()");
    }

   

静态内部类：

class OuterClass {
    public int data1 = 77;
    private int data2 = 20;
    int data3 = 30;//包访问权限
    public static int data4 = 40;


    static class InnerClass{
        public int data1 = 10;
        private OuterClass out;
        public InnerClass() {

        }
       

本地内部类：

class OuterClass {
    public int data1 = 77;
    private int data2 = 20;
    int data3 = 30;//包访问权限
    public static int data4 = 40;

            public void show() {
                System.out.println(a);
                System.out.println(data4);
                System.out.println("InnerClass.show()");
            }
        }
        InnerClass innerClass = new InnerClass();
        innerClass.show();
    }

}

匿名内部类：

interface Button{
    void test();
}
class A implements Button {

    @Override
    public void test() {

    }
}*/
public class TestDemo4 {
    /*public static void main(String[] args) {
        //Button button = new Button();

        new Button(){
            @Override
            public void test() {
                System.out.println("main.test()");
            }
        }.test();
    }*/

    public static void main1(String[] args) {
        new OuterClass(){
           public void function() {
                System.out.println("main.function()");
            }
        }.function();
    }

    /*public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.func2();
    }*/
    /*public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass innerClass =
                new OuterClass.InnerClass(outerClass);
        innerClass.fun1();
    }*/

外部类的创建语法：外部类.内部类对象=new 外部类.内部类（）；

问题：
1丶实例内部类能否定义static的数据成员？
答：能public static final int A=100;
不能public static int A=100；
（ final一定要在编译期间确定的值）
2丶实例内部类对象是否有额外的内存消耗？
答：有（实例内部类拥有外层类的this引用）
3丶静态内部类能否访问外部类的实例数据成员？
答：一般不可以，可以===>System.out.println(this.out.data2);

11丶继承

继承用extends关键字实现
语法：class 子类 extends 父类

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

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

    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 getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }

    public void playBean() {
        System.out.println("wen is playingBean");
    }

问题：
1、派生类继承了基类，继承了什么东西？

• 除构造函数外的其他东西。
• 派生类需要帮助基类构造。

2丶super（name，age）；

• super();//调用基类的构造函数
• spuer.data;//访问基类的属性
• super.func()//调用基类的成员函数

3丶

• invokespecial 构造函数
• invokevirtual 普通方法 虚函数
• invokestatic 静态方法

12丶多态

多态：基类引用 派生类对象，并且基类和派生类有 同名的覆盖(重写)方法。

方法的多态性：
①方法的重载：同一个方法名称可以根据参数的类型或个数不同调用不同的⽅法体
②方法的覆写：同一个父类的方法，可能根据实例化子类的不同也有不同的实现。
对象的多态性【抽象类和接口才能体会到实际⽤用处】（前提：方法覆写）：
【自动，90%】①对象的向上转型：父类 父类对象 = 子类实例。
【强制， 1%】②对象的向下转型：子类 子类对象 =（子类）父类实例。

• overload：重载：函数名相同 参数列表不同 返回值不要求
• override: 重写：函数名相同 参数列表相同 返回值相同