面向對象的封裝
package day7;
//面向對象的封裝
public class Employee {
    String name = "zhangsan";
    private int age;
    //多個方法重載
    public Employee(){
        
    }
    public Employee(String name,int age){
        
    }
    public Employee(int age,String name){
        
    }
    
    
    //可以在方法裏修改不能訪問的屬性
    public
 
 int getAge(){
        return age;
    }
    
    public void setAge(int age) {
        if(age>=1&&age<=120){
        this.age = age;
    }else{
        this.age =18;
    }
        
    }
    public void say(){
        System.out.println(name);
        System.out.println(age);
    }
    
}
 

package day7;

public class EmployeeTest {
    public static void main(String[] args) {
        Employee user = new Employee();
        //存在問題的賦值
//        user.age = 1000;
        //使用封裝進行屬性額隱藏,添加相關的get set方法
        //供外部程序調用
        user.setAge(50);
        System.out.println(user.getAge());
    }
}

結果圖;

面對對象繼承
package day7_1;

//繼承:只能單繼承!!!
//子類不能訪問父類private成員
//不能繼承:子類與父類不在同包,使用默認訪問權限的成員,
//子類不能訪問父類的構造函數
public class Engineer {
    int no;
    private String name;
    private String enterTime;

    public Engineer() {
        System.out.println("父類的構造函數");
    }

    public void showInfo() {
        System.out.println("展示信息");
    }
}

package day7_1;

public class SoftEngineer extends Engineer {

    private String type;
    
    
    public SoftEngineer() {
        System.out.println("子類的構造函數");
    }
    public void coding() {
        super.showInfo();
        System.out.println("我在寫bug!");
    }
    // 重寫:返回值類型, 方法名和參數列表都相同.
        //訪問修飾符不能比父類更嚴格
    @Override
    public void showInfo(){
        super.showInfo();
        System.out.println("我是軟件工程師");
    }
}

package day7_1;

//在子類裏可以通過super關鍵字調用父類裏公開的屬性或方法
public class TestEngineer extends Engineer {

    private String level;

    public TestEngineer() {
        System.out.println("子類的構造函數");
    }

    public void test() {

        System.out.println("我在Debug!");
    }
    
    public void showInfo() {
        System.out.println("我是測試工程師");
    }
    
    
    //重載
    public void showInfo(int i) {
        System.out.println("我是重載");
    }
}

 package day7_1;

public class Test {
    public static void main(String[] args) {
        SoftEngineer user1 = new SoftEngineer();
        user1.showInfo();
        TestEngineer user2 = new TestEngineer();
        user2.showInfo(3);
    }
}

結果圖:

abstract:限制實例化
package day7_4;
//abstract:限制實例化,讓這個類只能提供繼承,只能用於類和方法,不能給屬性
public abstract class Instrument {    
    //1:抽象類不能被實例化,只能起到被繼承的作用
    //2:抽象類裏的抽象方法必須被子類實現  除非子類也是抽象類
    //3:抽象方法必須放在抽象類裏面
    //4:抽象類裏不一定全是抽象方法
    //5:抽象方法沒有方法體
    String brand;
    String weight;
    public abstract void play();
    
    
    public void show(){
        
    }
}

package day7_4;
//final 最後的,無法讓這個類或方法或屬性被繼承
public  class Piano extends Instrument {
     final String size = "123";
    //重寫了父類裏面的play方法
    @Override
    public  void play(){
        System.out.println("我用彈的");
    }
    public final void  showCompany(){
        System.out.println("made in China");
    }
}

package day7_4;

public class Violin extends Instrument {
    int length;
    
public void play(){
    System.out.println("我是用拉的");
}
}

package day7_4;

public class Test {
    public static void main(String[] args) {
    
        Piano user1 = new Piano();
        user1.play();
        Violin user2 = new Violin();
        user2.play();
        
    }
}

結果圖:

Static:靜態方法
public class User {
    //成員屬性
    int age;
    int height;
    //類屬性
    static int weight = 60;
    //成員方法
    public void show(){
//        User.age; 成員屬性和方法不能直接由類來調用
        System.out.print(User.weight);
    }
    public static void showWeight(){
        System.out.println(User.weight);
        //在靜態方法裏不允許調用非靜態屬性
//        System.out.println(User.age);
    }
}

package day7_5;

public class UserTest {
    public static void main(String[] args) {
        User user = new User();
        user.age = 10;
        User.weight = 100;
        User.showWeight();
        
//        Arrays.sort(arg0);
        //1:沒有用static修飾的屬性和方法,被稱為成員屬性和成員方法
        //成員屬性和成員方法只能由對象來調用
        //2:使用static修飾的屬性和方法被稱為類屬性,
        //類屬性和類方法可以由類來調用
        //也可以由對象來調用
    }
}

結果圖:

Java學習記錄(補充三:面向對象的封裝和繼承)