语法基础（三. 类，属性，方法，方法重载，方法重写，构造方法，访问修饰符）

语法基础（三. 类，属性，方法，方法重载，方法重写，构造方法，访问修饰符）

（如有错误，欢迎指正，感谢！）

类

类是面向对象的程序设计中的概念，实现信息的封装

概念： 类就是拥有相等行为和相同的属性的对象的集合。(是一种比较抽象的数据类型，称为引用数据类型)
　　　　比如：人是一个类,具体到一个人,这个人就是一个对象,"名字,身高,体重"是这个对象的属性;"吃饭,吃东西"这些行为就是对象的方法。

语法规范:

[访问修饰符] class 类名{

}

类的三大特性：

1. 封装性
2. 继承性
3. 多态性

类比较抽象，是一个群体概念。

---

属性

• 类或者对象具有的特征在程序中称为属性
  
  

语法规范:

[修饰符] 属性类型 属性名称 [=默认值]

• 具体对象的属性数据称为属性值。
  
  
• 同一类的不同对象，都具有相同的属性，但各个对象都拥有各自的属性值。

类中的三种属性

1. 对象属性
2. 类（静态）属性
3. 局部属性

---

方法（函数）

• 类或者对象的行为称为方法
  

作用：

1. 用于定义功能。

2. 用于封装代码提高代码的复用性。

语法规范:

[访问修饰符] 返回值类型 方法名（参数列表）{
　　　方法体
}

类中的三种方法：

1. 对象方法
2. 静态方法
3. 构造方法

---

方法的重载

• 一个类中出现两个或两个以上同名方法，只要方法的参数，或者参数的类型不同，就可以说这个方法重载了（与返回值类型和访问修饰符无关）。

public class A{

   public void a(){
        System.out.println("================");
    }

     /*
    public int a(){
        System.out.println("");       // 方法冲突
    }

    private int a(){                 // 方法冲突
        System.out.printf("----");
    }
    */

    private void a(char ch){

    }

    public int a(int num){
        System.out.println("int num = "+num);
        return num;
    }

    public void a(String num){
        System.out.println("String num = "+num);
    }
}

• 构造方法，类方法，对象方法，final方法均可以被重载

---

方法的重写

• 一般用于子类中，如果想要重写父类的方法，实现不同的功能。
  
  

重写规则：

1. 重写的方法必须与被重写方法一模一样（包括返回值类型）。

2. 重写方法的访问修饰符，一定要大于等于被重写方法的访问修饰符

3. 重写方法抛出的异常必须和被重写方法抛出的异常一致，或者是其子类异常

4. 静态方法不能被重写，但是子类可以有同名的静态方法。

5. final方法不能覆盖重写，如果各个子类也去覆盖这个final方法，那父类的这个方法再用final修饰就没啥意义了

//父类
public class A {
    public void a(){
        System.out.println("父类A");
    }

    protected void b(){
        System.out.println("父类B");
    }

    public static void c(){
        System.out.println("父类静态方法C");
    }
}

//子类
public class B extends A {
    @Override
    public void a(){
        System.out.println("子类重写A");
    }

    /*
    @Override
    private void B(){       重写方法，访问修饰符不能变小

    }
    */

    @Override
    public void c(){
        System.out.println("子类重写B，访问修饰符由protected改为public");
    }

   /*
   @Override
    public static void c(){          父类静态方法不能被覆盖重写
        System.out.println("===");
    }
    */

    public static void c(){
        System.out.println("子类同名方法");
    }

}

---

构造方法

作用:

1. 构造出来一个类的实例（实例化对象）
   
   

2. 对构造出来个一个类的实例（对象）初始化。
   
   

语法规范:

[访问修饰符] 　类名（参数列表）{

}

规则:

• 方法名与类名相同
• 可以有 0 个、1 个或多个参数
• 没有任何返回值，包括 void
• 默认返回类型就是对象类型本身
• 只能与 new 运算符结合使用
• 构造方法不能被 static、final、abstract 等修饰。
  
  

注意:

• 构造方法的调用是在创建一个对象时，使用new操作自动进行的。
  
  

• 接口不允许被实例化，所以接口中没有构造方法。
  
  

• 类中必定有构造方法，若不写，系统自动添加无参的默认空构造方法
  
  

• 一旦手动定义了构造方法，默认的无参空构造方法就不再存在。
  
  
  
  

public class C {

    public static void main(String[] args) {
        C c=new C();    // 不报错，若不手动添加构造方法，系统自动添加无参的默认空构造方法
    }
}

public class C {
    public C(int num){
        System.out.println(num);
    }

    public C(String string){
        System.out.println("=========");
    }

    public static void main(String[] args) {
        // C c=new C();  报错，默认空构造方法不再存在
        C c=new C("有参构造");
    }
}

---

访问修饰符

• Java的四个关键字：public、protected、default、private
  （决定了修饰过的东西可以被谁使用）
  
  

访问权限	类	包	子类	其他包
public	∨	∨	∨	∨
protected	∨	∨	∨	×
default	∨	∨	×	×
private	∨	×	×	×

访问权限范围越小，安全性越高

• public： 都可以随意访问
  
  

• protected：包内可见,继承该类的子类（即使该类在其它包）实例（对象）可以访问，不然在其它包中相当于private权限
  即便是父类对象本身，在其它包也无法访问自己类中protected修饰的属性或方法
  
  

• default：在同一个包内均可被随意访问，其它包不可以
  
  

• private:　除啦可以在自己的类中随便访问，其它任何地方都不能访问

注意:

• 如果不添加访问类型，默认为default
  
  
  
  

包结构: domo01—A（父类） demo02—B（子类）

public class A {

    public void a(String string){
        System.out.println("public修饰的a方法");
    }

    protected  String  b(String string){
        System.out.println("protected修饰的b方法");
        return string;
    }

    void c(String string){
        System.out.println("默认default修饰的c方法");
    }

    private void d(String string){
        System.out.println("private修饰的d方法");
    }

}

import demo01.A;

public class B extends A{

    public static void main(String[] args) {
        A a=new A();

        B b=new B();

        b.a("public");

        b.b("protected");   //子类，父类不在同一个包，但是子类对象可以访问
  //    a.b("protected");      即便是父类对象本身，在其它包也无法访问自己类中protected修饰的属性或方法

  //    b.c("默认default");       其它包不能访问
   //   b.d("private");           其它包不能访问
    }

}

---

参考资料: https://www.cnblogs.com/yb38156/p/9599820.html
( 注：部分资料参考网络，如有侵权请联系。)