您的位置：首页 > 编程语言 > Java开发

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

2015-07-31 22:13 555 查看

封装

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

[code]    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;   
    } 
}

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

继承

继承：子类继承父类的方法和属性（利用extends）。

访问修饰符4种：


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

对象的初始化顺序：

1、首先是父类的属性

2、父类的构造器

3、子类的属性

4、子类的构造器

5、系统默认调用无参数的副类构造器

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

[code]    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是注解）

覆写：

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

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

多态

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

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

[code]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("哦，老鲜肉");
    }

[code]        dog.voice();
        dog.voice("aa");
        dog.voice(38);

相关补充

1、类：包含属性、方法、构造器

2、对象：生活中的每一实物都可以是一个对象

3、super()：super可以调用父类的方法或属性。还可以调用父类构造器，只能在构造器中使用super（“张三”）格式。方法：super.sleep();属性：super.age;无参构造器：super();有参构造器:super(“张三”)。

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

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

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

[code]        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这个类的实例

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

6、static关键字：修饰属性和方法。

修饰属性叫类的属性类共有的

修饰方法叫类的方法为类的方法以类调用

注：静态的方法中只能调用静态的属性

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

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

[code] 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是指当前对象自己

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

    }
    public Dog(String color){

    }

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

10、object的重写

[code]    @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+/+回车

[code]    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;
    }

[code]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、强制造型的格式：（（类名）对象）.方法();

[code]        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");
        }

学习问题

[code]System.out.println((douDou.getId()).equals((baoBao.getId())));

以上写法错误。

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

[code]System.out.println(douDou.equals(baoBao));

备注代码

[code]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));
    }

}

[code]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

    }

}

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航

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

目录

封装

继承

多态

相关补充

学习问题

备注代码