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

lewis 1年前 (2024-05-04) 阅读数 19 #技术

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

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

false

子类不同包

true

false

其他

true

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("动物叫");
    }
}

多态

new Animal();
        Animal animal2=new Dog();
        Animal animal3=new

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

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

.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类型属性

;
        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时，必须在第一行

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

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

版权声明

本文仅代表作者观点，不代表博信信息网立场。

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

版权声明

作者文章