构造器+块+new关键字+内存图+封装

一.构造器（构造方法|构造函数）

1.定义：构造器是一个特殊的方法

2.作用：为对象初始化信息

3.特点：

• ​构造器的方法名要和类名相同
• 构造器不需要定义返回值和void
• ​如果构造器中出现return，return的作用只是提结束构造器

4.书写格式：

修饰符 类名（参数列表）{

方法体；

}

​
public class Block {
    public String name;
    public static int a;
//构造器（空构造）
    public Block() {
        System.out.println("构造器");
    }
    //方法
    public void block() {
        System.out.println("O(∩_∩)O哈哈~");
    }
    public static void main(String[] args) {
        Block b=new Block();
        System.out.println(a);
        b.block();
    }
}
​

5.注意

• 如果没有定义构造器，编译器会自动给你提供一个空构造（参数列表为空的构造器）
• 如果你定义了构造器编译器将不会提供任何构造器
• 构造器也是一个方法，拥有方法重载的特性可以构成方法的重载
• 构造器不能和abstract,static,final修饰符一起使用
• 构造器不是创建对象使用的,是为对象初始化信息用的，知道对象的初始值可以运用带带参构造为对象附上初始值

6.继承中的构造方法:

• 子类的构造的过程中必须调用其父类的构造方法
• 子类可以在自己的构造方法中使用super 调用父类的构造方法，但super必须写子类构造方法的第一行

public class Block {
    public String name;
    public static int a;
//带参构造器
    public Block(int b) {
        a=b;
        System.out.println("构造器");
    }
    //方法
    public void block() {
        System.out.println("O(∩_∩)O哈哈~");
    }
    public static void main(String[] args) {
        Block b=new Block(5);//初始化信息
        System.out.println(a);
        b.block();
    }
}
​

二.块

1.定义：block块{}-->作用域

2.用法：

• 放在方法中，称为局部代码块或普通语句块-->跟随方法或方法被调用时执行
• 放在类中方法外，称之为构造块-->创建对象时执行
• 放在类中方法外，但在{}前加了static修饰符，称之为静态块-->类加载时执行

3.注意：

• 在程序编译时构造块会比构造器先执行,如果存在多个构造块从上倒下一次执行
• 静态块的内容只会执行一次，如果存在多个静态块从上倒下一次执行

4.运行先后顺序：静态块-->main-->构造块->构造器

public class Block {
    public String name;
    public static int a;
//构造器
    public Block(int b) {
        a=b;
        System.out.println("构造器");
    }
//构造块
    {
        System.out.println("构造块");
    }
//静态块
    static {
        System.out.println("静态块");
    }
    //方法
    public void block() {
        System.out.println("O(∩_∩)O哈哈~");
    }
    public static void main(String[] args) {
        Block b=new Block(5);
        System.out.println(a);
        b.block();
    }
}
​

 

三.关键字

​ 1.new

作用：

• 在堆中为对象开辟一块空间，成员变量跟随对象进入堆内存并附默认值
• 调用构造器，让对象初始化信息
• 将地址返回给引用

 

​ 2.this

定义：表示当前创建的对象，存储当前对象的地址

作用：

• 在构造器中的首行调用本垒中的其他构造器
• 区分成员变量和构造器中局部变量的同名现象

public class Block {
    public String name;
    public static int a;
//构造器
public Block() {
        System.out.println("空构造");
    }
//构造器
    public Block(String name) {
        this（）；//调用空构造
        this.name=name;
        System.out.println("构造器");
    }
    //方法
    public void block() {
        System.out.println("O(∩_∩)O哈哈~");
    }
    public static void main(String[] args) {
        Block b=new Block("二花");
        System.out.println(b.name);
        b.block();
    }
}
​

 

 

​ 3.super

作用：

• 用来区分父类中的成员变量与子类中构造器同名现象
• 在子类中的构造器里调用父类的构造器

public class Super{
    public static void main(String[] args) {
        Son son=new Son("小米");
        Fu f=new Fu("爸爸");
    }
}
class Fu{
    public String name;
    public Fu() {
        
    }
    public Fu(String name) {
        this.name=name;
        System.out.println(name+"在打儿子屁股");
    }
}
class Son extends Fu{
    public Son() {
        
    }
    public  Son(String name) {
        super.name=name;
        System.out.println("小米被"+name+"打屁股");
    }
}

4.static(静态的)

1.定义：静态的内容是属于类的，成员是属于对象的

2.作用：

• 修饰变量：静态变量（static是成员修饰符，只能修饰成员不能修饰局部 ）
• 修饰方法：静态方法

3.注意：

• 1.静态内容是属于类的,在类第一次加载完成之后初始化一次,静态内容是共享的会在静态区中存在 
• 静态方法中,可以直接使用静态的内容,不可以直接使用非静态的内容,但是可以通过对象使用
• 非静态的内容中,可以直接使用静态的内容,可以直接使用非静态的

​ 5.final（最终的）

1.作用：

• 修饰类：表示该类不能被继承 （太监类）
• 修饰方法：表示该方法不能被重写
• 修饰属性：表示常量，值一旦确定不可改变。

6.private（私有的）

定义：成员修饰符,只能修饰成员,不能修饰局部

特征：

• 私有的内容,只能在本类中使用,外部类无法使用
• 私有的属性,需要配合设置器和访问器一起使用（成套使用）
• 设置器setter和访问器getter 是一个方法,这个方法公共的访问方式

public class Demo1{
    
    public static void main(String[] args) {
        Dog d = new Dog(10086);
        d.name="二哈";
        d.play();
    }
}
class animal{
    public String name;
    public String type;
    private int id;
}
​
class Dog extends animal{
    private int id;
    public Dog(int id){
        this.id=id;
    }
    public void setId(int id) {//设置器
        this.id=id;
    }
    public int getId(int id) {//访问器
        return id;
    }
    public void play() {
        System.out.println(name+"的编号是"+id);
    }
}

四.权限修饰符

修饰符	同类	同包	子类	任何地方
protected	Yes	Yes	Yes
public	Yes	Yes	Yes	Yes
default	Yes	Yes
private	Yes

注意：

1.对于 class 的权限修饰只能用 public 和 default。

2.public 类可以在任意地方访问 default 类只可以在同包被访问

3.属性尽可能私有化 private ，配合访问器: setter 与 getter 访问器 一起使用

五.封装（javaBean）

定义：把对象的属性和功能（方法）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。（隐藏实现细节，提供公共的访问方式 ）

优点：

1:隐藏实现细节，提供公共的访问方式

2:提高代码的复用性

3.:提高代码的安全性

private 是封装的一种体现

六.包机制(package)

package 语句作为 Java 源文件的第一条语句，指明该文件中定义的类所在的包。（若缺省该语句，则指定为无名包）。

一般的命名为:com+公司域名倒写+功能名|模块名

注意:不要定义与 jdk 相同的包，相同的类， 否则会引起很多你觉得莫名其妙的问题

导包：

1.使用 import在文件的开头引入要使用到的类

2.import 语句不仅可以导入类，还增加了导入静态方法的功能。

引入 :

• *模糊匹配（会将该包下所有用到的类引入进来），会降低编译速度，但是不会影响运行速度(import java.util.*;)
• 具体类名:import java.util.Scanner;
• 静态导入：import static java.lang.Math.PI;

不需要导包的：

• 同包下的类不需要导入
• lang包下的

七.继承（子承父业）

为什么要使用继承？简化代码

父类: 抽取一些列子类中的共性,相同的内容,定义在父类中

子类: 子类去继承父类,可以使用父类中的内容,子类也可以定义独有的内容，子类一旦继承父类,就有权使用父类中的内容

父类定义:基类:超类:被继承的类

子类定义:派生类:继承其他类的类

书写格式：

class 子类 extends 父类

优点:

• 提高代码复用型
• 子类有权使用父类中的内内容
• 子类扩展自己的能力

继承的特点:

• java中单继承机制,一个子类只能继承一个父类,但是可以多实现
• 一个父类可以有多个子类
• java中类和类之间,可以存在继承的关系,子父类的关系,但是没有什么兄弟关系

单继承机制优点:使用简单

单继承机制缺点:不便于后期维护

八.方法的重写

定义:当子类从父类中继承的某个方法,对方法体的实现不满意,想要子类独有的实现方式,那可以对这个方法进行重写

重写条件：

• 不同的类
• 继承关系|实现关系
• 方法签名相同(方法名+参数列表)

重载条件：

• 一个类中有多个方法
• 方法名相同
• 参数列表不同|方法签名不同

注意：

1.子类对象调用的是重写后的方法,如果子类没有重写调用从父类中继承的方法

2.继承有权使用父类中的内容，但是如果子类中有重写,对父类的那个方法进行屏蔽

重载Overload与重写之间的区别：都是指方法,静态方法不能重写,但是可以重载

package com.shsxt.dao;
​
public class Chong{
    public static void main(String[] args) {
        Samll dog = new Samll();
        dog.play();
        Big dog1 = new Big();
        dog1.play();
    }
}
class Big{
    public String name="大哈";
    public Big play() {
        System.out.println(name+"会拆家");
        return null;
        
    }
}
class Samll extends Big{
    public String name="二哈";
    public Samll play() {
        System.out.println(name+"会抓老鼠");
        return null;
    }
}