JAVA 封装 继承 多态

封装：

封装步骤：

1.使用private修饰需要被封装的属性。
2.提供一个公共的方法设置或获取该私有成员属性。（set属性名（），get属性名（））

代码：

class Member
{
    String name;
    private String sex;
    String salary;
    public void talk(){
        System.out.println(name + "happy day");
    }
    public void setSex(String ss)
    {
        if(ss.equals("男")||ss.equals("女"))
             sex = ss;
        else
             sex = "男";
    }
    public String getSex( )
    {
         return sex;
    }

}


class demo1
{
    public static void main(String[] args){
       Member m = new Member();
       m.setSex("dd");
       System.out.println("性别:" + m.getSex());
    }
}
**************************************************
class Calc
{
    private int num1;
    private int num2;
    private char ch;
    public void setNum1(int a){
        num1=a;
    }
    public void setNum2(int b){
        num2=b;
    }
    public void setCh(char st){
        ch=st;
    }
    public int run(){
       if(ch=='+')
           return num1 + num2;
       else if(ch== '-')
           return num1 - num2;
       else if(ch== '*')
           return num1 * num2;
       else  
           return num1 / num2;
    } 
}

class demo1
{
    public static void main(String[] args ){
         Calc dd = new Calc();
            dd.setNum1(1);
            dd.setNum2(2);
            dd.setCh('-');
            System.out.println( dd.run() );
    }
}

继承：

格式：

 class 类名1 extends class 类名2
 {
 }

使用注意：

 ** 只有存在继承关系的时候才去继承。
 ** 父类私有的成员和构造函数不能被继承。
 ** 创建子类时java编译器会默认调用父类的无参的构造方法。
    （调用父类的构造方法可以初始化从父类继承下去的属性）

代码：

class Person
{
    String name;

    public Person(String name)
    {
        this.name = name;
        System.out.println("Person 有 参数的构造方法调用了");
    }

    public Person()
    {
        System.out.println("Person 无 参数的构造方法调用了");
    }

    public  void eat()
    {
        System.out.println("Person eat eat");
    }
}

class Student extends Person 
{
    int num;

    public Student(String name)
    {
        super(name);   //指定调用父类一个参数的构造函数。。。
        //this.name = name;
        System.out.println("Student 有 参数的构造方法调用了");
    }

    public void study()
    {
        System.out.println("Student study study");
    }
}



class Demo3 
{
    public static void main(String[] args) 
    {
        Student s = new Student("ddddd");
        s.eat();
        System.out.println("Hello World!" + s.name);
    }
}

方法的重写：（子父类出现同名函数）

前提：

   １.必须要存在继承关系。

注意事项：

　　　　１. 方法名和形参列表必须一致；
　　　　 2. 子类的权限修饰符 > = 父类的权限修饰符
　　　　 3. 子类的返回值类型 < = 父类的返回值类型
　　　　 4. 子类抛出的异常类型 < = 父类抛出的异常类型
Exception （最坏）
RuntimeException ( 小坏）

代码：

class  Fu
{
    String name;
    public Fu(String name)
    {
        this.name = name;
    }
    public void eat(){
        System.out.println(name + "吃番薯。。。。。");

    }
}

class Zi extends Fu
{
     String num;
     public Zi(String name)
    { 
       super(name);
    }
     public void eat()
    {
        System.out.println("ffffffff");

    }
}



class  Demo1
{
    public static void main(String[] args) 
    {
        Zi z = new Zi("大头儿子");
        z.eat();
        System.out.println("Hello World!");
    }
}

多态

定义：

一个类有有多种形态。（例如：动物可以由多种组成）
两种表现：1.父类的引用类型变量指向了接口实现类的对象；
        2.接口的引用类型变量指向了接口实现类的对象。

使用前提：

必须存在继承和实现关系。

使用注意：

1.多态情况下，子父类存在同名的成员时，默认访问父类的成员，除了在同名的非静态函数时，访问的是子类函数。
2.多态情况下，不能访问子类特有的成员。

多态的应用：

1.多态用于形式参数类型时，可以接收更多类型的数据。
2.多态用于返回值类型时，可以返回更多类型的数据。

样例代码：

abstract class MyShape
{
    public abstract void getArea();
    public abstract void getLength();
}

class Rect  extends MyShape
{
    double x,y;
    public Rect(double x,double y)
    {
        this.x =x;
        this.y =y;
    }
    public void getArea()
    {
        System.out.println("矩形的面积" + x*y);
    }
    public void getLength()
    {
        System.out.println("矩形的周长" + 2*(x+y));  
    }
}

class Circle extends MyShape
{
    public static final double PI = 3.14;
    double r;
    public Circle(double r)
    {
        this.r = r ;
    }
    public void getArea()
    {
        System.out.println("圆的面积" + PI*r*r);
    }
    public void getLength()
    {
        System.out.println("圆的周长" + 2*PI*r);    
    }
}


class Demo3
{
    public static void main(String[] args)
    {
         MyShape a = new Circle(4.0);  // 多态的使用
         print(a);
         Myshape b = new Rect(4,5);
         print(b);
    }

    public static void print(MyShape s)
    {
        s.getArea();
        s.getLength();
    }
}
***************************************************
// 多态在接口中的使用：
interface  Dao   
{
    public abstract void print();

    public abstract void eat();
}

class UerDao implements Dao
{
    public void print()
    {
        System.out.println("走走走");
    }
    public void eat()
    {
        System.out.println("吃吃吃");
    }
}

class Demo9 
{
    public static void main(String[] args)
    {
         Dao  a = new  UerDao();
        a.print();
        a.eat();
    }
}