JAVA基础--java简单知识04(类与对象,封装,继承,多态)

(20) 2024-06-07 11:01:01

类与对象

在学习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类型转换出错");
        }
    }
}
THE END

发表回复