oop面向对象

花笑白

已于 2022-03-08 01:08:49 修改

阅读量113

点赞数

文章标签： java 语音识别

于 2021-08-18 16:15:20 首次发布

本文链接：https://blog.csdn.net/weixin_44279647/article/details/119778189

版权

简述final、finally、finalize的区别

GC是什么？为什么要有GC？垃圾回收机制有哪些？垃圾回收相关参数有哪些？

什么是对象

类中的静态变量和实例变量的区别？

类中的静态变量是类变量，该类对象都能对它操作，其他对象修改了，后面的对象就操作修改后的值，实例变量只能是本对象操作

类加载的过程

分为三大阶段

加载：查找并加载类的二进制信息

链接：

   验证：确保被加载类的正确性

   准备：为类的静态变量分配内存，并将其初始化为默认值

   解析：把类中的符号引用转换为直接引用

初始化：执行构造方法

卸载

对象加载的过程

1.检测类加载信息（去常量池中检查这个类的符号应用是否存在）

2.为新类分配地址（在堆内存中为新对象分配一块内存空间）

3.为新对象值初始化为零值（对对象的成员变量默认初始化,显示初始化）

4.设置对象头（线程持有的锁，锁的状态标志，GC分代年龄，类型指针）

5.执行init方法（init方法执行完，就执行构造函数）

两者的区别

类加载主要是对类变量进行初始化，对象创建阶段则是为了对对象进行初始化操作，对象创建前就要进行类加载

创建对象的方式？

1.new一个对象

2.利用反射创建对象

3.利用反序列化创建对象

4.使用clone方法

面向对象的三大特征：封装，继承，多态

封装：封装的主要作用就是提高重用性，还有提高安全性，不管具体的实现过程。只要可以体现重用性，简化代码的都可以成为封装，我们搬用private修饰符修饰，其实public也可以封装代码。

继承：子类用关键字extends，继承父类的属性和方法，但是无法继承私有内容。

多态：多态是同一行为具有不同表现形式或形态的能力，增强了软件的灵活性和重用性。

封装：一般我们用private修饰成员变量，进行封装，用get（），set（）方法供外部修改调用。

public class Teacher {
    public static void main(String[] args) {
        Student student1 = new Student();
        student1.setName("张三");
        student1.setSex("男");
        student1.setAge(18);
        System.out.println(student1.toString());
    }
}
class Student{
    private String name;
    private String sex;
    private Integer age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                '}';
    }
}

多态：分为向上转型和向下转型

向上转型中只能调用父类中有的方法，子类若重写了就实现子类中重写的方法，

向下转型的目的是向方法中入一个父类参数，有多个子类重写父类方法，需要调用特定子类方法，就要将父类参数先转成子类对象

package cn.tedu;

public class ShopAnimalfood {
    public static void main(String[] args) {
        String animal="dog";
        if (animal.equals("dog")){
            Animal animal1=new Dog();
            Dog dog = (Dog) animal1;//向下转型
            dog.eat();
            dog.run();
        }
        animal = "cat";
        if (animal.equals("cat")){
            Animal animal1=new Cat();//向上转型
            animal1.eat();
            animal1.as();
        }
    }
}
class Animal{
    void eat(){
        System.out.println("什么都吃");
    } ;
   void as(){
       System.out.println("1");
  }
}
 class Dog extends Animal{

     void run(){     
         System.out.println("跑得快");
     }
    @Override
    void eat() {
        System.out.println("吃骨头");
    }


 }
 class Cat extends Animal{
     void jump(){
         System.out.println("跳的高");
     }
    @Override
    void eat() {
        System.out.println("吃鱼");
    }
}

抽象类和接口的区别

1.抽象类中可以有成员变量，接口中的变量只能被public static final修饰，显示常量

2.抽象类中可以有普通方法，接口中只有抽象方法，抽象方法不能被static和final修饰

3.抽象类中的方法访问符可以是public，protected，和默认的，接口中只能是public类型并且默认为public abstract

4.抽象类只能单继承，一个接口可以继承多个接口

5.抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类

6.抽象类有构造方法，不能被实例化，接口没有构造方法，也不能实例化

重载和重写

重载（Overload）：同类内部，同名不同参（参数类型不同，顺序不同，个数不同）

重写（Override）：父子类之间，同名且同参，遵循2小1大原则

1) 子类声明抛出的异常必须小于等于父类

2) 子类返回类型必须小于等于父类

3) 子类的访问控制修饰符必须大于等于父类

构造器

this与super的区别

   This代表本类对象的引用
   class Cat{ this.XXX } 可以理解成: Cat this = new Cat();
   super代表父类对象的引用
   class Father{ }
    class Son extends Father{ super.XXX }
    可以理解成: Father super = new Father();
    this可以在两个变量名相同时,用于区分成员变量和局部变量
    this 可以在本类的构造方法之间调用,位置必须是第一条语句,注意,不能相互调用,会死循环
    super是建立了继承关系以后,子类如果想用父类的功能,可以通过super调用
    如果重写后还想用父类的功能,需要使用super来调用
    super在调用父类构造方法时,必须出现在子类构造方法的第一条语句,而且如果父类中没有提供无参构造,子类可以通过super来调用父类其他的含参构造

简述final、finally、finalize的区别

final：java中的关键字，修饰符

1 .如果一个类被声明为final，就意味着它不能再派生出新的子类，不能作为父类被继承。因此，一个类不能同时被声明为absrtact抽象类的和final的类。

2. 如果将变量或者方法声明为final，可以保证它们在使用中不被改变。

2.1 被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。

2.2被声明final的方法只能使用，不能重写。

finally：java的一种异常处理机制finally是对Java 异常处理模型的最佳补充。finally 结构使代码总会执行，而不管有无异常发生。使用 finally 可以维护对象的内部状态，并可以清理非内存资源。特别是在关闭数据库连接这方面，如果程序员把数据库连接的close()方法放到finally中，就会大大降低程序出错的几率。

1、当 try 代码块和 catch 代码块中有 return 语句时，finally 仍然会被执行。

2、执行 try 代码块或 catch 代码块中的 return 语句之前，都会先执行 finally 语句。

3、无论在 finally 代码块中是否修改返回值，返回值都不会改变，仍然是执行 finally 代码块之前的值。finally 代码块中的 return 语句一定会执行。

4、当 finally 有返回值时，会直接返回该值，不会去返回 try 代码块或者 catch 代码块中的返回值。注意：finally 代码块中最好不要包含 return 语句，否则程序会提前退出。

finalize：Java中的一个方法名Java使用finalize()方法在垃圾收集器将对象从内存中清除出去前，做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在Object类中定义的，因此所有的类都继承了它。子类覆盖finalize()方法以整理系统资源或者执行其他清理工作。finalize()方法是在垃圾收集器删除对象之前对这个对象调用的

Java的内存空间

GC是什么？为什么要有GC？垃圾回收机制有哪些？垃圾回收相关参数有哪些？

GC是垃圾收集的意思，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，简化了开发。垃圾回收机制有很多种，包括：分代复制垃圾回收、标记垃圾回收、增量垃圾回收等方式

与垃圾回收相关的JVM参数：
-Xms / -Xmx — 堆的初始大小 / 堆的最大大小
-Xmn — 堆中年轻代的大小
-XX:-DisableExplicitGC — 让System.gc()不产生任何作用
-XX:+PrintGCDetails — 打印GC的细节
-XX:+PrintGCDateStamps — 打印GC操作的时间戳
-XX:NewSize / XX:MaxNewSize — 设置新生代大小/新生代最大大小
-XX:NewRatio — 可以设置老生代和新生代的比例
-XX:PrintTenuringDistribution — 设置每次新生代GC后输出幸存者乐园中对象年龄的分布
-XX:InitialTenuringThreshold / -XX:MaxTenuringThreshold：设置老年代阀值的初始值和最
大值
-XX:TargetSurvivorRatio：设置幸存区的目标使用率

花笑白

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
oop面向对象

什么是对象面向对象的三大特征：封装，继承，多态封装：封装的主要作用就是提高重用性，还有提高安全性，不管具体的实现过程。只要可以体现重用性，简化代码的都可以成为封装，我们搬用private修饰符修饰，其实public也可以封装代码。继承：子类用关键字extends，继承父类的属性和方法，但是无法继承私有内容。多态：多态是同一行为具有不同表现形式或形态的能力，增强了软件的灵活性和重用性。封装：一般我们用private修饰成员变量，进行封装，用get（），set（）方法供外部修改调用。p
复制链接

扫一扫