面向对象总结

最新推荐文章于 2024-07-23 21:45:09 发布

ZJL7173

最新推荐文章于 2024-07-23 21:45:09 发布

阅读量59

点赞数

文章标签： java

本文链接：https://blog.csdn.net/ZJL7173/article/details/133928781

版权

三大特征：

封装继承多态

类与对象：

类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)

面向对象的编程思想力图在程序中对事物的描述与该事物在现实中的形态保持一致。为了做到这一点，面向对象的思想中提出两个概念，即类和对象。其中，类是对某一类事物的抽象描述，而对象用于表示现实中该类事物的个体。

如何创建对象：使用对象必须依赖于类，没有类就没有对象

格式：类名对象名 = new 类名();

格式说明

类名：要创建对象的类型，实例化就是创建对象的另外一种说法，比如 Scanner

对象名：合法的标识符

= ：将对象在堆内存中申请的地址赋值给对象名称储存 new：在堆内存中开辟空间类名：和前面保持一致

()：表示一个方法，这个方法叫做构造方法(用于创建对象的方法)

对象的使用

调用属性对象名.属性名= 值(赋值操作) 对象名.属性名;(访问属性中的值)

调用方法对象名.方法名(实际参数)

// 创建一个 人 的类
class Person {
    //属性（字段、成员变量）
    String name; //姓名
    int age;    //年龄，此处不初始化不会报错

    //定义 人 的行为
    public void eat() {
        System.out.println(name + "正在吃饭");
    }

    public void sleep() {
        System.out.println(name + "正在睡觉");
    }
}
public class ClassName {
    public static void main(String[] args) {
        //使用 new 实例化一个 Person类 的 对象
        Person person = new Person();
        //可以通过 . 访问对象中的成员变量
        person.name = "YKH";
        person.eat();
    }
}

局部变量和成员变量区别

区别一：定义的位置不同

定义在类中的变量是成员变量

定义在方法中或者{}语句里面的变量是局部变量

区别二：在内存中的位置不同

成员变量存储在对内存的对象中

局部变量存储在栈内存的方法中

区别三：生命周期不同

成员变量随着对象的出现而出现在堆中，随着对象的消失而从堆中消失

局部变量随着方法的运行而出现在栈中，随着方法的弹栈而消失

区别四：初始化不同

成员变量因为在堆内存中，所有默认的初始化值

局部变量没有默认的初始化值，必须手动的给其赋

静态方法和成员变量可以通过类名直接调用

package 表示 “包” : 类所在的包

import 表示 “引入” ：引入类中需要的类（PS ： import 只能导入一个具体的类不能导入一个具体的包，包名必须是小写字母组成

static关键字的用途

方便在没有创建对象的情况下进行调用(方法/变量)。

被static关键字修饰的方法或者变量. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问。
static关键字修饰的方法或者变量，不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。
（static 修饰的变量或者方法是一开始就和类一起加载的，所以可以直接通过类名去访问，不用实例化）
static可以用来修饰类的成员方法、类的成员变量，其修饰的成员方法和变量不依赖于对象

public class test02 {
    public static void main(String[] args) {
        //对于静态修饰的类中的成员变量可以直接通过 类名.成员名 访问
        Person.age = 20;
        // Person 类中的sleep方法和name变量 未加static ，需要先实例化（new）一个对象才能使用
        Person person = new Person();
        person.name = "路飞";
        person.sleep();

        //Person 类中的eat 方法加了static 可以直接用类名进行访问使用
        Person.eat();
    }
}
class Person {
    String name;
    static  int age;
    public static void eat() {
        System.out.println( "正在吃饭");
    }
    public void sleep() {
        System.out.println(name+"正在睡觉");
    }
}

静态方法没有隐藏的this引用参数，因此不能在静态方法中访问任何非静态成员变量，这是很不方便的，需要通过实例化对象，通过对象来访问成员和方法。
静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用
静态方法是无法被重写的，这就无法形成多态，以及接口的使用。

静态成员变量的初始化的分类

就地初始化：

就地初始化指的是：在定义时直接给出初始值。

静态代码块初始化

静态代码块：

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。

匿名代码块：

主要用于初始化普通的成员变量

public class Demo01 {
    //匿名代码块
    {
        System.out.println("执行匿名代码块");
    }
    //静态代码块
    static {
        System.out.println("执行静态代码块");
    }
    //构造方法
    public  Demo01() {
        System.out.println( "执行构造方法");
    }

    public static void main(String[] args) {
        Demo01 demo1 = new Demo01();
        System.out.println("=========");
        //第二次 静态方法不执行
        Demo01 demo2 = new Demo01();
    }
}

执行顺序：

1、静态代码块：和类一起加载，所以第一个执行且静态代码块只执行一次

2、匿名代码块：和对象一起加载，所以第二个执行

3、构造方法：对象执行时，所以最后一个执行

new关键字

使用new关键字创建对象的时候，除了给创建的对象分配内存空间外，还会进行默认的初始化，以及对类中的构造器调用。

构造器

特点：

1. 构造器的方法名必须和类名相同

2. 没有返回类型

作用：

1 . 使用 new 关键字，必须要有构造器。

2. 用来初始化值

所有类中默认会存在一个无参构造器

在定义一个有参构造后，默认的无参构造会失效，如果要使用无参构造。此时应该显示的 自定义一个无参构造，否则会报错。

public class Person {

    String name;
    int age;
    public void eat() {
        System.out.println(this.name + "正在吃饭");
    }
    public void sleep() {
        System.out.println(name + "正在睡觉");
    }
    //自定义的有参构造器
    public Person(String name) {
        this.name = name;
    }
    // 显示的 自定义的无参构造器
    public Person() {
    }
}

封装

隐藏事物的实现细节，对外提供一个公共的访问方式

作用

1、提高程序的安全性，保护数据

2、隐藏代码的实现细节（封装后会隐藏代码实现功能的细节）

3、统一接口（通过get set 统一接口）

4、增强系统的可维护性

关键字：

private 私有的私密的

private能够修饰的内容：成员变量

成员方法

修饰构造方法

修饰内部类

Getter和Setter

当属性被私有化之后，外界不能直接访问了，所以需要提供公共的访问方式，让外界可以访问

属性赋值的方式

private 数据类型变量名；

public void set+首字母大写的变量名(数据类型参数名称){ 变量名 = 参数名称 }

属性获取的方式

public 返回值类型 get+首字母大写的变量名{ return 变量名 ; }

public class Person {

    private String name;
    private int age;
    private int high;

   //设置 属性name的 set方法，用来对该对象中的 name属性 存放数据
    public void setName(String s) {
        this.name = s;
    }
    
    //设置 属性name的 get方法，用来取出 该对象中的 name属性 
    public String getName() {
        return this.name;
    }
}
 public static void main(String[] args) {
        // 先 new 一个对象
        Person per = new Person();
     	通过 对象 per 中的set ,get 方法 存放和读取数据
        per.setName("大白");
        System.out.println(per.getName());
    }

this关键字

为什么要有this关键字

当局部变量与成员变量重名时，在方法中由于就近原则，会出现局部变量隐藏成员变量的情况
this关键字的含义
this关键字其实就是指代的当前关键字，简单来说，谁调用this就指的谁

语法

调用成员变量：this.成员变量
调用成员方法：this.成员方法

public String name;
//当调用show方法，会输出局部变量name,成员变量会被隐藏
public void show(String name) {
    System.out.println(name);
}

public String name;
//当调用show方法，会输出成员变量name
public void show(String name) {
    System.out.println(this.name);
}

继承

继承的定义

继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。继承是类与类之间的关系，是一个很简单很直观的概念，与现实世界中的继承（例如儿子继承父亲财产）类似。继承可以理解为一个类从另一个类获取方法和属性的过程。如果类B继承于类A，那么B就拥有A的方法和属性。

继承的实现

继承使用 extends 关键字

继承的限制

Java之中使用extends关键字实现继承
Java之中只允许多层继承，不允许多重继承，Java存在单继承局限
Java之中，子类可以继承父类除private以为的所有的成员
构造方法不能被继承
子类使用父类成员时，使用super关键字，使用本类成员使用this关键字

继承的好处

提高了代码的复用性（多个类相同的成员可以放到同一个类中）

提高了代码的维护性（如果方法的代码需要修改，修改一处即可）

class Animal {
    String run = "跑";
    String eat = "吃";
    public void sleep() {
        System.out.println("睡觉");
    }
}
class Dog extends Animal {
 
    public void wangWang() {
        System.out.println("汪汪叫");
    }
}
 
class Cat extends Animal {
 
    public void miaoMiao() {
        System.out.println("喵喵叫");
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();
        //dog类中并没有定义任何成员变量,run和eat是从父类Animal中继承过来的。
        System.out.println(dog.run);
        System.out.println(dog.eat);
        dog.wangWang();
        //dog类中并没有定义任何成员变量,run和eat是从父类Animal中继承过来的。
        System.out.println(cat.run);
        System.out.println(cat.eat);
        cat.miaoMiao();
    }
}

super关键字

Super关键字，可以用来子类调用父类的成员用，它包括调用父类的public、protected修饰的变量方法。

注意事项：

调用父类的方法：super.父类的方法
同时super也可以调用父类的构造方法，但是父类中构造方法用private修饰时，不能有子类去继承
子类可以没有构造方法，他会自动调用父类的构造方法
在子类中可以调用父类的构造方法，super必须放在子类构造方法的首句

super和this对比

1、this( )与super( )区别

	this（）	super（）
作用	调用本类的其它构造方法；从而达到本类构造方法的代码可以复用的效果。与继承无关。	调用父类的指定构造方法；从而达到使用指定的父类构造方法构造子类中的父类对象部分。与继承有关。
位置	构造方法的第一句；与super()互斥。	构造方法的第一句；与this()互斥。
默认	没有	有，就是无参的super()

2.this.和super.的区别

作用不同

this.：书写在一个类的内部代码块中，用来调用当前对象的属性和行为

含义：当前对象

super. ：书写在一个类的内部代码块中，用来调用当前对象从父类继承而来的属性或行为

含义：当前对象的父类部分

注意：super.也会受到访问修饰符的限制

总结：

1、this.能看到本类自己定义的，也能看到父类继承而来的（但受访问修饰符的限制）

2、super.只能看到从父类继承而来的（但受访问修饰符的限制）

3、通常只用this.

调用重写方法的时候super.【super.调用的是子类重写前的方法】【this.调用的是子类重写后的方法】

方法的重载(Overload)与重写(Override)

方法的重载：

一个类中有多个具有相同名称但参数不同的方法，则称为方法重载。如果只需要执行一个操作，具有相同的方法名称将增加程序的可读性。

方法的重写：

方法重写基于继承，子类继承父类，子类可以调用父类的方法，同时子类也可以重写父类中的方法，来实现和父类中不同的业务处理逻辑。重写要求子类中方法与父类中的方法名称相同，参数相同，参数类型相同。当子类调用该方法时，基类中的方法则被覆盖。方法重写即：重写父类方法，同名也同参。

区别点	重载方法	重写方法
参数列表	必须修改	一定不能修改
返回类型	可以修改	一定不能修改
异常	可以修改	可以减少或删除，一定不能抛出新的或者更广的异常
访问	可以修改	一定不能做出更严格的限制（可以降低限制）

public class Human{
	
	public void speak() {
		System.out.println("人类可以说话！");
	}
}

public class Programmer extends Human{
		
		public void speak() {
			System.out.println("程序员可以说话！也可以使用计算机说话");
		}
}

		Human human=new Human();
		human.speak();
		Programmer programmer=new Programmer();
		programmer.speak();

final关键字

Java语言中，final关键字有多种用途，其主题都表示“不可变”，但背后的具体内容并不一样。当final关键字用于修饰类时表示该类不允许被继承；当它用于修饰方法时表示该方法在继承该类的子类中不允许被重写。当final关键字用于修饰变量时表示该变量的值不可变；静态变量、实例成员变量、形式参数和局部变量都可以被final修饰。

final关键字修饰类

当用final关键字修饰一个类时，表明这个类不能被继承。也就是说，如果一个类你永远不会让他被继承，就可以用final进行修饰。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。

final关键字修饰方法

当用final关键字修饰一个方法时，表明这个方法不能被重写，但是这个方法可以被重载。也就是说我们使用final关键字修饰一个方法时，相当于给这个方法上了一把锁。

final关键字修饰变量

final修饰基本类型变量：因基本数据类型的值与真实的值是同一个，所以该变量的值不能改变，即不能重新赋值，是“编译时常量”(compile-time constant)
final修饰引用类型：因引用数据类型的值表示引用地址，真实的值为实际内容，所以该变量的引用地址不能改变，而引用地址里的存储内容可以变，是“运行时不变量”(runtime immutable variable)

equals和 ==

boolean equals(Object obj) 比较两个对象是否相等

== 可以比较任意数据类型基本数据引用数据类型

equals：只能比较引用数据类型

== 比较的基本数据类型的时候比较的是数据的值,比较引用数据类型的值比较的是地址值 equals：比较引用数据类型的时候，重写之前比较的是地址值，重写之后比较的是对象的属性值

toString( )方法

作用是返回当前对象的字符串描述。

toString( )方法在Object中的默认实现是返回一个：类的限定名@对象的哈希值

注意：toString( )方法还有一个特点就是当我们对一个对象进行字符串操作的时候，会默认调用这个对象的toString方法，不用手工调用

多态

多态的概念

（1）多态是面向对象的一个重要特征，指同一类事物同时具有多种形态，即同一类事物，在不同时刻，代表的对象不一样，指的是对象的多种形态。

（2）多态就是同一个行为具有多个不同表现形式或形态的能力，指的就是行为的多态。

（3）多态就是同一个接口，使用不同的实例而执行不同操作

多态的作用

可以把不同的子类对象都当作父类来看，进而屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。也就是可以降低类型之间的强耦合关系，提高程序的可扩展性

多态的定义格式

普通格式：父类类型变量名=new 子类类型();

特殊格式: 方法名(父类形参子类实参) //了解下扩展内容

多态的存在的三个必要条件

继承
重写（实现）
父类引用指向子类对象：Parent p = new Child(); //父类做形参,子类做实参

多态的特点

多态中，编译看左边（静态绑定），运行看右边（动态绑定）

静态绑定：在编译阶段能够确定方法在内存什么位置的就叫静态绑定，当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译不通过；如果有，编译通过。

动态绑定：在运行阶段，父类对象类型在堆内存中创建的实际对象是子类对象，所以jvm会根据内存中真实的对象引用重新去给父类的方法表索引项赋值，这种通过程序运行过程动态创建对象方法表的定位方法的方式，一般称之为动态绑定。

多态的基础语法

向上转型：

当子类的对象赋值给一个父类的引用时，便是向上转型，多态本身就是向上转型的过程

使用格式：父类类型变量名= new 子类类型();

向下转型：

一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类的引用转换为子类引用，这个过程是向下转型。直接创建父类对象的无法使用向下转型;

使用格式：

子类类型变量名= (子类类型) 父类类型的变量

public class Animal {
    String name = "动物";
    int age = 10;
    public void sleep(){
        System.out.println("睡觉");
    }
    public void run(){
        System.out.println("跑步");
    }
    public void eat(){
        System.out.println("吃饭");
    }
    public void show(){
        System.out.println("hello, 你好");
    }
}

package org.example.poly_.details_;
 
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
 
    public void catchMouse() {//cat特有的方法，猫抓老鼠
        System.out.println("猫抓老鼠");
    }
}

public static void main(String[] args) {
        //向上转型 ： 父类的引用指向了子类的对象
        //语法 ： 父类类型 引用名 = new 子类类型();
        Animal animal = new Cat();
        animal.eat();
        animal.run();
        animal.sleep();
        animal.show();
        //向下转型
        //编译类型Cat, 运行类型Cat
        Cat cat = (Cat) animal;
        cat.catchMouse();//猫抓老鼠，不转型调用不了。
    }

向上转型和向下转型
在Java中允许两种这样的语法出现，一种是向上转型（Upcasting）,一种是向下转型（Downcasting），向上转型是指子类型转换为父类型，可理解为自动类型转换，向下转型是指父类型转换为子类型，又可以理解为强制类型转换。调用子类特有方法时必须进行向下转型。

注意：无论是向上转型还是向下转型，两种类型之间必须是继承关系，没有继承关系编译器会报错！！！

instanceof 关键字

可以通过instanceof关键字来判断某个对象是否属于某种数据类型;

使用格式：

boolean b= 对象(new ) instanceof 数据类型;

抽象类

抽象的定义：

我们在日常生活中，经常通过总结一些事物的共性来对事物进行分类，这种共性可能是一些相同的属性，也可能是一些相同的动作。通过总结，我们能够清晰的划分事物的分类。同样，在程序设计中，我们将拥有相同行为，但是不同表现形式的行为进行抽象，描绘出的方法，就称之为抽象方法，那么包含抽象方法的类，就是抽象类。

抽象方法：

所谓的抽象方法，是指具有相同行为，但是不同分类的行为又有不同表现形式的方法，那么我们声明了方法，但又不需要具体实现方法内容的方法，称之为抽象方法。从语法结构上讲，就是通过abstract关键字来修饰的方法。

public abstract void jiao();

public abstract class Dog {
	public abstract void jiao();
}

public abstract class Dog {
	public abstract void jiao();
	public void pao() {
		System.out.println("狗可以跑！");
	}
}

抽象类的使用：

我们可以这样理解，抽象方法在抽象类中，那么当使用抽象类的对象是，是无法直接使用方法的，所以我们只能通过继承的方式具体化一个抽象类的具体形象，就好像我们在欣赏一幅抽象派的画一样，我们需要在脑海中具象化一个具体的内容，来赋予这幅画的真实含义。我们的抽象类也是一样，需要具体化一个内容来描述抽象类。

抽象的注意事项：

1.抽象类和抽象方法必须使用abstract关键字修饰
2.抽象类中不一定有抽象方法,但是有抽象方法的一定在抽象类中
3.抽象类不能实例化 (实例 = 对象) [也就是不能创建对象],如果非要实例化,可以通过多态的形式创建,也就是父类引用指向子类对象
4.抽象类的子类必须重写父类(抽象类)中所有的抽象方法或将自己也变成一个抽象类

//抽象类--狗
public abstract class Dog {
	public abstract void jiao();
}
//狗类的继承类---二哈
public abstract class ErHa extends Dog {
	public abstract void jiao()；
}
//灰色二哈
public class HuiErHa extends ErHa {
 
	@Override
	public void jiao() {
		System.out.println("灰色二哈边叫边拆家边把自己弄脏");
	}
 
}

接口

接口的定义：

接口（英文：Interface），在Java中是一个抽象类型，属于引用数据类型，是抽象方法的集合，接口通常以interface来声明。
个人的理解，接口是一个特殊的类，也是一种特殊的数据类型，它比抽象类更加抽象，是一种纯概念的定义。通常使用接口来定义类所需要的行为（方法）。

定义接口：

Java中使用interface关键字定义接口，定义方式与类相同
[访问修饰符] interface 接口名{}

//动物接口
public interface IAnimal {
 
}
public interface IDog extends IAnimal{
	
 
	//狗类有叫的行为
	public void jiao();
	//狗类有跑的行为
	public void pao();
	//狗类有吃的行为
	public void eat();
}

接口的特点：

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。所以接口中只能存在抽象方法（JDK1.8前）。除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。

接口与类的关系：

接口与接口之间的关系：接口与接口之间可以通过继承来实现父子接口的关系。接口继承接口使用extends关键字，并且接口可以多继承接口。

//动物接口
public interface IAnimal {
 
}
public interface IDog extends IAnimal{
	
 
	//狗类有叫的行为
	public void jiao();
	//狗类有跑的行为
	public void pao();
	//狗类有吃的行为
	public void eat();
}

接口与类之间的关系：类可以实现接口，并且在实现时要实现接口中的所有抽象方法，如果接口继承了其他接口，实现类也要实现父类接口中的所有抽象方法。实现类可以实现多个接口，从而实现多继承。

//动物接口
public interface IAnimal {
	//动物有睡觉的行为
	public void sleep();
}
//定义狗类接口
public interface IDog extends IAnimal{
	//狗类有叫的行为
	public void jiao();
	//狗类有跑的行为
	public void pao();
	//狗类有吃的行为
	public void eat();
}
//金毛作为狗类的一员
public class JinMao implements IDog{
	@Override
	public void jiao() {
		
	}
	@Override
	public void pao() {
		
	}
	@Override
	public void eat() {
		
	}
	@Override
	public void sleep() {
		
	}
}

接口类型的使用：在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。依据多态的特性，我们可以定义接口类型的变量，实例化实现类对象。

抽象类与接口的区别：

（1）抽象类和接口都用于抽象化具体对象的，都不能直接实例化，但是两者的侧重点不同：抽象类主要用来抽象类型，表示这个对象是什么；接口主要用来抽象功能，表示这个对象能做什么；

（2）接口可以看成抽象类的变体，所有方法都是抽象的，因此接口只能做方法的声明，不能有方法的实现；而抽象类可以有默认的方法实现，既可以做方法的声明，也可以做方法的实现；

如果往抽象类中添加新的方法，可以给他提供默认的实现，因此可以不需要改变子类的代码；如果往接口中添加方法，那么必须改变实现该接口的类（JDK8 之后，接口也可以有默认的实现）

（3）接口可以继承多个接口，抽象类不可以多继承类，但可以单继承类或多实现接口。

（4）抽象方法和接口函数都不能使用static修饰。抽象方法的访问修饰符可以是public、protected和default，不能是private；接口的默认访问修饰符为public，不能使用其他修饰符。

（5）接口的变量只能是不可变常量，默认修饰符都是public static final；但是抽象类的变量可以是普通变量

（6）抽象类可以有构造器，接口不能有构造器。

（7）接口实现类必须实现接口中的所有声明的方法，但抽象类的子类可以部分实现父类的抽象方法，但如果子类不能全部实现抽象方法，那么该子类只能是抽象类；

（8）与正常Java类的相比，抽象类除了不能实例化之外，和正常Java类没有任何区别，但接口和正常Java类是完全不同的类型。

（9）抽象类和接口是Java语言中两种不同的抽象概念，他们的存在对多态提供了非常好的支持，虽然他们之间存在很大的相似性。抽象类的功能远远超过接口，但是定义抽象类的代价比较高。因为每个类只能继承一个类。因此，在这个抽象类中，你必须编写出其子类的所有共性。虽然接口在功能上会弱化很多，但是他只是针对一组动作的描述，而且可以在一个类中同时实现多个接口，因此在设计阶段会降低难度。

分别在哪些地方使用抽象类和接口？

（1）当你关注一个事物的本质时，使用抽象类；当你关注一组操作的时候，使用接口。

（2）如果拥有一些方法并且想让他们中有一些默认的是实现，那么可以使用抽象类。

（3）如果想实现多重继承，那必须使用接口。由于Java不支持多继承，子类不能够继承多类，但是可以实现多个接口。

（4）如果基本功能在不断改变，那么就需要使用抽象类，如果不断改变基本功能并且使用接口，那么就需要改变所有实现了该接口的类。

类的有参与无参方法

在编写一个类时没有添加无参构造方法，那么编译器会自动添加无参构造方法；（如果自己手动添加构造函数，无论有参数或是没参数，默认构造函数都将无效）
编写时添加有参构造方法而未添加无参构造方法，那么编译器只认有参构造方法而不会默认添加无参构造方法。
如果需要使用无参构造方法，一定要在类里面添加。

有参构造方法

在之前我们要为一个对象赋值，先要创建好对象之后然后“对象名.属性名”或者调用属性的setter为属性赋值。但是在很多时候觉得这样做很麻烦，最好的做法是在创建对象的时候完成属性的初始化操作，此时需要使用到有参数构造方法方能完成该功能(有人把构造方法叫做构造器)。

package com.hn.yuan.common;

/**
 * 有参构造方法
 */
public class Student {

    private String name;

    private String age;

    public Student(String name, String age) {
        this.name = name;
        this.age = age;
    }

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

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

    public String getName() {
        return name;
    }

    public String getAge() {
        return age;
    }

    public void start(){
        System.out.println("我叫"+name+"今年"+age+"岁了");
    }
}

package com.hn.yuan.common;

public class Test {

    public static void main(String[] args) {
        //使用有参数的构造方法实例化对象
        Student st=new Student("张三","18");
        st.start();
    }
}

无参构造方法

作用：无参构造方法一般是用来初始化：如为变量赋初值、初始化对象等。
在之前我们使用过方法，在调用的方法的是时候需要在方法名称之后加.上小括号,括号里面可以传递实参,那么我们在创建一个对象的时候使用的是“new类名()”的方式去实现，其实上这也是一种方法，但是这个方法我们没有明确的去定义，那为什么可以调用呢?

package com.hn.yuan.common;

/**
 * 无参构造方法
 */
public class Student {

    private String name;

    private String age;

    //含有 无参构造方法
    public Student() {
        System.out.println("调用了无参构造方法");
    }


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

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

    public String getName() {
        return name;
    }

    public String getAge() {
        return age;
    }

    public void start(){
        System.out.println("我叫"+name+"今年"+age+"岁了");
    }
}

package com.hn.yuan.common;

public class Test {

    public static void main(String[] args) {
        //使用有参数的构造方法实例化对象
        Student st=new Student();
        System.out.println(st);
    }
}

使用构造器时

1、构造器必须与类同名（如果一个源文件中有多个类，那么构造器必须与公共类同名）
2、每个类可以有一个以上的构造器
3、构造器可以有0个、1个或1个以上的参数
4、构造器没有返回值
5、构造器总是伴随着new操作一起调用
父类有有参构造方法有两种情况，一只有有参构造，那么子类的构造方法中的第一句必须调用父类的有参构造方法，也就是“super(…);”，…为你传入的参数如：

ZJL7173

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
面向对象总结

定义在类中的变量是成员变量定义在方法中或者{}语句里面的变量是局部变量继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。继承是类与类之间的关系，是一个很简单很直观的概念，与现实世界中的继承（例如儿子继承父亲财产）类似。继承可以理解为一个类从另一个类获取方法和属性的过程。如果类B继承于类A，那么B就拥有A的方法和属性。1、this.能看到本类自己定义的，也能看到父类继承而来的（但受访问修饰符的限制）
复制链接

扫一扫