JAVA基础--java简单知识04（类与对象，封装，继承，多态）

类与对象

在学习Java中，最重要的就是面对对象，面对对象三大特性：封装，继承，多态
什么是面对对象？
面对对象，就是你在进行开发时，把所有能够认知到的事物看做对象，去描述它的行为和特征。
什么是类和对象？
类
类是确定对象将会拥有的特征（属性）和行为（方法），类在客观中是不存在的，它只是用来描述对象的一些信息。
类的特点：
类是对象的类型
具有相同方法和属性的一组对象的集合
对象
对象就是能够描述出来的物体，万物皆对象，你所能够认知出来的都可以成为对象，对象具有特征（属性）和行为（方法）
什么是对象的属性
对象具有类型，属性，对象的属性就是指对象所拥有的特征，
列如你要买电脑，电脑有什么特征，它有品牌，价格，笔记本类型是游戏本还是商务本等等一些特定值，可以进行描述这个电脑的都属于它的特征（也就是属性）
什么是对象的方法
对象执行的操作，或者说对象能够做什么或者说对象的功能，能够做什么的行为或者对象的功能都叫做对象的方法。你买一台电脑，这个电脑能打游戏，能上网，打游戏和上网就称为名为电脑的对象的方法。
类和对象的区别
类是抽象，客观是不存在的，类只是用来描述对象的具体信息，类是实体，可以根据类中的构造方法来得到对象，计算机操作的是数据，而对象就是真实的数据信息，而类就是数据信息的类型。
定义一个类
类是所有java程序中的组织单元，现有类才能创建对象。
定义一个类：
类的名字
属性
方法

//创建一个名为computer的类
public class computer {
    //类的属性（也叫成员变量）
    String brand;//电脑的品牌
    int price;//电脑的价格
    String type;//电脑的类型

    //类的方法
    public void playGame(){
        System.out.println("使用电脑打游戏");
    }
    public void netPlay(){
        
        System.out.println("使用电脑上网!"+"brand:"+brand+" price:"+price+" type:"+type);
    }

}

使用类去创建对象
使用类去创建对象叫做实例化

public class InitailComputer {
    public static void main(String[] args){
        //使用computer类进行创建computer对象，new computer(）就是实例化
         computer computer=new computer();、
         //调用方法
         computer.netPlay();
    }
}

执行结果为：使用电脑上网!brand:null price:0 type:null
在没有给实例变量赋值的情况下，默认值为0和NULL
什么是实例变量
声明在所有方法体和代码块之外，并且没有使用static修饰的变量，叫做实例变量；
在使用对象需要两步操作：
对实例变量进行赋值

		 //给实例变量赋值
        computer.brand="联想";
        computer.price=5000;
        computer.type="游戏本";

调用方法
三种变量
构造方法
在创建对象时，我们使用的是实例化过程，也就是new computer（）；后面的computer（）;就是构造方法，我们刚刚的computer类中并没有这个方法，当类中，没有这个方法时，系统会自动生成这个构造方法。有无参构造和有参构造，有参构造需要我们自己创建。有参构造可以对实例变量进行初始化。
构造方法与普通方法的不同
1.普通方法是描述对象的行为或者是功能，而构造方法是用来创建对象。
2.构造方法用来初始化对象。与类名相同，但没有返回值。
构造方法的特点
1.没有构造方法时，系统会自动添加无参构造方法
2.当有指定的构造方法时，无论是无参构造还是有参构造，系统都不会再自动添加无参构造
3.构造方法也是方法，也会有重载，根据参数的类型和个数进行调用不同的重载构造方法
4.不仅能在构造方法中给属性赋值，还能保证赋的是合理值
类与对象总结：
创建一个类，去描述一个对象的属性（变量）和行为（方法），创建对象的过程叫做实例化，就是new 构造方法了，创建完对象后的变量叫做实例变量，对象要对其进行初始化。

封装

将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
好处
用户只能通过规定的方法去访问数据
可以去隐藏类的实例细节，方便修改和实现
封装的实现步骤
1.修改属性的可见性语句
2.创建getter/setter方法
3.在getter/setter方法中加入属性控制语句
使用getter/setter方法可以进行对属性进行赋值，但并不是只能使用getter/setter方法进行对属性的赋值，使用getter/setter方法是一种标准，一种规范。
java中的包管理，访问修饰符，this关键字
Java中的内部类

继承

继承是一种类与类之间的关系，有个动物类，一个猫类，猫是动物，猫继承动物类，那么动物类被称为父类，猫类被称为子类。
继承的好处
1.子类拥有父类的所有属性和方法，前提属性和方法的修饰符不能为private，使用private修饰符的属性和方法将不能被继承。
2.实现代码的复用
语法
class 子类 extends 父类
创建一个父类

public class Animal {
    public String name;
    public int age;
    public String color;
    public void lound(){
        System.out.println("动物会叫");
    }
}

创建一个子类继承父类

public class Cat extends Animal {
}

创建子类对象

public class Initail {
    public static void main(String[] args) {
        Cat cat=new Cat();
        cat.name="小花";
        cat.lound();
    }
}

继承的初始化顺序
初始化父类在初始化子类
先执行初始化对象中属性，在执行构造方法中的初始化

//父类
public class Animal {
    public String name;
    public int age;
    public String color;
    public void lound(){
        System.out.println("动物会叫");
    }
    //父类构造方法
    public Animal(){
        System.out.println("animal构造方法执行");
    }

}

//子类
public class Cat extends Animal {
    public Cat(){
        System.out.println("Cat构造方法执行");
    }
}

//执行类
public class Initail {
    public static void main(String[] args) {
        //创建cat对象
        Cat cat=new Cat();
        cat.name="小花";
        cat.lound();
    }
}
/*
*结果为：animal构造方法执行
*Cat构造方法执行
*动物会叫
*/

当我们进行创建子类对象时，先是创建父类的属性进行初始化，再执行父类的构造方法，然后执行子类对象属性的初始化，再执行子类的构造方法
方法的重写
子类继承父类的方法，对父类的方法不满意，想写一个子类自己的方法，就是方法的重写，在调用方法时，会优先调用子类的方法。

返回值类型
方法名
参数类型及个数
都要与父类继承的方法相同，才叫方法的重写

子类不想进行动物叫，想要自己叫，于是在子类中重写父类方法：

public class Cat extends Animal {
    public void lound() {
        System.out.println("小猫叫 喵喵喵");
    }
}

多态

多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口，使用不同的实例而执行不同操作
引用多态
父类的引用可以指向本类的对象
父类的引用可以指向子类的对象
方法多态
创建本类对象时，调用的方法为本类方法
创建子类对象时，调用的方法为子类重写的方法或者继承的方法

构成多态的三个条件：
继承
方法重写
父类引用指向子类对象

对于多态的理解
父类引用指向子类对象，就是 父类类名 对象名=new 子类类名（）；特点是：创建出的对象是向上转型，就是可以进行调用父类的属性，父类的方法和子类重写父类的方法，而不能去调用子类的属性和子类特有的方法。

public class Animal {
    public String name="动物";//父类属性
    //父类方法
    public void lound(){
        System.out.println("动物叫");
    }
}

//子类继承父类
public class Cat extends Animal {
    public String name="小猫";//子类属性
    //子类重写父类lound方法
    public void lound(){
        System.out.println("小猫叫");
    }
    //子类特有方法
    public void play(){
        System.out.println("玩耍");
    }
}

public class Initail {
    public static void main(String[] args) {
        //创建子类对象1
        Cat cat=new Cat();
        System.out.println(cat.name);//输出为子类属性名称
        cat.lound();//调用子类重写方法
        cat.play();//调用子类特有方法
        //父类引用指向子类
        Animal animal=new Cat();//向上转型
        System.out.println(animal.name);//输出为父类属性名称
        animal.lound();//调用子类重写方法
   //  animal.play();不能进行调用子类特有方法,想要去调用子类的特有方法，可以向下转型
        Cat c=(Cat) animal;//向下转型
        c.play();
    }
}

引用类型的转换
向上类型转换：
把小类型向大类型进行转换（隐式、自动类型转换、无风险）
向上类型转换：
把大类型向小类型进行装换（强制类型转换、有风险）

public class Initail {
    public static void main(String[] args) {
        //创建子类对象1
        Cat cat=new Cat();//注意刚开始的类型为Cat类型
        Animal animal=cat;//自动类型转换，向上类型转换
        Cat cat2=(Cat)animal;//强制转换，向下类型转换

        /**Dog dog=(Dog)animal;
         *  这样进行转换时编译器不会报错，但在运行时会进行报错
         *  由于刚开始我们向上进行类型转换，转换类型为cat类型
         *  在进行第二次向下类型转换时，转换类型为Dog类型
         */
        Dog dog=(Dog)animal;

    }
}

instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题

public class Initail {
    public static void main(String[] args) {
        //创建子类对象1
        Cat cat=new Cat();//注意刚开始的类型为Cat类型
        Animal animal=cat;//自动类型转换，向上类型转换

        if(animal instanceof  Cat){
            Cat cat2=(Cat)animal;//强制转换，向下类型转换
        }else {
            System.out.println("cat类型转换出错");
        }
        if(animal instanceof  Dog){
            Dog dog=(Dog)animal;
        }else{
            System.out.println("Dog类型转换出错");
        }
    }
}