java 的 封装 、继承

封装：

（1）好处：
提高代码的复用性；
隐藏实现细节，提供可以访问的方式（概念）；
提高安全性；
（2）私有private：（私有仅仅是封装的体现形式而已）
只能在本类中使用【隐藏实现细节】；
对成员属性提供方法（赋值、取值）：【提供可以访问的方式】

举个例子：

package com.oracle.demo01;
//定义一个手机类Phone，包含三个属性品牌(brand)、价格(price)、颜色(color)。
public class phone {
        private String   brand;
        private  double price;
        private   String  color;
        public String getBrand() {
            return brand;
        }
        public void setBrand(String brand) {
            this.brand = brand;
        }
        public double getPrice() {
            return price;
        }
        public void setPrice(double price) {
            if(price > 0){                 可以对属性设置条件
                this.price = price;
            }else{
                this.price = 0;
            }        
        }
        public String getColor() {
            return color;
        }
        public void setColor(String color) {
            this.color = color;
        }        
}

当我们对属性进行赋值和取值时，使用的是方法；

举个例子：

package com.oracle.demo02;

public class test {
    public static void main(String[] args) {
        person p = new person();
        /*p.age = 12;
        p.name = "zhangsan";*/
        p.setAge(12);
        p.setName("zhangsan");
        p.speak();
            
    }
}

 

（3）this：（对象，哪个对象调用了this所在的方法，this就代表哪个对象）
成员变量和局部变量的同名问题（注：遵循就近原则，不用this时）

举个例子：

public class person {
            private String name;
            private int age;
            
            public int getAge() {
                return age;
            }

            public void setAge(int age) {
                this.age = age;
            }

            public String getName() {
                return name;
            }

            public void setName(String name) {
                this.name = name;
            }

            public void speak(){
                //成员变量和局部变量同名时，如果不用this：遵循就近原则
                String name = "lisi";
                int age = 12;
                System.out.println("我叫"+this.name+"今年"+this.age+"岁");
            } 
}

建立测试类

package com.oracle.demo02;

public class test {
    public static void main(String[] args) {
        person p = new person();
        p.setAge(12);
        p.setName("zhangsan");
        p.speak();
            
    }
}

效果如下：

但是当将speak方法修改为：

public void speak(){
                //成员变量和局部变量同名时，如果不用this：遵循就近原则
                String name = "lisi";
                int age = 12;
                System.out.println("我叫"+name+"今年"+age+"岁");
            } 

效果如下：

 

 

2、继承：
（1）继承的格式&使用：
class 子类 extends 父类 {}
子类在继承父类的时候，会自动拥有父类可继承的成员。

package com.oracle.demo03;
//员工类（父类）
public class employee {
        String name;
        public void speak(){
            System.out.println("员工正在工作");
        }
}

package com.oracle.demo03;
//研发类员工（子类）
//子类继承父类：自动拥有所有可继承的成员
public class developer extends employee {
    
}

建立一个测试类

package com.oracle.demo03;

public class test {

    public static void main(String[] args) {
        developer d= new developer();
        d.name = "zhangsan";
        d.speak();
        System.out.println(d.name);

    }

}

效果如下：

（2）继承的好处&注意事项：
好处：提高了代码的复用性；
　　　提供了多态的前提；

（3）成员变量：

先要注意：就近原则

package com.oracle.demo04;

public class father {
        int a = 1;
}

package com.oracle.demo04;
//在继承中，成员变量的特点 ： 如果父类成员变量和子类成员变量同名，那么调用是子类成员变量。
public class son extends father{
        int a = 2;
        public void speak(){
            //遵循就近原则
            System.out.println(a);
        }
}

建立测试类：

package com.oracle.demo04;

public class test {

    public static void main(String[] args) {
        son s = new son();
        s.speak();

    }

}

super.父类中的成员变量

package com.oracle.demo04;

public class father {
         int a = 1;
        
}

package com.oracle.demo04;
//super.父类中的成员变量
public class son extends father{
    int a = 2;
    public void speak(){
        System.out.println(super.a);
    }
}

建立测试类：

package com.oracle.demo04;

public class test {

    public static void main(String[] args) {
        son s = new son();
        s.speak();

    }
}

效果如下：

 

还要注意：私有成员变量（能继承到但是不能取值和赋值，相当于没继承到）

举个例子：

package com.oracle.demo04;

public class father {
        private int a = 1;

        public int getA() {
            return a;
        }

        public void setA(int a) {
            this.a = a;
        }
        
}

package com.oracle.demo04;
//在继承中，成员变量的特点 ： 如果父类成员变量和子类成员变量同名，那么调用是子类成员变量。
public class son extends father{
    int b = 2;
    public void speak(){
        //遵循就近原则
        System.out.println(a);     报错 这里a相当于没继承到
    }
}

建立测试类：

package com.oracle.demo04;

public class test {

    public static void main(String[] args) {
        son s = new son();
        s.setA(0);            方法中对A进行赋值和取值
        s.getA();

    }

}

（4）成员方法：

package com.oracle.demo05;

public class father {
            public  void  zhengqian(){
                System.out.println("父类成员方法");
            }
}

package com.oracle.demo05;

public class son extends father{
        public void eat(){
            System.out.println("子类成员方法");
        }
}

建立测试类：

package com.oracle.demo05;

public class test {

    public static void main(String[] args) {
        son s = new son();
        s.eat();
        s.zhengqian();
        father f =new father();
        //f.eat();
    }

}

效果如下：

 

（5）方法重写：
方法的返回值类型 方法名 参数列表都要一样；

举个例子：（手机更新）

 旧手机：

package com.oracle.demo06;

public class phone {
            public void call(){
                System.out.println("打电话");
            }
            public void send(){
                System.out.println("发短信");
            }
            public void show(){
                System.out.println("显示电话号码");
            }
}

新手机：

package com.oracle.demo06;

public class iphone extends phone{
    //重写
        public  void show(){
            super.show();
            System.out.println("显示姓名");
            System.out.println("显示头像");
        }
}

测试类：

package com.oracle.demo06;

public class test {
    public static void main(String[] args) {
        iphone i = new iphone();
        i.call();
        i.show();
    }
}

效果如下：