java基础-对象

java对象

构造器详解

1. 构造的特点

   1. 与类的名字相同
   2. 没有返回值

2. 无参构造，默认的

3. 有参构造

创建对象内存分析

java封装

1. 将变量设置为private，不可以被访问

2. 将方法设置为public，可以由外部调用

3. command+N：可以自动生成set和get方法

4. 属性私有，get/set

继承

1. 父类

2. 子类

3. /*
   子类继承父类的所有public元素
   public
   protexted
   default
   
   */
   public class Person
   {
     
   }
   public class Student extend Person
   {
     
   }
   

4. 一个子类只能有一个父类

5. object类，所有类的父类

Super详解

1. super可以调用父类的构造方法

2. super必须只能出现在子类的方法或构造方法中

3. super和this不能够同时调用构造方法

4. 私有的东西还是无法被访问

5. 默认调用父类的无参构造

   public class Person
   {
     public Person()
     {
       System.out.println("Person调用");
     }
   }
   public class Student extend Person
   {
     public Student()
     {
       System.out.println("Student调用");
     }
   }
   //在new了Student后，先输出"Person调用",再输出"Student调用"
   

6. this():子类的构造

7. super():父类的构造

方法的重写

1. 静态方法与非静态方法区别很大

public class B {
    public  static void test()
    {
        System.out.println("B");
    }
}
public class A extends B {
    public static void test()
    {
        System.out.println("A");
    }
}
public class Main {
    public static void main(String[] args) {
        A a=new A();
        a.test();
        B b=new B();
        b.test();
    }
}
/*输出
A
B
*/

public class B {
    public  void test()
    {
        System.out.println("B");
    }
}
public class A extends B {
    public  void test()
    {
        System.out.println("A");
    }
}
public class Main {
    public static void main(String[] args) {
        A a=new A();
        a.test();
        B b=new B();
        b.test();
    }
}
/*输出
A
A
*/

2. 只有子类重写父类的方法，才能说重写

3. 重写

   需要有继承关系，子类重写父类的方法

   1. 方法名相同
   2. 参数列表必须相同
   3. 修饰符：范围可以扩大：public>protected>default(默认)>private
   4. 抛出异常：范围可以被缩小，但不能扩大

4. 为什么要重写

   父类的一些功能不满足子类的需求

多态

1. 同样的一个方法名，可以根据不同的对象（父类，子类），运行不同的方法

2. 必须要有重写，才能有多态

3. 子类重写父类，调用子类；没有重写，调用父类

4. Student s1=new Student();
   Person s2=new Person();
   /*
   父类可以指向子类，但是不可以调用子类特有的方法
   */
   
   

5. 注意事项：

   1. 多态是方法的多态，属性没有多态
   2. 子类和父类，有联系
   3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象！Father f1=new Son();

instanceof和类型转换

1. 有继承关系，instanceof才有用

2. /*
   用super详解中的例子
   */
   Student student=new Student();
   System.out.println(student instanceof Student);
   System.out.println(student instanceof Person);
   System.out.println(student instanceof Object);
   /*
   返回值都是true，当Student，Person，Object换成其他没有继承关系的，返回的都是false
   */
   

3. 类型转换

   子类转换为父类，可能丢失自己本来的一些方法。

   把指向父类，而定义为子类的对象。强制转换为子类的对象。

   public class B {
       public void test()
       {
           System.out.println("B");
       }
   }
   
   public class A extends B {
       public void test()
       {
           System.out.println("A");
       }
       public void hh()
       {
           System.out.println("hello");
       }
   }
   
   public class Main {
       public static void main(String[] args) {
           B b=new A();
   				//b.hh();//A
           ((A) b).hh();//B
   				
       }
   }
   //A处不可执行
   //B处可以执行
   

4. 总结

   1. 父类引用指向子类对象
   2. 把子类转换为父类，向上转型
   3. 把父类转换为子类，向下转型，强制转换