Java 객체지향 학습 소개-java지도 시간-php.cn

키워드: 객체지향, 클래스, 생성자, this, 정적, 내부 클래스

1. 객체지향 개념: 특정 규칙을 설치하여 해결해야 할 문제를 여러 개의 독립된 객체로 나누고 문제를 해결합니다. 객체의 메소드를 호출하여. 그 특징은 캡슐화, 상속, 다형성으로 요약할 수 있습니다.

1. 캡슐화: 객체의 핵심을 마주하고, 구체적인 구현 세부 사항을 외부에 알리지 않고 객체의 속성과 동작을 캡슐화하는 것이 캡슐화의 아이디어입니다.

2. 상속: 주로 클래스 간의 관계를 설명합니다. 상속을 통해 원래 클래스를 다시 작성하지 않고도 원래 클래스의 기능을 확장할 수 있습니다.

3. 다형성: 프로그램에서 이름의 중복이 허용됩니다. 이는 한 클래스에 정의된 속성과 메서드가 다른 클래스에 상속된 후 서로 다른 데이터 유형을 가지거나 다른 동작을 나타낼 수 있음을 의미합니다. 클래스마다 의미가 다릅니다.

2. 클래스 및 개체

1. 클래스는 개체 그룹의 공통 특성과 동작을 설명하는 데 사용됩니다. 멤버 변수와 멤버 메서드는 클래스에서 정의할 수 있습니다. 멤버 변수는 속성이라고도 하는 개체의 특성을 설명하는 데 사용되며, 멤버 메서드는 메서드라고 할 수 있는 개체의 동작을 설명하는 데 사용됩니다.

클래스 생성 방법:

1 class Person{
2      //定义int 类型的变量
3       int age;
4      //定义speak（）方法
5       void speak （）{
6             System.out.println(“***”)
7       }
8 } //Person 类名，age 是成员变量，speak（）成员方法

로그인 후 복사

2. 객체 생성 및 사용:

생성: 클래스 이름 객체 이름 = 새 클래스 이름() // 인스턴스 객체

사용: 객체 참조.

객체를 인스턴스화할 때 Java 가상 머신은 자동으로 멤버 변수를 초기화하고 다양한 유형의 멤버 변수에 서로 다른 초기 값을 할당합니다.

테이블: 멤버 변수의 초기값
Member 변수 클래스	초기값	Member 변수 클래스	초기값
바이트	0	double	0.0 ㄷ
짧다	0	char	null 문자, 'u0000'
int	0	boolean	false
long	0L	참조 데이터 유형	null
float	0.0F

在Java中，null是一种特殊的常量，当一个变量的值为null时，则表示该变量不指向任何一个对象，变成垃圾被回收。

3、所谓的类的封装是指定义一个类时，将类中的属性私有化，即利用private 关键字来修饰，私有属性只能在它所在类中被访问。为了能让外界访问私有属性，需要提供一些使用public 修饰的公用方法，其中包括用于获得属性值得getXXX（）方法和设置属性值得setXXX（）方法。

 1 class Student{
 2     private String name;    //将name属性私有化
 3     private int age;        //将age属性私有化
 4     //下面是公有的getXXX（）和setXXX（）方法
 5     public String getName (){
 6         return name;
 7     }
 8     public void setName(String stuName){
 9         name = stuName ;
10     }
11     public int getAge (){
12         return age ;
13     }
14     public void setAge(int stuAge){
15         //下面是对传入的参数进行检查
16         if(stuAge<=0){
17             System.out.println("年龄不合法");
18         }else {
19             age = stuAge ;        //对属性赋值
20         }
21     }
22     public void introduce(){
23         System.out.println("大家好，我叫"+name+",我今年"+age+"岁!");
24     }
25 }
26 public class Example01{
27     public static void main(String[] args){
28         Student stu  = new Student();
29         stu.setAge(-30);
30         stu.setName("李芳");
31         stu.introduce();
32     }
33 }

로그인 후 복사

三、构造方法

1、构造方法：构造方法是类中一个特殊成员，它会在实例化对象时被自动调用。

2、构造方法的特点：

①方法名与类名相同；

②在方法名前面没有返回值类型的声明；

③在方法中不能使用return语句返回一个值；

 1 class Person{
 2       //构造方法
 3      public Person(){
 4           //无参构造方法
 5       }
 6      public Person(int age){
 7           age = a;   //有参构造方法
 8      }
 9      public void speak(){
10           System.out.println(“I am” +age+”years old !");
11      }
12 }
13 public  class Example{
14      public  static void main (String [] args){
15          Person p = new Person(20);  //实例化Person对象
16          p.speak();
17      }
18 }

로그인 후 복사

3、构造方法的重载：与普通方法一样，方法名相同，只需要参数类型或参数个数不同即可。

一般情况下，构造方法通常会使用public来修饰。

四、this 关键字

1、this关键字三种常用方法：

①通过this关键字可以明确地访问一个类的成员变量，解决与局部变量名称冲突问题。

 1 class Person{
 2      int age ;
 3      public Person(int age){
 4           this.age = age ;   //访问成员变量
 5      }
 6      public int getAge(){
 7          return this .age;
 8     }
 9  }

로그인 후 복사

②通过this关键字调用成员方法。

③构造方法是在实例化对象时被Java虚拟机自动调用的，在程序中不能像调用其他方法一样去调用构造方法，但可以在一个构造方法中使用“this（【参数1，参数2……】）”的形式来调用其他的构造方法。

注意点：

①只能在构造方法中使用this 调用其他的构造方法，不能在成员方法中使用。

②在构造方法中，使用this 调用构造方法的语句必须位于第一行，且只能出现一次。

③不能在一个类的两个构造方法中使用this互相调用。

五、static关键字

1、使用static关键字来修饰成员变量，该变量被作静态变量。静态变量被所有实例共享，可以使用“类名.变量”的形式来访问。

注意：static关键字只能用于修饰成员变量，不能用于修饰局部变量。

2、静态方法：在类中定义的方法前加上static关键字，可在不创建对象的情况下调用某方法。可使用“类名.方法名”的形式访问。

注意：在一个静态方法中只能访问static修饰的成员，静态方法在被调用时可以创建任何对象。

3、静态代码块：用static关键字修饰的代码块称为静态代码块，当类被加载时，静态代码块会被执行，由于类只加载异常，因此静态代码块只能执行一次。

4、单例模式：

 1 class Single{
 2      private static Single INSTANCE = new Single();
 3      private Single(){}
 4      public static Single getInstance(){  
 5          return INSTANCE ; 
 6        }
 7 }
 8 //上面单例又可写成以下形式
 9 class Single{
10      private Single(){}
11      public static final Single INSTANCE = new Single()；
       /*变量名INSTANCE的前面有三个修饰符，其中，public的作用是允许外部直接访问该变量，static 的作用是 让外部可以使用
         “类名.变量名“的方式来访问变量，final的作用是禁止外部对该变量进行修改。*/
12 }
13 
14 class Example {
15     public static void main(String[] args){
16          Single s = Single.getInstance();    //   getInstance()方法是获得Single类实例对象的唯一途径，Single 类是一个单例的类    
17      }
18 }

로그인 후 복사

被关键字final修饰的变量为常量,其值不可变。

六、内部类：根据内部类的位置、修饰符和定义的方式可分为成员内部类、静态内部类、方法内部类。

1、创建内部类对象的具体语法格式：

外部类名.内部类名变量名 = new 外部类名（）.new 内部类（）；

 1 class Outer{
 2     private int num = 4;              //定义类的成员变量
 3     //下面的代码定义了一个成员方法，方法中访问内部类
 4     public void test(){
 5         Inner inner = new Inner();
 6         inner.show();
 7     }
 8     //下面的代码定义了一个成员内部类
 9     class Inner{
10         void show(){
11             //在成员内部类的方法中访问外部类的成员变量
12             System.out.println("num = "+num);
13         }
14     }
15 }
16 public class Example16 {
17     public static void main(String[] args){
18         Outer outer = new Outer();               //创建外部类对象
19         outer.test();                                 //调用test（）方法
20     }
21 }
22 //直接创建内部类对象示例
23 public class Example16 {
24     public static void main(String[] args){
25         Outer.Inner inner = new Outer().Inner() ;               //创建内部类对象
26         inner.show();                                 //调用show（）方法
27     }
28 }
29 //当内部类被声明为私有，外界将无法访问。

로그인 후 복사

2、创建静态内部类对象的具体语法格式：

外部类名.内部类名变量名 = new 外部类名.内部类名（）；

 1 class Outer{
 2     private static int num = 6;              //定义类的成员变量
 3     //下面的代码定义了一个静态内部类
 4     static class Inner{
 5         void show(){
 6             System.out.println("num = "+num);
 7         }
 8     }
 9 }
10 public class Example16 {
11     public static void main(String[] args){
12         Out.Inner inner = new Out.Inner();             //创建内部类对象
13             inner.show();                                 //调用内部类的方法
14     }
15 }

로그인 후 복사

注意：①在静态内部类中只能访问外部类的静态成员。

②在静态内部类中可以定义静态成员，而在非静态的内部类中不允许定义静态的成员。

3、方法内部类：是指在成员方法中定义的类，它只能在当前方法中被使用。方法内部类可以访问外部类的成员变量。

위 내용은 Java 객체지향 학습 소개의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!