Java面向对象的三大特征及学习心得

目录

• 封装
• 继承
• 多态
• 相关补充
• 学习问题
• 备注代码

Java面向对象的三大特征：封装、继承、多态。

---

封装

封装是把对象的属性和操作结合为一个独立的整体，并尽可能隐藏对象的内部实现细节，利用private实现。封装的实现：         1、私有化属性(private)         2、公开的方法（set/get）         3、加入限制条件（判断条件的合理性，例如age）

    public class Student extends Person{    private int age;  //private隐藏类内部，只能在本类中使用    public int setAge;//公开的方法    public void set(int age){        if(age>50){            System.out.println("lao");//判断合法性            this.age=20;        }    }    public int get(){        if(age>10){            return 19;      }        return 0;       } }

public class Person {    public static void main(String[] args) {        Student zhangsan=new Student();        System.out.println(zhangsan.get());    }}

继承

继承：子类继承父类的方法和属性 （利用extends）。
访问修饰符4种：

访问修饰符 public protected default private 本类 true true true true 子类同包 true true true false 子类不同包 true true false false 其他 true false false false

public :任何情况都可以访问
protected：子类
default：子类同包
private：只能在本类访问

对象的初始化顺序：
1、首先是父类的属性
2、父类的构造器
3、子类的属性
4、子类的构造器
5、系统默认调用无参数的副类构造器

public int age=10;       public Student(String name,String sex){     super("张三","nan");//super子类必须在子类构造器第一行     //构造器中没有super时，默认为super（）,此时super无参数传递;     System.out.println("子类构造器");     System.out.println("子类属性age"+age);           }

    public Person() {    }    public Person(String name1, String sex1) {        name = name1;        sex = sex1;        System.out.println("父类的构造器");        System.out.println("父类的属性age" + age);        System.out.println(name);        System.out.println(sex);    }

多态

多态 ：父类的引用指向子类的对象，调用同样的方法产生的结果不同。
方法的覆盖/重写:子类中覆写父类中的方法
特点：
1、方法名称相同
2、返回值类型相同
3、参数列表相同
4、访问修饰符不能比父类更严格
5、私有方法因为不能继承不能重写
复写的快捷键：
1、方法名+alt+回车
2、工具栏：source+override…（Override是注解）
覆写：

public class Dog extends Animal{        public void voice(){        System.out.println("汪汪汪");    }}

public class Animal {public void voice(){        System.out.println("动物叫");    }}

多态

        Animal animal=new Animal();        Animal animal2=new Dog();        Animal animal3=new Cat();        animal.voice();        animal2.voice();        animal3.voice();

方法的重载：方法名相同 参数列表不同 无关访问修饰符和返回值类型

public void voice(String sex){        System.out.println("看见美女摇尾巴");          }    public void voice (int age1){        int age=age1;        if(age<=30)        System.out.println("哇塞，小鲜肉");        else        System.out.println("哦，老鲜肉");    }

        dog.voice();        dog.voice("aa");        dog.voice(38);

相关补充

1、类：包含属性、方法、构造器
2、对象：生活中的每一实物都可以是一个对象
3、super()：super可以调用父类的方法或属性。还可以调用父类构造器，只能在构造器中使用super（“张三”）格式。方法：super.sleep();属性：super.age;无参构造器：super();有参构造器:super(“张三”)。

 public void study(){        super.sleep();//super调用父类的方法        System.out.println(super.age);//super用于调用父类属性        System.out.println(age);     }

4、自动装箱与自动拆箱：

     int i=9;       int m=new Integer(9);     //自动拆箱     Integer n=9;             //自动装箱    System.out.println(i==n);//此时n自动拆箱

        int m=new Integer(9);        int n=new Integer(9);        System.out.println(m==n);        //此时m=n，原因：m与n自动拆包

5、instance of: A instanceof B
A是一个对象（使用new实例的对象）
B是一个类（不是方法名）
他表示A这个对象是否是B这个类的实例

if(animal2 instanceof Dog){            //instanceof判断是否为狗的对象            //强制类型转换 强制造型            ((Dog) animal2).voice(18);            ((Dog) animal2).voice("lisi");        }

6、static关键字：修饰属性和方法。
修饰属性叫类的属性 类共有的
修饰方法叫类的方法 为类的方法以类调用
注：静态的方法中只能调用静态的属性

 public static void eyesNum(){   //static类型的方法              System.out.println(2);        }        public static int eyes=2;//static类型属性

        Dog wangcai=new Dog();        Animal.wangcai.add(4,5);         Animal.eyesNum();      //调用静态方法        System.out.println(Animal.eyes);//调用静态属性

 public static void eyesNum(){                  System.out.println(2);        }        public static int eyes=2;

7、final关键字：
修饰类时表示最终的类，不允许被继承，没有子类。
final修饰方法时，方法不允许被复写。
final修饰变量时，将变量变为常量，不允许被修改。

8、静态常量书写格式： static final int EYE_NUM
注： 静态常量命名为全部大写字母用下划线隔开。
9、this与super：this是指当前对象自己

    public Dog(){        this("黄毛");        //调用本类的构造器，必须写在第一行        //super调用父类构造器，必须写在第一行    }    public Dog(String color){    }

public class Student extends Person {    Student(){        //有一句隐式的super()调用父类的构造函数。        super("zhangsan");    }    Student(String name){        super(name);  //super()在使用时，必须在第一行        //this(name);//在构造器中使用this时，必须在第一行        System.out.println(name);    }

10、object的重写

    @Override    public boolean equals(Object obj) {          if(obj!=null){              if(obj instanceof Dog){                 if( ((Dog)obj).id==this.id )                    return true;                    }          }

11.equals可以自己重新定义：equals+alt+/+回车

    public int id;    public String name;    public boolean equals(Object obj) {          if(obj!=null){              if(obj instanceof Dog){                 if( ((Dog)obj).id==this.id )                    return true;                    }          }          return false;    }

Dog douDou=new Dog();        Dog baoBao=new Dog();        douDou.id=333;        baoBao.id=333;        douDou.name="豆豆";        baoBao.name="豆豆";        System.out.println(douDou==baoBao);        System.out.println(douDou.equals(baoBao));

12、强制造型的格式：（（类名）对象）.方法();

        Animal animal2=new Dog();        Animal animal3=new Cat();        animal.voice();        animal2.voice();        animal3.voice();        if(animal2 instanceof Dog){            //intanceof判断是否为狗的对象            //强制类型转换 强制造型             //把animal2这个对象强制转换为Dog类            ((Dog) animal2).voice(18);            ((Dog) animal2).voice("lisi");        }

学习问题

System.out.println((douDou.getId()).equals((baoBao.getId())));

以上写法错误。
原因：由于equals为引用数据类型不能比较int类型的。正解如下：

System.out.println(douDou.equals(baoBao));

备注代码

package day03pm;public class Test {    public static void main(String[] args) {//      Dog dog=new Dog();//      //方法重载 方法名相同 参数列表不同//      dog.voice();//      dog.voice("danfeng");//      dog.voice(38);        Animal animal=new Animal();        Animal animal2=new Dog();        Animal animal3=new Cat();        animal.voice();        animal2.voice();        animal3.voice();        if(animal2 instanceof Dog){            //intanceof判断是否为狗的对象            //强制类型转换 强制造型            ((Dog) animal2).voice(18);            ((Dog) animal2).voice("lisi");        }//      String s="123123";//      Integer k=new Integer(11);//      System.out.println(s+3);//      System.out.println(k.parseInt(s)+3);//      System.out.println(k.parseInt(s+3));//      String s2="F2";//      Integer h=new Integer(9);//      System.out.println(h.parseInt(s2, 16)+3);//              //多态  父类的引用指向子类的对象        //调用同样的方法产生的结果不同//      String s1= new String("abc");//      String s2=new String("abc");//      String s3="abc";//      String s4="abc";//      System.out.println(s1==s2);//      System.out.println(s1==s3);//s1栈，s2堆//      System.out.println(s3==s4);        int m=new Integer(9);        int n=new Integer(9);        System.out.println(m==n);//      int i=9;//      int j=9;//      Integer k=new Integer (9);//      Integer h=new Integer(9);//      System.out.println(i==j);//      System.out.println(k==h);//      System.out.println(i==k);//      int m=new Integer(9);//自动拆箱//      Integer n=9;//自动装箱//      System.out.println(i==n);//此时n自动拆箱//      Dog wangcai=new Dog();//      Animal.wangcai.add(4,5); //      Animal.eyesNum();//调用静态方法//      System.out.println(Animal.eyes);//调用静态属性//      Dog dog=new Dog();//      System.out.println(dog);//      System.out.println(dog.toString());//输出与上一条相同//      System.out.println(dog.hashCode());//      String s1="19e0bfd" ;//      System.out.println(Integer.parseInt(s1,16));        Dog douDou=new Dog();        Dog baoBao=new Dog();        douDou.id=333;        baoBao.id=333;        douDou.name="豆豆";        baoBao.name="豆豆";        System.out.println(douDou==baoBao);        System.out.println(douDou.equals(baoBao));//      Dog douDou=new Dog();//      Dog baoBao=new Dog();//      douDou.setId(333);//      baoBao.setId(444);//      douDou.setName("豆豆");//      baoBao.setName("宝宝");//      System.out.println(douDou.equals(baoBao));    }}

package day03pm;public class Dog extends Animal{    public Dog(){        this("黄毛");        //调用本类的构造器，必须写在第一行        //super调用父类构造器，必须写在第一行    }    public Dog(String color){    }    @Override//表示复写的方法    public void voice(){        System.out.println("汪汪汪");        //根据Animal可以看出这是一个子类中腹泻父类的方法（也叫重写）        //方法的重写的特点：        //1、方法名称相同        //2、返回值类型相同        //3、参数列表相同        //4、访问修饰符不能比父类更严格    }//   // @Override//    public void voice() {//      // TODO Auto-generated method stub//      super.voice();//    }    public void voice(String sex){        System.out.println("看见美女摇尾巴");          }    public void voice (int age1){        int age=age1;        if(age<=30)        System.out.println("哇塞小鲜肉");        else        System.out.println("老鲜肉");    }    public static void eyesNum(){               System.out.println(2);    }    public static int eyes=2;    public static int add(int a,int b){        return a+b;    }    public int id;    public String name;    @Override    public boolean equals(Object obj) {          if(obj!=null){              if(obj instanceof Dog){                 if( ((Dog)obj).id==this.id )                    return true;                    }          }          return false;    }//    private int id;//    private String name;    public int getId() {        return id;    }    public void setId(int id) {        this.id = id;    }    public String getName() {        return name;//get有返回值所以可以使String    }    public void setName(String name) {        this.name = name;//set没有返回值所以是void    }}