자바의 세 가지 주요 기능은 무엇입니까?

Java의 세 가지 주요 특징: 1. 객체의 속성과 구현 세부 정보를 숨기고 외부 세계에만 공개 액세스를 제공하는 것을 의미하는 캡슐화 2. 상속, 기존 클래스에서 새 클래스 파생, 새 클래스가 흡수 가능 기존 클래스 데이터 속성과 동작을 가지며 새로운 기능을 확장할 수 있습니다. 3. 다형성, 메서드는 여러 구현 버전, 즉 "하나의 정의, 여러 구현"을 가질 수 있습니다.

관련 추천: "Java 동영상 튜토리얼"

Java의 세 가지 주요 특징은 Java의 고유한 성능이라고 생각됩니다. 캡슐화, 상속 및 다형성이 바로 Java의 가장 중요한 기능입니다.

캡슐화:

캡슐화: 객체의 속성과 구현 세부정보를 숨기고 외부 세계에 대한 공개 액세스만 제공하는 것을 말합니다.

이점:

• 변경 사항을 격리합니다.

• 사용하기 쉽습니다.

• 재사용성을 향상하세요.

• 보안을 강화하세요.

• 캡슐화 원칙:

• 외부에 제공할 필요가 없는 콘텐츠를 숨깁니다.

• 모든 속성을 숨기고 해당 속성에 액세스할 수 있는 공개 방법을 제공하세요.

비공개 키워드:

• 은 권한 수정자입니다.

• 멤버 수정에 사용됩니다(멤버 변수 및 멤버 함수)

• Private 멤버는 이 클래스에서만 유효합니다.

일반적으로 사용되는 방법 중 하나:

개인 멤버 변수를 제공하고 해당 set 및 get 메소드를 제공하여 외부에서 액세스할 수 있습니다. 데이터에 대한 액세스 보안이 향상되었습니다.

예:

우리가 자주 부르는 혈액 손실 모델

public class Demo {

        private String name;
        private String sex ;
        private int 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 int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }


}

구성 코드 블록 및 구성 방법(구성):

구성 방법:

은 개체를 초기화하는 데 사용됩니다. 해당 객체를 초기화하는 기능이며 그 중 하나입니다.

특징:

• 함수 이름은 클래스 이름과 동일합니다.
• 반환 값 유형을 정의할 필요가 없습니다.
• 이 함수에는 특정 반환 값이 없습니다.
• 생성자는 우리가 수동으로 호출하지 않지만(수동 호출은 b1.baby(); 등 참조) 해당 객체가 생성되면 JVM이 해당 생성자를 적극적으로 호출합니다.
• 클래스가 생성자를 명시적으로 작성하지 않으면 Java 컴파일러는 매개변수가 없는 생성자를 클래스에 추가합니다.
• 클래스가 생성자를 명시적으로 작성한 경우 Java 컴파일러는 매개변수가 없는 생성자를 클래스에 추가하지 않습니다.
• 함수 오버로딩의 형태로 클래스에 여러 생성자가 존재할 수 있습니다.
• 구성 방법에는 매개변수 없는 구성 방법과 매개변수화된 구성 방법이 있습니다. JVM은 기본적으로 매개변수가 없는 생성자를 생성합니다. 매개변수가 있는 생성자를 수동으로 생성하면 시스템은 기본적으로 매개변수가 있는 생성자를 인식합니다.

构造函数的定义格式： 
   修饰符 函数名(形式参数){
           函数体;
 }
　　修饰符 函数名(){
           函数体;}

생성자 메소드와 일반 메소드의 차이점:

(1) 반환값 유형의 차이점:

① 생성자는 반환값 유형이 없습니다. will 일반 함수가 되려면 수동으로 호출해야 합니다.

② 일반 함수에는 반환값 형식이 있습니다. 함수가 값을 반환하지 않더라도 반환값 형식은 void로 작성해야 합니다.

(2) 함수 이름의 차이점

① 생성자의 함수 이름은 클래스 이름과 일치해야 합니다.

②일반 함수의 함수 이름은 식별자의 명명 규칙만 따르면 됩니다.

(3) 호출 방식의 차이:

① 생성자는 객체 생성 시 JVM에 의해 호출된다.

②일반 함수는 객체를 사용하여 호출됩니다. 객체는 일반 함수를 여러 번 호출할 수 있습니다.

(4) 기능의 차이점:

①생성자의 기능은 객체를 초기화하는 것입니다. 생성된 모든 객체에는 초기 값이 있습니다.

②일반 함수는 사물 클래스의 공개 동작을 설명하는 데 사용됩니다.

참고:

(1) Java 컴파일러에서 추가한 매개변수 없는 생성자의 권한 한정자는 클래스의 권한 한정자와 일치합니다.

(2) 객체 생성 시 생성자가 호출되므로 속성값을 생성자에게 전달하고, 생성자에 매개변수를 설정하여 속성값을 받을 수 있습니다.

（3）JVM和Java编译器是不同的，Java编译器编译生成的.class文件是给JVM看的，所以经过编译后的class类打开后会是乱码，我们可以通过反编译来查看。

构造代码块：

1.构造代码块的作用与构造函数的作用的对比：

（1）构造代码块的作用：给所有对象进行统一的初始化，对象一建立就运行并且优先于构造函数，比如所有的婴儿出生都会哭。

（2）构造函数的作用：给对应的对象（new ）进行初始化。

构造代码块的格式：

{

构造代码块;

}
注意：构造代码块的大括号必须位于成员的位置上。

代码块的类别：

（1）构造代码块：在工作中经常会用到。

（2）局部代码块：大括号位于方法之内，基本上写不写没什么区别，现实开发中也很少会用到。它的作用是缩短局部变量的生命周期，节省一点点内存。

（3）静态代码块：使用static修饰的代码块。

注意的事项：

（1）Java编译器在编译一个Java源文件的时候，会把成员变量的声明语句提前至一个类的最前端。

（2）成员变量的初始化工作其实都是在构造函数中执行的。

（3）一旦经过Java编译器编译后，那么构造代码块的代码就会被移动到构造函数中执行，构造代码块的代码是在构造函数之前执行的，构造函数中的代码是最后执行的。

（4）成员变量的显示初始化与构造代码块的代码是按照当前代码的顺序执行的。　

继承(inheritance)：

继承是面向对象最显著的一个特性。 继承是从已有的类中派生出新的类， 新的类能吸收已有类的数据属性和行为，并能扩展新的能力。
在JAVA中， 被继承的类叫父类(parent class)或超类(superclass)， 继承父类的类叫子类(subclass)或派生类(derivedclass)。 因此， 子类是父类的一个专门用途的版本， 它继承了父类中定义的所有实例变量和方法， 并且增加了独特的元素 。

继承的结构：

继承的使用 ：

关键字：extends。

使用继承
– 编写父类
– 编写子类， 继承父类
class Animal {
//公共的属性和方法
}
class Chicken extends Animal{
//子类特有的属性和方法
}
 class Duck extends Animal {
}

基本语法：

class Chicken extends Animal{ }

 上述代码表示Chicken类继承Animal类，使用extends关键词将Animal类（父类/超类）和Chicken类（子类）连接接起来；
在继承关系下，Chicken类将拥有Animal类所有的非私有的方法和属性，Chicken类还可以拥有自己独有的方法和属性；
声明Animal类，实例化Chicken类时， Chicken类会自动向上转型为Animal类；

举个栗子：

//创建动物类

public class Animal {
private String type;
private String skin;
private int legCount;
public void eat(){
System.out.println("动物正在吃东西");
}
public void breath(){
System.out.println("动物正在呼吸");
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getSkin() {
return skin;
}
public void setSkin(String skin) {
this.skin = skin;
}
public int getLegCount() {
return legCount;
}
public void setLegCount(int legCount) {
this.legCount = legCount;
}
}

//鸡类
public class Chicken extends Animal {
public void eat(){
System.out.println(“鸡正在吃东西”);
}
public void run(){
System.out.println(“鸡在跑");
}
}

//鸭类
public class Duck extends Animal {
public void eat(){
System.out.println(“鸭正在吃东西”);
}
 public void run(){
System.out.println(“鸭在跑");
}
}

//测试类

public class Test {
public static void main(String[] args){
Chicken chicken=new Chicken ();
chicken.eat();
chicken.setType(“鸡”);
chicken.setSkin(“金色");
chicken.setLegCount(2);
System.out.println("动物品种是： "+chicken.getType()+"， 肤色是： "+chicken.getSkin()+"， 腿数"+t.getLegCount());
chicken.run();
Duck duck =new Duck ();
duck.eat();
duck.fight();
}
}

继承执行的顺序：

java中， new一个类的对象， 类里面的静态代码块、 非静态代码块、无参构造方法、 有参构造方法、 类的一般方法等部分， 它们的执行顺序相对比较简单， 例如： 

public class FatherTest{
private String name;
public FatherTest(){
System.out.println(“--父类的无参数构造方法--”);
}
public FatherTest(String name){
System.out.println(“--父类的有参数构造方法--”+this.name);
}
static{
System.out.println(“--父类的静态代码块--”);
}
{
System.out.println(“--父类的非静态代码块--”);
}
public void speak(){
System.out.println(“--父类的方法--”);
}
}

public static void main(String[] args){
System.out.println(“--父类主程序--”);
FatherTest father = new FatherTest(“父亲的名字”);
father.speak();
}

执行结果为：
--父类的静态代码块--
--父类主程序--
--父类的非静态代码块--
--父类的有参构造函数--父亲的名字
--父类的方法--

执行顺序总结：
  静态代码块—>主程序—>非静态代码块—>构造函数—>一般方法

加入子类继承后的执行顺序， 例如 ：

public class SonTest extends FatherTest{
private String name;
static{
System.out.println("--子类的静态代码块--"); }
{
 System.out.println("--子类的非静态代码块--");
 }
public SonTest(){
System.out.println("--子类的无参构造方法--");
 }
public SonTest(String name){
System.out.println("--子类的有参构造方法--"+name);
 }
@Override
public void speak() { System.out.println("--子类重写了父类的方法--"); }
}


public static void main(String[] args) {
System.out.println("--子类主程序--");
FatherTest father=new FatherTest("父亲的名字");
father.speak();
SonTest son=new SonTest("儿子的名字");
son.speak();
}

执行结果为：
--父类的静态代码块--
--子类的静态代码块--
--子类主程序--
--父类的非静态代码块--
--父类的有参构造函数--父亲的名字
--父类的方法--
--父类的非静态代码块--
--父类的无参构造函数--
--子类的非静态代码块--
--子类的有参构造方法--儿子的名字
--子类重写了父类的方法--

方法的重写：

方法重写是在继承关系下， 子类拥有与父类方法名、 参数(个数、顺序、 类型)、 返回值类型完全相同， 访问修饰符只能扩大或相等， 不可缩小， 但实现过程与父类不同的方法。 方法重写也是多态的一种变现形式。 

重写必须满足以下几个条件：
在子类中可以根据需要对从基类中继承来的方法进行重写；
重写的方法和被重写的方法必须具有相同方法名称、 参数列表和返回类型； 
重写方法不能使用比被重写的方法更严格的访问权限 ；

举个栗子：

//鸡类
class Chicken extends Animal {
public void eat(){
System.out.println(“鸡正在吃东西”);//对父类Animal中的eat方法进
行重写
}
 public void run(){
System.out.println(“鸡在跑");//可以添加新的方法
}
}

Super关键字：

super关键字是一个特殊的变量， 它提供了对父类的方法。 可以用super主动调用父类的构造方法、 访问父类中的成员。 

 super调用父类的构造方法： 

public class Duck extends Animal {
public Duck(String name){
super(name);//主动调用父类的构造方法
}
}

super访问父类的成员： 

在子类方法中使用super访问父类中隐藏的成员， 访问形式是：
super.变量；
super.方法名(参数); 

public class Duck extends Animal {
@Override
public void eat() {
System.out.println();
}
public void quack(){
System.out.println(super.name);//使用super调用父类的属性
eat();
super.eat();//使用super调用父类的eat()方法
}
public static void main(String[] args) {
new Duck().quack();//创建Duck类对象并调用quack方法
}
}

final 关键字：

“final”关键字用来修饰类、 方法和变量， 其含义“不可改变的、 最终的”。 

修饰类 声明为final的类不能派生子类，即此类不能被继承；
public final class Person{ }
修饰变量 表示它为一个常量，变量一旦初始化，将不能改变；
final int COUNT = 5;
修饰方法 表示向编译器表明子类不能重写此方法；
public final void eat(){ }

多态(polymorphism) 

在面向对象语言中， 多态性是指一个方法可以有多种实现版本，即“一种定义， 多种实现”。 利用多态可以设计和实现可扩展的系统， 只要新类也在继承层次中。 新的类对程序的通用部分只需进行很少的修改， 或不做修改。 类的多态性表现为方法的多态性，方法的多态性主要有方法的重载和方法的覆盖。

重载：

 方法重载(overload)是指在同一个类中的多个方法可以同名但参数列表必须不同。 重载表现为同一个类中方法的多态性。

class Chicken {
public void eat(){
System.out.println(“鸡正在吃东西”);
}
public void eat(String food){
System.out.println(“鸡在吃"+food);//重载eat方法
}
}

 方法重写(override)是指子类冲定义了父类中同名的方法。 重写表现为父子与子类之间方法的多态性。

//鸡类
class Chicken extends Animal {
public void eat(){
System.out.println(“鸡正在吃东西”);//对父类Animal中的eat方法进
行重写
}
}

对象类型转换： 

基本类型的数据可以转换类型， 当转换类型较高时可以自动转换， 当转换类型较低时需要强制转换。 对象类型也允许转换， 这个转换只限于java类层次结构图上的一根枝干上， 即父类和子类之间。 枝干上离Object较近的为上， 相反较远的为下， 由此对象的类型转换分为“向上转型”和“向下转型”两种。

public class Duck extends Animal {
@Override
public void eat() {
System.out.println();
}
public void quack(){
System.out.println("嘎嘎嘎");
}
public static void main(String[] args) {
Animal a1 = new Animal();//实例化过程
Animal a2 = new Duck();//向上转型
a1.eat();
a2.eat();
//a2.quack();//去除注释会怎样？
}
}

向下转型：只能针对指向子类对象的基类对象引用进行 。

public class Duck extends Animal {
@Override
public void eat() {
System.out.println();
}
public void quack(){
System.out.println("嘎嘎嘎");
}
public static void main(String[] args) {
Animal a = new Duck();//向上转型
Duck b = (Duck) a;//向下转型
a.eat();
b.eat();
b.quack();
}
}

Instanceof 关键字 ：

instanceof关键字是用来判断其左边对象是否为其右边的实例， 返回boolean类型的数据 .

boolean result = Object instanceof class

同时， 也可以用来判断继承中的子类的实例是否为父类的实现。

.....
public static void main(String[] args) {
Animal a = new Duck();//向上转型
if(a instanceof Duck){
((Duck) a).quack();
}
}
.....

위 내용은 자바의 세 가지 주요 기능은 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!