面向对象之第一章

构造器

在类中用来创建对象的方法称之为构造器，构造方法，构造函数
构造器是一种特殊的方法：
            （1）方法名称和类名相同
            （2）	放法无返回值
            （3）在方法中无须显示return返回数据
            （4）允许方法重载
            （5）所有类默认情况下都会存在一个无参构造器，如                果在当前类中声明了构造器后，无参构造器就不存在
构造器的作用：用来创建对象（构造器的调用只能通过new关键字来调               用）。

package com.mage.oop;  
public class Student {  
    static int count=1;  
    int id;  
    String name;  
    int sex;  
    String clz;  
      
    public Student() {  
        System.out.println();  
    }  
    public Student(String name) {  
        this.name=name;  
    }  
    public Student(String name,int sex) {  
        this(name,sex,count++,"0708");  
    }  
    public Student(String name,int sex,int id,String clz) {  
        this.name=name;  
        this.id=id;  
        this.clz=clz;  
        this.sex=sex;  
    }  
    public void study() {  
        System.out.println(this.name+"day day up");  
        System.out.println(this.info());  
    }  
    public String info() {  
        return "student[id:"+this.id+",name:"+this.name+",sex:"+(this.sex==0?"男":"女")  
                +",clz:"+this.clz+"]";  
    }  
}  

package com.mage.oop;  
public class Test01 {  
    public static void main(String[] args) {  
        //创建一个student对象，通过带参构造器  
        Student stu1=new Student("张三",1,1,"0709");  
        System.out.println(stu1.info());  
          
        Student stu2=new Student("李四",0);  
        System.out.println(stu2.info());  
    }  
}

引用类型经过方法

基本数据类型：基本数据类型经过方法后，值不变。值出传递
引用数据类型：引用数据类型经过方法后，值会改变，同样也是值传               递，不过它是地址的值传递
tips：通过两个变量指向了同一个内存地址，一个对内存改变了的话，       另一个也是可见的。

继承

定义：子承父业，将多个类中的共性抽取出来，作为一个父类，这样可      以提高代码的复用性。
格式：子类 extends 父类 
     继承之后子类就拥有了父类的属性和方法。
tips:1.java中只支持单继承，一个子类只能有有一个父类。
     2.多继承：极大提高代码的可复用性，但是复杂度也提高了
       单继承：代码复杂度低，但是可复用性有限。

封装

定义：将代码中的实现细节的部分进行包装，隐藏起来。
作用：保护屏障，防止该类的代码和数据被外部类随意访问和修改。
方法：1.修改属性的可见性（private）
     2.对每个值提供对外的公共访问方法和设置方法

this

this的用法：
  this.:当前对象的->(谁在调用代表谁)；this一般可以省略，但是为了区分同名变量，局部变量和成员变量时不可省略。
  this():构造器之间的互相调用

super

要注意的是在创建子类对象时，会先执行父类的构造器。
super.:当期对象的父类对象的，可以省略，如果子类和父类中出现了        同名变量，同名方法就不能省略。
super():调用父类的构造器，默认情况是调用父类的无参构造器。
tips：1.当父类中存在其他构造器时，无参构造器不存在，如果子类中没有super()显示的指定调用的构造器会导致程序报错。
      2.在构造器中this()和super()不能同时出现，因为他们都     只能放在第一行，会造成二异性。

package com.mage.oop.extend;  
public class Test01 {  
    public static void main(String[] args) {  
        Dog  d=new Dog();  
    }  
}  
class Animal{  
    String name;  
    public Animal() {  
        System.out.println("我被调用了。。。。");  
    }  
    public Animal(String name) {  
        this.name=name;  
        System.out.println("带参的构造器被调用了");  
    }  
    public void eat() {  
        System.out.println("吃东西");  
    }  
}  
class Dog extends Animal{  
    String NickName;  
    public Dog() {  
        this("啊哈");  
        System.out.println("dog 我被调用了");  
    }  
    public Dog(String NickName) {  
        this.NickName=NickName;  
        System.out.println("带参的我被调用了，，，，");  
    }  
    public void lookdoor() {  
        System.out.println("看门");  
        super.eat();  
    }  
    public void eat() {  
        System.out.println("吃东西");  
    }  
}  

重写

定义：在子类中定义了和父类中同名的方法。
重写环境：父类中的功能不能满足子类的需求，子类在父类的基础上进行扩展。
判定条件：在子类的方法上加上@overried注解，如果不报错，就是重写。
重写的前提：1.一定要发生继承关系，并且子类的方法名和父类的方法             名要相同
          2.参数列表要相同
          3.返回类型要相同

object

object是所有类的根基类，父类，超类；当一个类没有显示的继承关系时，默认情况下的父类都是object类
object：
    finalize：gc回收垃圾时，自动调用finalize
    
tips：输出一个对象的时候默认情况下会先调用当前对象的toString
     ==比较数据类型比较的是值，比较引用类型比较的是地址
     equals：用来比较是否相等，相等返回true，否则返回false
     object中是通过==比较

修饰符

修饰符的作用：用来屏蔽一些底层的实现逻辑，降低复杂度，确保当前             类更安全
作用范围：1.类
		2.变量
		3.方法
public ：公共的，谁都能访问，被public修饰的类，方法，变量能被所有的类可见。
protected：同包下可见，异包下子类可见
默认的：不写，同包下可见，异包下不可见
private：本类可见
tips:1.局部变量只能通过final修饰
2.将类中的成员变量通过public 默认的 protected 修饰之后，导致在某些情况下可以随意.出来。这些修饰符修饰的变量不够安全
3.如果用private修饰的话 一定要保证对外提供get、set方法让外部可见

	本类	同包下子类	同包下无关类	异包下子类	异包下无关类
public	√	√	√	√	√
protected	√	√	√	√	×
默认的	√	√	√	×	×
private	√	×	×	×	×

package com.mage.oop.extend;  
public class FlowerUtil {  
    public static boolean isFlower(int num) {  
        int sum=sum(num);  
        return num==sum;  
    }  
    private static int sum(int num) {  
        int result=0;  
        int length=length(num);  
        while (num!=0) {  
            int bit=num%10;  
            result=result+pow(bit,length);  
            num=num/10;  
        }  
        return result;  
    }  
    public static int length(int num){  
        int length=0;  
        while(num!=0) {  
            num/=10;  
            length++;  
        }  
        return length;  
    }  
    public static int pow(int bit,int length) {  
        int result=1;  
        for(int i=1;i<length;i++) {  
            result=result*length;  
        }  
        return result;  
    }    
}