面向对象编程（二）封装--构造方法，this关键字，static关键字，方法重载

面向对象三大特点：封装、继承、多态

封装概念

①   将东西包装在一起，然后以新的完整形式呈现出来：

将方法和字段一起包装到一个单元中，单元以类的形式实现;

②   信息隐藏，隐藏对象的实现细节，不让外部直接访问到;

③   将数据和方法包装进类中，加上具体实现的隐藏，共同被称作封装，其结果是一个同时带有特征和行为的数据类型;

④   定义类，定义其属性、方法的过程称为封装类;

 

信息隐藏式OOP最重要的功能之一，也是使用访问修饰符的原因;

信息隐藏的原因包括：

①   对模块的任何实现细节所作的更改不会影响使用该模块的代码;

②   防止用户意外修改数据;

③   是模块易于使用和维护;

 

访问修饰符

①   public:该类或非该类都均可访问;

②   private:只有该类可以访问;

③   protected:该类及其子类的成员可以访问，同一个包中的类也可以访问;

④   默认:同一包中的类可以访问;

 

属性封装的实现

①   修改属性的可见性来限制对属性的访问;

②   为每个属性创建一对赋值（setter）方法和取值（getter）方法，用于公开对这些属性的访问接口;

③   在setter和getter方法中，根据需要加入对属性操作的限制;

要点：除非必须公开底层实现细节，否则应该将所有属性指定为private加以封装;使用属性封装，通过增加数据访问限制，增强了类的可维护性;

 

封装方法的目的

①   隐藏方法实现细节（方法体），向外部提供公开接口（方法头），以供安全;

②   简化调用，方便修改维护;

③   根据需要，可以私有化方法以供类内部使用----帮助方法help;

public class TeacherDemo
{
    public static void main(String []agrs){
        Teacher t=new Teacher();
        //t.name="张三";//不能直接赋值
        t.setName("张三");
        System.out.println(t.getName());
        t.setAge(10);
        System.out.println(t.getAge());
    }
}

class Teacher
{
    private String name;
    private int age;
    public void setName(String tname){
        name=tname;
    }
    public String getName(){
        return name;
    }
    public void setAge(int tage){
        if(tage<25)
        {
            System.out.println("年龄太小了");
            age=25;
        }
        else
        {
            age=tage;
        }
    }
    public int getAge(){
        return age;
    }
}

 

类的构造方法的概念和作用

①   构造方法负责对象初始化工作，为对象的属性赋合适的初始值;

②   创建对象时，其类的构造方法确保在用户操作对象之前，系统保证初始化的进行;

构造方法的语法规则

①   构造方法名与类名相同

②   没有返回类型

③   方法实现主要为字段赋初值

构造方法的调用和特别：new操作符（返回新建实例的引用）

无参构造方法

public class ConstructorDemo
{
    public static void main(String []agrs){
        Person p=new Person();//实例化的时候是有初始值的int默认0,String默认null
        p.setName("张三");
        p.setAge(10);
        System.out.println(p.toString());
    }
}

//当一个类没有显示声明一个构造方法时，系统会有一个默认的无参构造方法
class Person
{
    private String name;
    private int age;
    private String city;
    
    //默认的构造方法，实例化时候会调用，此处不写也可以，系统已默认写好
    public Person(){
        System.out.println("Person");
    }
    

    public void setCity(String pcity){
        city =pcity;
    }
    public String getCity(){
        return city;
    }
    
    public void setName(String pname){
        name=pname;
    }
    public String getName(){
        return name;
    }
    
    public void setAge(int page){
        age=page;
    }
    public int getAge(){
        return age;
    }
    
    public String toString()
    {
        return "名字:"+name+"，今年"+age+"岁，家住"+city;
    }
}

带参构造方法

public class ConstructorDemo
{
    public static void main(String []agrs){
        //带参调用，若不写参数会报错，因为Person中只有一个带参的构造方法
        Person p=new Person("张三",10,"杭州");
        //1、在堆中开辟空间，给属性分配默认的初始值
        //2、假设属性一开始就赋值了，就进行赋值工作
        //3、调用构造方法对属性进行初始化
        System.out.println(p.toString());
    }
}

class Person
{
    private String name="李四";
    private int age;
    private String city;
    
    //带参数的构造方法
    public Person(String pname,int page,String pcity ){
        name=pname;
        age=page;
        city=pcity;
    }
    
    public void setCity(String pcity){
        city =pcity;
    }
    public String getCity(){
        return city;
    }
    
    public void setName(String pname){
        name=pname;
    }
    public String getName(){
        return name;
    }
    
    public void setAge(int page){
        age=page;
    }
    public int getAge(){
        return age;
    }
    
    public String toString()
    {
        return "名字:"+name+"，今年"+age+"岁，家住"+city;
    }
}

 

this关键字

特点：

①在类的方法中使用的this关键字代表的是调用此方法的对象的引用;

②this可以看作是一个变量，它的值是当前对象的引用;

③使用this可以处理方法中的成员变量和形参同名的问题;

④当方法内需要用到调用该方法的对象时，就可以用this;

⑤在类的构造方法中可以调用this([参数列表])来调用该类的指定构造方法。

 public class ConstructorDemo
{
    public static void main(String []agrs){
        Person p=new Person("张三",10,"杭州");
        System.out.println(p.toString());
    }
}


class Person
{
    private String name="李四";
    private int age;
    private String city;
    
    //构造方法
    public Person(){
        System.out.println("无参构造方法");
    }
    
    //带参数的构造方法
    public Person(String name,int age,String city ){
        
        this();//表示调用当前对象的无参构造方法，必须写在第一句
        
        //此处将形参名称写成age与属性名相同
        //age=age;//此处不会对属性重新赋值age=0
        this.age=age;//此处对属性重新赋值age=10，this代表p    
        this.name=name;
        this.city=city;
        
    }
    
    public void setCity(String city){
        this.city=city;
    }
    public String getCity(){
        return city;
    }
    
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return age;
    }
    
    public String toString()
    {
        //默认前面都是有this的，可写可不写
        System.out.println(this.getAge());
        return "名字:"+this.name+"，今年"+age+"岁，家住"+city;
    }
}

 

static关键字

特点：

①用来修饰类的成员----修饰成员变量的称之为类变量（静态变量），修饰成员方法的称之为类方法（静态方法）;

②当类被加载时就会被加载，优先于对象的存在;

③用来修饰语句块----称之为静态代码块。先于构造方法之前执行，只会执行一次，用来对静态成员做初始化;

④静态修饰的成员被所有的对象共享;

⑤调用的时候可以直接通过类名.成员来进行访问

static关键字注意事项

①   静态方法中只能访问外部的静态成员;

②   静态方法中不能出现this;

 

非静态

public class StaticDemo
{
    public static void main(String []agrs){
        Account acc1=new Account();
        acc1.number1++;
        acc1.showNumber1();
        acc1.showNumber2();
        
        Account acc2=new Account();
        acc2.showNumber1();
        acc2.showNumber2();
    }
}

class Account
{
    public int number1=1;
    public int number2=2;
    public void showNumber1()
    {
        System.out.println(number1);
    }
    public void showNumber2()
    {
        System.out.println(number2);
    }
}

静态1

public class StaticDemo
{
    public static void main(String []agrs){
        Account acc1=new Account();
        acc1.number1++;
        acc1.showNumber1();
        //acc1.showNumber2();
        
        
        Account acc2=new Account();
        acc2.showNumber1();
        //acc2.showNumber2();
    }
}

class Account
{
    public static int number1=1;//静态变量（类变量），它不属于任何一个对象，被多个对象共享
    public int number2=2;
    public void showNumber1()
    {
        System.out.println(number1);
    }
    public void showNumber2()
    {
        System.out.println(number2);
    }
}

静态2

public class StaticDemo
{
    public static void main(String []agrs){
        Account.number1++;
        System.out.println(Account.number1);
        Account.showNumber1();
        
        Account acc1=new Account();
        acc1.showNumber2();
        
        Account acc2=new Account();
        acc2.showNumber2();
    }
}

class Account
{
    public static int number1=1;//静态变量（类变量），它不属于任何一个对象，被多个对象共享
    public int number2=2;
    //静态方法中不能使用非静态的变量
    //静态方法中不能使用this
    public static void showNumber1()
    {
        //showNumber2();//报错
        System.out.println(number1);
        //System.out.println(this.number2);//报错 
    }
    
    //非静态的方法可以访问静态的内容和非静态的属性和方法
    public void showNumber2()
    {
        showNumber1();
        System.out.println(number2);
        System.out.println("非静态方法访问静态变量："+number1);
    }
    
    //构造方法
    public Account(){
        System.out.println("constructor");
    }
    
    //static语句块
    //在类被加载时就会执行，只会执行一次，用来对静态的变量赋值
    //优先于构造方法执行
    static{
        System.out.println("static");
        number1=100;
    }
}

 

方法重载

多数程序设计语言要求为每个方法（函数）提供一个独一无二的方法名，不存在方法重载的概念

在Java中，规定方法签名是解析方法的规则而不是方法名，为方法重载开创了条件

方法重载使得在一个类中，方法名相同而参数列表不同的方法可同时存在，代表相似的行为和功能

 

重载overload概念：同一类中，同名不同参的方法称为重载方法

注意：仅有返回类型不同的方法不能称为重载，即方法重载必须方法签名不同

public class OverloadDemo{
    public static void main(String []agrs){
        Printer p=new Printer(2000);
        p.print("hello");    
        p.print(10);
        p.print("hello",10);
    }
}

class Printer{
    private String brand="联想";
    private double price;
    
    public Printer(double price){
        this.price=price;
    }
    
    public Printer(String brand,double price){
        this.brand=brand;
        this.price=price;
    }

    public void print(String content){        
        System.out.println("字符串"+content);
    }
    
    public void print(int content){        
        System.out.println("整型"+content);
    }
    
    public void print(String str,int content){        
        System.out.println(str+"--"+content);
    }
    
    public int print(int content,double d){        
        return content;
    }
}