第31节：Java基础-类与对象

深碍√TFBOYSˉ_ 2021-09-16 03:32 383阅读 0赞

![标题图][1240]

## 前言 ##

Java基础-类与对象，方法的重载，构造方法的重载，static关键字，main()方法，this关键字，包，访问权限，类的继承，继承性，方法的重写，super变量。

> **方法的重载：**成员方法的重载和构造方法的重载

## 方法的重载 ##

在一个类中可以有多个方法具有相同的名字，但是这些方法的参数个数不同，或参数类型不同，即为**方法的重载。**

class Demo{
     // one
     void dashu(String name){
      System.out.println(name);
     }
     // two
     void dashu(String name,String score){
      System.out.println(name+score);
     }
     // three
     void dashu(String name,String score,Int age){
      System.out.println(name+score+age);
     }
      public static void main(String[] args){
       Demo demo = new Demo();
       demo.dashu("dashucoding");
       demo.dashu("dashucoding","一百");
       demo.dashu("dashucoding","一百",10);
      }
    }

## 构造方法的重载 ##

class Person{
     String name;
     int age;
     float height;
     float weight;
     // 构造方法
     public Person(){
      age = 13;
      name="dashu"
     }
     public Person(String name){
      this.name = name;
     }
     // 构造方法的重载
     public Person(String name, int age){
      this.name = name;
      this.age = age;
     }
     void print(){
      System.out.println(name+age);
     }
    }
    class Test{
     public static void main(String[] args){
      Demo demo1,demo2,demo3;
      demo1 = new Demo();
      demo2 = new Demo("dashu");
      demo3 = new Demo("dashu",12);
      demo1.print();
      demo2.print();
      demo3.print();
     }
    }

## static关键字 ##

被`static`修饰的变量为**静态变量**  
被`static`修饰的方法为**静态方法**

静态变量属于类而不属于类的某个实例，可被直接类名调用，所以叫**类变量**  
静态方法属于类而不属于类的某个实例，可被直接类名调用，所以叫**类方法**

**非静态的成员变量和方法，必须通过实例化后通过对象名来调用**  
所以叫实例变量和实例方法

> 实例变量和实例方法通过实例调用，类变量和类方法同样也可以通过实例调用  
> 这点要注意

--------------------

## main()方法 ##

`main()`方法为静态的，在`java`虚拟机中执行`main()`方法时不需要创建`main()`方法所在类的实例就可调用，因为有`static`修饰。

## 例子 ##

class Demo{
     // 定义静态的成员变量
     static int x;
     int y;
     // 定义静态的成员方法，用来获取值
     public static int getX(){
      return x;
     }
     // 定义静态的成员方法，用来设置值
     public static void setX(int newX){
       x = newX;
      }
     public int getY(){
      return y;
     }
     public void setY(int newY){
      y = newY;
     }
    }

> 静态方法可以调用同类的静态成员，不能调用非静态成员，反之能；静态成员可通过类名调用，也可通过实例对象，静态方法中不能使用`this`和`super`。

## this关键字 ##

`this`代表使用该方法的当前的对象，只用于实例方法或者构造方法中。

void setAge(int age){
     this.age = age;
    } 
    Person(String name, int age){
     this.name = name;
     this.age = age; 
    }

--------------------

## 包 ##

在`java`中提供了不同的类和接口存放在不同的包中。  
常见的包

java.applet
    java.awt
    java.net
    java.util
    java.lang
    java.io

**包的格式：**

package 包名[.子包名[…]];

**引入java包**

import 包层次结构的类名;

## 访问权限 ##

**修饰符：**

public、private、protected、友好

> `private`变量和方法

访问权限最小，只能在同一个类中被访问，私有成员可以被对象实例调用，方法被对象实例调用，静态成员可以被类名直接调用。

`private`，类中的私有变量不能被另一个类所引用，私有变量和方法只能在本类中使用。

class Demo{
     private static String name;
     private int age;
     private void print(){
      System.out.println(name+age);
     }
     public static void main(String[] args){
     Demo.name = "dashu";
     Demo d = new Demo();
     d.age = 12;
     d.print();
     }
    }
    // 另一类
    class Da{
     public static void main(String[] args){
      // 非法使用
     Demo.name = "dashu";
     // 非法调用
     Demo d = new Demo();
     d.print();
     }
    }

> `public` 访问修饰符，它的访问权限在不同类，不同包的类中访问
> 
> `默认，友好`权限只能被同类或同包中的不同类引用
> 
> `protected`不能在不同包中的类所引用

<table> 
 <thead> 
  <tr> 
   <th>访问权限</th> 
   <th>public</th> 
   <th>protected</th> 
   <th>友好</th> 
   <th>private</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>同类</td> 
   <td>可以</td> 
   <td>可以</td> 
   <td>可以</td> 
   <td>可以</td> 
  </tr> 
  <tr> 
   <td>同包不同类</td> 
   <td>可以</td> 
   <td>可以</td> 
   <td>可以</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>不同包子类</td> 
   <td>可以</td> 
   <td>可以</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>通用</td> 
   <td>可以</td> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

--------------------

## 类的继承 ##

在`java`中可以单继承，不支持多继承，一个子类只能有一个父类，不能有多个，但一个父类可以有多个派生的子类。

public class Person{ 
         String name;
         int age;
         public void setAge(int age) {
        this.age=age;
         }
         public void out()   {
            System.out.println("姓名:"+name+" 年龄:"+age+"岁");      
         }
    }
    
    // 子类继承父类
    public class Student extends Person{ 
     ...
    }

#### 继承性 ####

子类继承父类，可以继承父类中非私有成员（子类和父类在同一包中），如果不在同一包中，子类只能继承父类中受保护的和公有的成员。

#### 方法的重写 ####

方法的重写，子类覆盖父类的方法，**定义了与父类相同名，相同类型，并且相同参数的方法。**

#### super变量 ####

`super`，提供了对父类的访问，**可以访问父类被子类的隐藏的变量和覆盖的方法。**

## 结语 ##

*  本文主要讲解 **Java基础-类与对象**
 *  下面我将继续对`Java`、 `Android`中的其他知识 深入讲解 ，有兴趣可以继续关注
 *  小礼物走一走 or 点赞

![送❤][1240 1]

[1240]: /images/20210724/69ddc5d23e46401d86c29f05eca5f670.png
[1240 1]: /images/20210724/bbfd4b782c1b40c5ae4e4656f10e8567.png