Java学习_day07_类的构造器&代码块&继承&封装&多态

文章目录

  • 构造器
    • 格式
    • 注意点
    • 使用
  • 代码块
    • 格式
    • 注意
  • 继承
    • 格式
    • 注意点
  • 封装
      • 声明包
      • 导包
      • 注意点
    • 访问修饰符
  • 多态
    • 格式
    • 注意点
    • 代码演示

构造器

Java中每个类都至少有一个构造器,当程序员没有明确编写构造器时,Java编译器会自动为类添加一个无参的构造器。构造器通常用来完成对类的初始化。

格式

构造器的定义格式和方法类似,不同点在于构造器的名称必须为类名,且构造器没有返回值类型。

修饰符  class  类名{
	修饰符  类名(参数列表) throws 异常列表{
		语句;
	}
}

注意点

  • 一个类中可以有多个构造器,多个构造器之间构成重载(名称相同,但是参数列表不同)
  • 修饰符只能是public,protected,缺省和private

使用

构造器主要用来生成类的实例对象,通过 new 构造器(…)完成某个类的实例化。
当使用有参构造器时,通常使用和成员变量相同名称的形参,此时为了区分需要引入this关键字,用来表示对象。

public class ReactangleTest{
	public static void main(String[] args){
		Rectangle rect1 = new Rectangle();
		Rectangle rect2 = new Rectangle(12, 3);
	}
}
class Rectangle{
	int length;
	int width;
	public Rectangle(){}
	public Rectangle(int length,int width){
		this.length = length;
		this.width = width;
	}
}

代码块

代码块是指在类中,构造器,方法之外的{}包围的语句部分,用来初始化类。根据是否有static修饰符分为静态代码块和非静态代码块。

格式

[修饰符] 类名{
	[修饰符] 变量;
	// 代码块
	[static] {
		代码块语句;
	}
	// 构造器
	[修饰符] 类名([参数列表]) [throws 异常列表]{
		构造器语句;
	};
	// 方法
	[修饰符] 返回值类型 方法名(参数列表) [throws 异常列表]{
		方法体语句;
	}
}

注意

  • 静态代码块比非静态代码块早执行
  • 类各个组成部分的执行顺序为:静态代码块-> 变量的显式赋值语句 -> 非静态代码块 -> 构造器
  • 静态代码块只执行一次,非静态代码块每创建一个对象就执行一次
  • 静态代码块中只能访问类变量和静态方法
  • 非静态代码块可以访问所有成员。
  • 涉及super时,父类先执行(子类的静态代码块比父类的非静态代码块先执行)。

演示代码:

public class TestClass {
    public static void main(String[] args) {
        Square square1 = new Square(12);
        System.out.println("******************************");
        Square square2 = new Square(12);

    }
}
class Shape{
    static {
        System.out.println("Shape静态代码块执行了");
    }
    {
        System.out.println("Shape非静态代码块执行了");
    }
    public Shape(){
        System.out.println("Shape无参构造器执行了");
    }
}

class Square extends Shape{
    int length;

    {
        System.out.println("Square 非静态代码块执行了");
    }
    static{
        System.out.println("Square 静态代码块执行了");
    }
    public Square(int length){
        super();
        this.length = length;
        System.out.println("Square 有参构造器执行了");
    }

}

Java学习_day07_类的构造器&代码块&继承&封装&多态_第1张图片

继承

Java中为了实现代码复用,提出继承的概念。既一个类(子类)可以继承另外一个类(父类),这样子类就具有了父类的属性和方法。

格式

[修饰符] class 子类 extends 父类 {

}

注意点

  • 创建子类时,Java默认调用父类的无参构造器,如果父类没有无参构造器,或者子类需要使用特定的父类构造器时,需要在子类构造器的第一行声明使用哪个父类构造器。
  • 当父类的某些方法执行逻辑不满足子类要求时,子类可以重写这个方法(方法名不变,形参列表不变,返回值类型等于或小于父类的,访问修饰符大于等于父类的,异常的类型等于或小于父类的,static,final修饰的方法不可被重写)
  • 当子类具有和父类相同的成员变量时,需要使用this和super来区分(默认用子类的)
  • Java是单继承的,既每个类只能有一个父类,一个父类可以有n个子类
  • java.lang.Object是所有类的父类

代码演示:

class Person{
    String id;  // 身份证号
    String name;
    int age;

    public Person(){}
    public Person(String id,String name,int age){
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public void detail(){
        System.out.println(
                "我是: " + name + ", 今年: " + age + ", 身份证号为: " + id
        );
    }
}

class Student extends Person{
    String id; // 学号
    public Student(){
        super();
    }
    public Student(String id, String name, int age, String stud){
        super(id,name,age);
        this.id = stud;
    }
//  重写方法
    public void detail(){
        super.detail();
        System.out.println("我的学号为: " + this.id);
    }
}

封装

封装就是将代码一类的形式提供,并且针对每个类和类的成员提供访问权限,实现代码的封闭和管理。

包主要用来解决类重名的问题。包本质上就是不同的文件夹。

声明包

在java文件的开头通过 package 包名声明包,表示文件中创建的类都隶属于这个包。

导包

通过import 包名.类名将其他包中的类导入。
导入包中多个类时,通过import 包名.*将包下所有的类导入。

注意点

  • 同一个包中只能有唯一的类名
  • 当一个方法中使用到两个同名的类时,需要使用类的全称(包.类名)来区别
  • 多包时遵循倒置域名的规则,全部小写

访问修饰符

Java为类和类成员设置了不同的访问修饰符,根据不同的访问权限,有如下几个访问权限:public -> protected -> 缺失 -> private
各个修饰符的权限如下:

访问修饰符 类内部 同一个包中 不同包的子类 任何位置 说明
public 权限最高,可以在任何地方访问
protected 此高权限,不能在不同包的非子类中访问
省缺 次低权限,只能在包和类内部访问
private 只能在类内部访问
访问修饰符 属性 构造器 方法
public
protected
省缺
private

通常将属性设置为private,而外部通过setter和getter,对类的属性进行设置和访问。

多态

多态就是同一个对象,当指向不同的实例对象时具有不同的行为。
此处涉及两个知识点:

  1. 类的继承
  2. 子类重载父类的方法

格式

父类 变量名 = new 子类();
变量名.方法();

注意点

  • 多态只发生在有重载方法的子类上(属性不存在多态)。
  • 当需要使用子类额外的属性或者方法时,需要将变量进行向下转移
  • 为了安全转移,此处使用instanceof关键字来判断对象是否为某个类的实例对象

代码演示

public class TestClass {
    public static void main(String[] args) {
        Animal animal = new Dog(1,"Beta","yellow");
        animal.eat();
        if(animal instanceof Dog){
            Dog dog = (Dog)animal;
            dog.bite();
        }
        System.out.println("**************************************");
        Animal animal1 = new Animal(2,"Bear");
        animal1.eat();
    }
}

class Animal{
    int age;
    String name;
    public Animal(){}
    public Animal(int age,String name){
        this.age = age;
        this.name = name;
    }
    public void eat(){
        System.out.println("Animal在吃事物");
    }
}

class Dog extends Animal{
    String color;
    public Dog(){
        super();
    }
    public Dog(int age,String name,String color){
        super(age,name);
        this.color = color;
    }

    public void eat(){
        System.out.println("狗狗啃骨");
    }

    public void bite(){
        System.out.println("小狗汪汪叫");
    }
}

Java学习_day07_类的构造器&代码块&继承&封装&多态_第2张图片

你可能感兴趣的:(Java,Java入门,java,学习)