夺命连环问——Java基础篇之面向对象

夺命连环问——Java基础篇之面向对象

Java的三大特性是什么？

答：
	面向对象编程、平台无关性、安全性。

1. 面向对象编程(Object-Oriented Programming,OOP)：Java是一种纯面向对象的编程语言，它支持封装、继承和多态等面向对象的特性。通过封装，Java可以将数据和方法封装在一起，形成一个类，从而实现对数据的保护；通过继承，Java可以从已有的类中继承属性和方法，避免重复编写代码；通过多态，Java可以让不同的对象对同一个消息做出不同的响应，提高了代码的复用性和灵活性。
2. 平台无关性(Platform Independence)：Java程序可以在不同的操作系统上运行，这是因为Java编译器将Java源代码编译成字节码(bytecode),然后由Java虚拟机(JVM)将字节码解释执行。因此，无论在哪个平台上安装了Java虚拟机，都可以运行Java程序。这种平台无关性使得Java成为一种非常适合开发跨平台应用程序的语言。
3. 安全性(Security)：Java提供了多种安全机制来保护应用程序的安全，包括沙箱安全模型、类加载器、安全管理器等。这些机制可以限制应用程序的访问权限，防止恶意代码的执行，保证了应用程序的安全性和稳定性。同时，Java还提供了加密和数字签名等标准安全协议，使得Java应用程序可以方便地与其他系统进行安全通信。

Java和C++有什么区别？

答：
	首先在内存管理上，Java的JVM内置垃圾回收机制，而C++没有内置的垃圾回收机制，需要程序员手动管理内存，会增加内存泄漏和指针错误的风险，但是可以提供更好的内存控制。
	其次，Java具有平台无关性，可以在不同机器上运行，无需重新编译，而C++是平台相关的，在不同平台上运行C++程序需要重新编译。
	Java支持单继承，但可以通过实现多个接口来实现多继承的效果，而C++支持多继承，这提供了强大的继承能力，但可能导致一些复杂性问题（比如钻石问题）。
	最后Java程序在运行时有JVM解释执行，可能导致运行速度慢，而C++在本地机器编译，直接在硬件上运行，运行速度更快。
	
	
Java： 
优点：
平台无关，可跨平台运行。
自动内存管理，减少内存泄漏和指针错误。
更安全的类型检查和异常处理机制。
丰富的标准库，方便编写各种应用程序。
广泛应用于Web开发、企业级应用和Android开发。

缺点：
运行速度可能略慢于C++，因为需要JVM解释执行。
对底层硬件和系统的控制能力较弱。
	
C++： 
优点：
运行速度快，编译为本地机器代码。
提供底层内存控制和系统访问能力。
支持多继承，提供更强大的继承能力。

重载和重写的区别★★★

答：
	定义方式上：重载是在同一个类中可以有多个方法名相同但参数列表不同的方法。重写是在子类中必须定义与父类同名、参数类型和返回值类型相同的方法。
	
	访问权限上：重载方法名相同但参数列表不同，因此访问权限是一样的，都是public、protected或private。重写子类中的方法必须使用super关键字来调用父类的方法，这意味着子类中的方法具有比父类中相同的方法更低的访问权限。

请说明一下Super关键字的作用？

在Java类中使用super来调用父类中的指定操作

• super可以用来访问父类中定义的属性

• super可以用于调用父类中定义的成员方法

• super可以同于子类构造器中调用父类的构造器

super关键字和this关键字的作用？

static关键字的作用？

在Java中，static关键字有以下几种作用：

1.修饰类成员变量和方法：

• 修饰类成员变量：被static修饰的成员变量是静态变量，它们属于类而不是对象。静态变量可以在类的任何地方访问，且只有一份实例。例如：public static int count = 0;。
• 修饰类成员方法：被static修饰的方法是静态方法，它们不依赖于对象而是直接通过类名调用。静态方法可以在类的任何地方调用，且没有this指针。例如：public static void printCount() { System.out.println(count); }。

2.修饰局部变量：

• 被static修饰的局部变量成为静态局部变量，它们属于类而不是对象。静态局部变量只能在类的静态方法中初始化一次。例如：public static void test() { static int count = 0; count++; System.out.println(“count=” + count); }。

3.表示类和接口的常量：

• 被static修饰的常量是类和接口的常量，它们在整个程序中都是可见的。例如：public static final int MAX_COUNT = 100;。

• 被static修饰的方法可以保证多线程访问时的安全性。例如：public static synchronized void printCount() { System.out.println(count); }。

Java 中的 final 关键字有哪些用法，它和 finally 有什么区别?

• final 关键字用于修饰类、方法、变量和参数，用于表示不可改变或不可继承。
• finally 关键字用于异常处理，用于定义一个代码块，在异常处理后必定执行。

注：在异常处理后必定执行，但是在异常处理前和finally代码块里加上System.exit(0)也会执行。

什么时候用public、private、protected？

答：
	1、想要让一个成员变量或方法被其他包中的类访问用public。
	2、想要限定范围只在本类中访问用private，在同一包中和子类中可以访问用protected。

• public修饰符提供最大的访问权限，可以被任何类访问。
• private修饰符提供最小的访问权限，只能在同一个类内部访问。
• protected修饰符提供包内和子类的访问权限。
• 默认修饰符提供包内的访问权限。

关于四种权限修饰符的说明：

成员变量和局部变量的区别？

Java能实现多继承么

Java不支持多继承，它只支持单继承。这意味着一个类只能继承自一个直接父类，而不能同时继承多个父类。

在Java中，一个类可以实现多个接口。

抽象类与接口有什么区别？

答：
	抽象类里面可以有构造方法和普通成员变量，接口中不能有构造方法、普通成员变量。
	由于Java中不支持多继承，一个类只能继承一个抽象类，但可以实现多个接口。

接口是否可继承接口? 抽象类是否可实现接口? 抽象类是否可继承具体类?

接口是可以继承其他接口的，而抽象类既可以实现接口，也可以继承具体类

面向对象的特征有哪些方面?

封装将数据和方法封装在一起，形成一个类（Class）

继承类可以继承另一个类的属性和方法

多态同一个方法在不同的对象上可以有不同的行为

抽象从具体的事物中提取出共同的特征和行为

能详细解释一下封装么？

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问 成员变量private，提供对应的getXxx()/setXxx()方法

程序涉及追求——>高内聚，低耦合

高内聚：类的内部数组操作细节自己完成，不允许外部干涉。

低耦合：仅对外暴露少量的方法用于使用。

继承你了解哪些？

Java中继承是一种面向对象编程的基本概念，它允许一个类(子类)从另一个类(父类)中继承属性和方法。以下是Java中继承的一些基本知识：

1. 继承的语法：在Java中，使用extends关键字来声明一个类继承另一个类。例如：

class Animal {
  // 父类中的属性和方法
}

class Dog extends Animal {
  // 子类中的额外属性和方法
}

2. 子类可以重写父类的方法：子类可以覆盖(override)父类中定义的方法，以实现自己的行为。例如：

class Animal {
  public void eat() {
    System.out.println("Animal is eating");
  }
}

class Dog extends Animal {
  @Override
  public void eat() {
    System.out.println("Dog is eating");
  }
}

public class Main {
  public static void main(String[] args) {
    Dog dog = new Dog();
    dog.eat(); //输出 "Dog is eating"
  }
}

3. 子类可以访问父类中的公有、受保护和默认(package-private)成员：子类可以访问其继承的父类中的公有、受保护和默认(package-private)成员。例如：

class Animal {
  public int age;
}

class Dog extends Animal {
  public void bark() {
    System.out.println("Woof! My age is " + age);
  }
}

public class Main {
  public static void main(String[] args) {
    Dog dog = new Dog();
    dog.age = 3; //可以修改子类的属性age,但不能修改父类的属性age
    dog.bark(); //输出 "Woof! My age is 3"
  }
}

多态你了解哪些？

多态是同一个行为具有多个不同表现形式或形态的能力。

多态一般分为两种：重写式多态和重载式多态。

重载式多态，也叫编译时多态。也就是说这种多态再编译时已经确定好了。重载大家都知道，方法名相同而参数列表不同的一组方法就是重载。在调用这种重载的方法时，通过传入不同的参数最后得到不同的结果。

但是这里是有歧义的，有的人觉得不应该把重载也算作多态。因为很多人对多态的理解是：程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，这种情况叫做多态。 这个定义中描述的就是我们的第二种多态—重写式多态。

重写式多态，也叫运行时多态。这种多态通过动态绑定（dynamic binding）技术来实现，是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。也就是说，只有程序运行起来，你才知道调用的是哪个子类的方法。 这种多态通过函数的重写以及向上转型来实现，我们上面代码中的例子就是一个完整的重写式多态。我们接下来讲的所有多态都是重写式多态，因为它才是面向对象编程中真正的多态。

总而言之我的理解：重载式多态，在编码等过程中，并没有很好的体现出多态的优势，但是不得否认也是多态的一种编写方式，而给出的重写式多态案例中，相比于重载式多态，在编码思路和代码量以及聚合度方面都较好的体现出了多态的优势。

多态的优点

• 消除类型之间的耦合关系
• 可替换性
• 可扩充性
• 接口性
• 灵活性
• 简化性

多态存在的三个必要条件

• 继承
• 重写
• 父类引用指向子类对象

public class Test {
    public static void main(String[] args) {
        show(new Cat());  // 以 Cat 对象调用 show 方法
        show(new Dog());  // 以 Dog 对象调用 show 方法
        /**
         * 上面两行可以发现，show方法要求传入的是动物对象，因为猫和狗都继承了动物类，因此符合规范，
         *         同时体现出多态的优势：一个形参可以对应多个实参，同时这也是一个重写式多态
         */


        Animal a = new Cat();  // 向上转型：通过子类实例化父类
        a.eat();               // 调用的是 Cat 的 eat
        //a.work();如果运行这一行就会发现，无法调用work方法，因为动物类只有eat一个方法，从而cat失去了特有方法

        Cat c = (Cat)a;        // 向下转型：通过父类强制转化为子类
        c.work();        // 调用的是 Cat 的 work
        /**
         * 上面两行体现了向下转型的用处，我们可以知道，对象a目前是一个动物对象，不能执行猫或者狗的特有方法
         * 但是，如果通过向下转型，将动物a对象，转化为一个猫c对象，这样就可以调用猫的特有方法了
         */


        /**
         * 得出结论：
         * 向上转型 : 通过子类对象(小范围)实例化父类对象(大范围),这种属于自动转换
         * 向下转型 : 通过父类对象(大范围)实例化子类对象(小范围),这种属于强制转换
         */

    }

    public static void show(Animal a)  {
        a.eat();
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情
            Cat c = (Cat)a;
            c.work();
        } else if (a instanceof Dog) { // 狗做的事情
            Dog c = (Dog)a;
            c.work();
        }
    }
}

//定义一个抽象类
abstract class Animal {
    abstract void eat();
}

//下面的每一个类继承抽象类，重写接口中的方法
class Cat extends Animal {
    public void eat() {
        System.out.println("吃鱼");
    }
    public void work() {
        System.out.println("抓老鼠");
    }
}

class Dog extends Animal {
    public void eat() {
        System.out.println("吃骨头");
    }
    public void work() {
        System.out.println("看家");
    }
}