当前位置： 移动技术网 > IT编程>开发语言>Java > Java之类和对象概述

Java之类和对象概述

2020年07月17日  | 移动技术网IT编程  | 我要评论

类和对象

java是面向对象的，关注的是对象，是将一件事情分成很多不同对象，靠对象与对象之间的交互完成。

类和对象的实例化

类是一类对象的统称，而对象是这一类具体化的一个实例。一个类可以产生多个对象

基本语法

在java中使用关键字class声明类。

//创建类
class Person {
    //成员变量（也可以说是字段、属性）
    public String name;
    public int age;
    public String sex;
    //成员方法
    public void eat(){
        System.out.println("在吃饭");
    }
    publi void sleep(){
		System.out.println("在睡觉")；
	}
}

类的实例化

类的实例化：通过类类型创建对象的过程

类就像模型一样的东西，限定了成员。 类可以在实例化多个对象，对象才能存储实际数据，占用物理内存存储成员属性。

  • 在类的实例化过程中通过关键字new实例化对象；
  • 使用 . 可以访问对象属性和方法 ；
  • 一个类可以实例化多个对象。
public class Person {
    //属性
    public String name;
    public int age;
    //成员方法
    public void eat(){
        System.out.println("吃饭");
    }
    public static void main(String[] args) {
        Person person1 = new Person(); //通过关键字new实例化对象
        Person person2 = new Person();
        person.name = "冷"; //调用属性需要通过对象引用调用
        person.age = 18;
        person1.eat(); //调用成员方法需要通过对象引用调用
    }
}

类的成员

1、字段（属性或变量）
在类中但方法的外部成为字段或属性或变量。用来描述一个类中包含哪些数据。

  • 使用 . 访问对象字段；
  • 可以对字段进行读写；
  • 若一个对象的字段没有进行显式初始化，那么会被设置为默认值。
class Person {
    //属性
    public String name;
    public int age;
    public String sex;
}
public class Main{
	public static void main(String[] args) {
        Person person = new Person(); //通过关键字new实例化对象
        person.name = "冷";
        System.out.println(person.name);
        System.out.println(person,sex);
        System.out.println(person.age);
    }
}

类的方法

类的方法用来描述一个对象的行为。
此时类的方法不用static修饰。

class Person {
    //成员方法
    public void eat(){
        System.out.println("吃饭");
    }
    public void show(){
    	//表示Person对象具有的“自我介绍”行为
        System.out.println(name + "今年" + age + "岁啦~");
    }
}
public class Main{
	public static void main(String[] args) {
        Person person = new Person(); //通过关键字new实例化对象
        person.name = "冷";
        person.age = 18;
        person.show(); 
    }
}

方法中还有一种特殊的方法称为构造方法。

构造方法

构造方法在实例化对象时自动调用该方法

  • 构造方法方法名必须和类名相同
  • 构造方法不用声明返回类型
  • 每一个类中至少有一个构造方法（当没有明确定义构造方法时，编译器会自动生成一个无参的构造方法；但若定义了构造方法则不会生成无参构造方法；构造方法支持重载）

static关键字

  • 修饰属性
    同一个类的不同对象共用一个静态属性。在访问static修饰的属性时，访问方法为类名.属性
class TestDemo{
    public int x;  
    public static int y;  //y被static修饰，属于类本身，只有一份
}
public class Test {
    public static void main(String[] args) {
        TestDemo td1 = new TestDemo();
        td1.x++;   //x没有显式定义，默认为0，x++后，x=1
        TestDemo.y++;  //y=1
        System.out.println(td1.x);
        System.out.println(TestDemo.y);
        System.out.println("===========");
        TestDemo td2 = new TestDemo();
        td2.x++; 
        TestDemo.y++; //y被static修饰，因此所有类共享 此时y = 1+1;
        System.out.println(td2.x);
        System.out.println(TestDemo.y);
    }
}

输出结果：
输出结果
修饰方法
使用static修饰的方法称为静态方法。

  • 静态方法属于类，不属于对象
  • 可以直接调用静态方法，不用实例化
  • 静态方法可以访问静态成员变量，并对静态成员变量赋值
class TestDemo{
    public int x ;
    public static int y ; //默认y初始值为0
    public static void func(){
        y = 100; //定义静态方法对静态变量赋值，y=100
    }
}
public class Test {
    public static void main(String[] args) {
        TestDemo.func();
        System.out.println(TestDemo.y);
    }
}

封装

private实现封装

public和private都表示成员属性访问权限

  • public修饰的成员变量和方法可以直接被类的调用者使用
  • private修饰的成员变量和方法不可以被调用者使用，需要使用getter/setter方法获取或使用private属性

getter/setter方法

public class Student {
    private String name;
    private  int age;
    //设置学生姓名
    public void setName(String name){   
        this.name = name; //this引用表示调用该方法的对象（this表示当前对象的引用）
    }
    //获取学生姓名
    public String getName(){
        return name;
    }

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

    public static void main(String[] args) {
        Student student = new Student();
        student.setName("就这");
        student.setAge(3);
        String sName = student.getName();
        int sAge = student.getAge();
        System.out.println(sName);
        System.out.println(sAge);
    }
}

this关键字

this表示当前对象的引用，通过借助this可以访问对象的属性和方法

public class Teacher {
    private String name;
    private String sex;
    private int age;

    public Teacher(){
        this("啾咪","女",3); //this调用构造函数，必须显式放在第一行
    }

    //构造函数重载
    public Teacher(String name,String sex,int age){
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public void show(){
        System.out.println("name:"+ name+"  sex:"+sex+"  age:"+age);
    }
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        teacher.show();
    }
}

代码块

字段的初始化除了就地初始化和构造方法初始化外，还有代码块初始化。
使用{ }定义的代码称为代码块
代码块根据定义位置和关键字可以分为四种：普通代码块、构造代码块、静态代码块和同步代码块

  1. 普通代码块
    定义在方法中的代码块称为普通代码块

  2. 构造代码块
    定义在类中的代码块，不加修饰符

  3. 静态代码块
    使用static关键字定义的代码块。
    静态代码块不论生成多少对象，都只会执行一次，而且是最先执行的；
    静态代码块执行完成后，构造代码块执行，再是执行构造函数

toString方法

toString方法是将对象直接转换成字符串

public class Student {
    private String name;
    private  int age;

    public Student(String name ,int age){
        this.name = name;
        this.age = age;
    }
    public void show(){
        System.out.println("name:"+name+"  age:" +age);
    }

    //重写Object的toString方法
    @Override
    public String toString(){
        return "Person{"+
                "name：'"  + name + '\'' +
                " age:" + age  +
                "}";

    }
 
    public static void main(String[] args) {
        Student student = new Student("这就",3);
        student.show();
        System.out.println(student); //toString方法会在println时自动调用
    }
}

继承

在生活中，事物与事物之间有一定的关联，因此在创建类时类和类之间也会有一定的关联。就像生活中的猫和狗都有一些动物特有的属性和行为，因此在写代码时猫类和狗类可以继承动物类。

//定义动物类
class Animal {
    public String name;
    public void eat(String food){
        System.out.println(this.name +"正在吃"+food);
    }
    public Animal(String name){
        this.name = name;
    }
}
//定义猫类继承动物类
class Cat extends Animal{
    public Cat(String name){
        super(name); //使用super调用父类属性
    }
}
//定义狗类继承动物类
class Dog extends Animal{
    public Dog(String name){
        super(name);
    }
}

public class TestDemo{
    public static void main(String[] args) {
        Cat cat = new Cat("猫咪");
        cat.eat("猫粮");
        Dog dog = new Dog("旺柴");
        dog.eat("骨头");
    }
}

在java中一个子类只能继承一个父类
子类会继承父类所有 public 修饰的属性和方法
父类中使用 private 修饰的属性和方法，子类是无法访问的
子类的实例中，也包含着父类的实例，可以使用 super 关键字引用父类实例

多态

多态表示同一个行为有不同的表现形式。
比如动物的叫声这一行为，猫会发出“喵”的声音，狗会发出“汪汪”的声音，羊会发出“咩”的声音。同一个时间发生在不同的对象身上会有不同的行为产生，叫多态

package first;

class Animal {
    public void voice(){
    }
}

class Cat extends Animal{
    @Override
    public void voice(){
        System.out.println("喵");
    }
}
class Dog extends Animal{ 
    @Override
    public void voice(){
        System.out.println("汪汪");
    }
}
class Sheep extends Animal{
    @Override
    public void voice(){
        System.out.println("咩");
    }
}

public class TestDemo{
    public static void main(String[] args) {
        Animal animal1 = new Cat();
        Animal animal2 = new Dog();
        Animal animal3 = new Sheep();
        animal1.voice();
        animal2.voice();
        animal3.voice();
    }
}

输出结果：
在这里插入图片描述

本文地址：https://blog.csdn.net/weixin_44170482/article/details/107363279

您可能感兴趣的文章:

如对本文有疑问， 点击进行留言回复！！

相关文章:

验证码：
最近更新的文章
大家感兴趣的文章
移动技术网