Java基础（3）

面向对象编程

• 面向对象：先分类，然后使用面向过程思想具体实现每一个类的功能 ** 适合复杂的多人协作的大型项目*
• 面向过程：一步一步考虑怎样实现功能（线性） ** 适合简单的项目实现*

特性：继承，封装，多态

从认识角度：先有对象后有类

从代码角度: 先有类后有对象

本质：以类的方式组织代码，以对象的方式封装数据

类与对象

类是一个抽象的集合，对象是一个类的实例化

构建类：

public class person{                  //一个文件里只有一个public的类 
    //属性
    String name;
    int age;
    
    //方法
    public void print(){
        System.out.println("输出");
    }
}

实例化类：

使用new关键字创建对象的时候，除了会给它在内存上创建空间之外，还会给这对象初始化，以及对构造器调用

public class test{
    public static void main(String[] agrs){
        person man=new person();    //构造一个对象，将类实例化
        //将对象赋值
        man.name="xiaoming";    
        man.age=21;
        //调用类中的方法
        man.print();
    }
}

构造器（构造方法）：

public class student{
    //属性
    String name;
    int number;
    
    //无参构造  （显示定义）默认也存在
    public student(){
        
    }
    //有参构造
    public student(String name){
        this.name=name;
    }
    
    //方法
    
}

构造器定义：修饰符 构造器名（）{ }

​ 没有返回值，构造器名与类名相同

alt+insert 选择construct 快捷键生成构造器

作用：1.对对象初始化

​ 2.使用new，其实就是在调用构造方法（构造器）

当一个类里存在有参构造时，想要使用无参构造就必须将其显示定义出来。

在重写了有参构造之后，最好将无参构造显示的也写出来

封装

主题思想：属性私有，使用get/set调用修改

快捷键：alt+insert 选择get and set

作用：1. 使代码具有良好的可维护性和安全性

​ 2.统一接口

public class pet{
    //封装属性
    private String name;
    private int age;
    
    //用public编写调用方法get/set  
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

继承

• 继承是对某一些类的抽象，从而更好的对现实世界建模

• 子类继承父类的所有公有的方法和属性,私有的不能被继承

• 在Java中一个父类可以有多个子类，但一个子类有且仅有一个父类

• 所有的类都直接或间接的继承Object类

定义:子类名 extends 父类名

public class person{                  //一个文件里只有一个public的类 
    //属性
    private String name;
    private int age;
    
    //方法
    public void print(){
        System.out.println("输出");
    }
    public String setName(String name){
        this.name=name;
    }
    public int setAge(int age){
        this.age=age;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
    
}

public class teacher extends person{
   
}

调用teacher类时，可以使用public方法，但是属性是其私有的，不可以继承

super和this

super用来调用父类的构造方法

this用来调用本身的相关属性或方法

二者不能同时调用构造器

 public Student(){
        super();   //this();调用本身构造器，必须写在第一行；  super()调用父类构造器，也必须写在第一行。 二者不能同时出
        System.out.println("成功调用子类");

    }
    public  void  test(){
        super.test();
        System.out.println("子类的");
    }

注意：

1. 在new一个子类时，会先调用父类的构造器，再调用子类构造器

2. super必须写在子类方法的第一行，否则会报错

3. 如果父类重写了有参构造，则子类构造起中不能使用super()，必须要写super(参数)形式，不然会报错；

方法重写

要求：1.必须是非静态方法（静态方法不能被重写）

​ 2.必须使用public修饰符，不能使用private，范围可以扩大不能缩小 修饰符优先级：public->protected->default->private

​ 3.方法名相同，参数列表相同

​ 4.抛出异常：只能缩小不能扩大

静态方法：只和构造对象时的数据类型有关，不存在重写

public static void main(String[] agrs){
    A a=new A();  
    B b=new A();
    a.test();  //A
    b.test();  //B
}

public class A extends B{
     public static void test(){
        System.out.println("A");
    }
}
public class B{
    public static void test(){
        System.out.println("B");
    }
}

非静态方法：表示A类将B类的test方法重写了

public static void main(String[] agrs){
    A a=new A();  
    B b=new A();
    a.test();  //A
    b.test();  //A
}

public class A extends B{
    @override //重写
     public void test(){
        System.out.println("A");
    }
}
public class B{
    public  void test(){
        System.out.println("B");
    }
}

多态（方法的多态）

1. 构建一个对象时，引用类型在对象名左边，实际类型在对象名右边

   //A继承B
   A a=new A();  引用类型与实际类型相同，都是A
   B a=new A();  引用类型为B，实际类型为A  *父类的引用指向子类
   

   2.若只在子类里存在的方法，父类引用构建的对象就不能调用（类型转换异常 ClassCastException）

​ 若只在父类里存在的方法，则都可以调用该方法

​ 若子类将父类方法重写了，则都可以调用该方法

3.存在条件：继承关系，方法重写，父类对象指向子类

instanceof

比较对象和类之间是否有关系

public class test {
    public static void main(String[] agrs){
        //Object > String
        //Object > Person > student
        Student st1 = new Student();
        System.out.println(st1 instanceof Person);  //true
        System.out.println(st1 instanceof Student);  //true
        System.out.println(st1 instanceof Object);   //true
        System.out.println(st1 instanceof String);  //编译报错
        Person st2 = new Student();

        st1.test();
    }

X instanceof Y 能不能编译通过，就是取决于X和Y之间是否有关系

类型转换

子类可以自然转换成父类，父类必须强制类型转换成子类

public class test {
    public static void main(String[] agrs) {
        //Object > String
        //Object > Person > student
        Student st1 = new Student();
        Person st2 = new Student();
        st1.test();
        ((Student)st2).go();  //go方法是Student类（子类）特有的，Person类（父类）不能使用，要使用的话，必须强制类型转换
        
        //将子类自然转换成父类，丢失自己的方法
        Person st3=st1;
        st3.go(); //报错
        
    }
	
}