Java基础|01.基础语法(1)

00x1 基本语法
00x2 类和对象的关系
00x3 方法
00x4 静态
00x5 包（package）
00x6 构造方法
- 1.定义
- 2.分析
00x7 一个对象的创建过程
00x8 继承
00x9 多态
- 1.概述
- 2.多态的具体体现

00x1 基本语法

1.类的语法

// TODO 面向对象

// 1.类的语法

class 类名{

    //类名规范：首字母大写

    特征（属性）-->类中的变量

    功能（方法）-->函数

}

一个类可以包含的类型变量

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。

2.对象的语法

// 1.创建对象的语法

new 类名();

// 2.创建对象

//**让对象名（变量）指向new所创建的对象

类名 对象名 = new 类名();

// 3.对象属性操作

对象名.属性 = "属性值";

注意

声明：声明一个对象，包括对象名称和对象类型。
实例化：使用关键字 new 来创建一个对象。
初始化：使用 new 创建对象时，会调用构造方法初始化对象。

3.方法的声明

//格式

void 方法名(参数){

        功能代码;

    }

//方法的执行方法：

	对象.方法名()；

4.小例子

//case01

public class Main {

    public static void main(String[] args) {

        Cooking fr_egg = new Cooking();

        fr_egg.name = "蛋炒饭";

        fr_egg.type = "煎炒";

        fr_egg.material = "egg、rice";

        fr_egg.cook_dish();

    }

}

class Cooking{

    String name;

    String type;

    String material;

    int weight;

    void cook_dish(){

        System.out.println("准备食材：" + material );

        System.out.println("选择烹饪类型：" + type );

        System.out.println("开始烹饪");

        System.out.println(name + "烹饪完成。");

    }

}

//case02

public class Main {

    public static void main(String[] args) {

        Animal dog = new Animal();

        dog.type = "dog";

        dog.color = "黑色";

        dog.name = "Gbnine";

        dog.run();

        dog.eat();

    }

}

class Animal {

    //属性

    String type;

    String name;

    String color;

    //方法

    void run(){

        System.out.println("一只叫" + name +"的" + color + type + "跑开了。");

    }

    void eat(){

        System.out.println(name + "吃");

    }

}

00x2 类和对象的关系

1.堆、栈和元空间

（1）堆区（heap）

堆：作用是用于存储java中的对象和数组，当我们new一个对象或者创建一个数组的时候，就会在堆内存中开辟一段空间给它，用于存放。
特点：堆类似于管道，即数据先进先出，后进后出

（2）栈区（stack）

栈：由编译器自动分配释放，作用是存放函数的参数值，局部变量的值等
特点：先进后出，后进先出

（3）元空间

作用是存放类的具体信息

2.基本数据类型和引用数据类型的区别

基本数据类型只存放于栈中，不存放在堆中
引用数据类型（如对象）在堆中创建，然后引用数据类型的内存地址被赋值给栈中的变量，由变量引用。

3. 空对象（null）

定义：没有引用的对象（即对象的内存地址未被赋值给变量）。

00x3 方法

1.定义：

2.参数传递方式

//java中方法参数的传递为值传递

// 基本数据类型：传数值

//引用数据类型：传引用地址

00x4 静态

1.先有类，后有对象

2.成员方法可以访问静态属性和静态方法。

3.静态方法不能访问成员属性和成员方法

4.静态代码块：

定义

class TestStaticBlock{

    static{

        //静态代码块

    }

}

类的信息加载完成后，会自动调用静态代码块，可以实现静态属性的初始化功能。
类似的，对象准备创建时，也会自动调用代码块（这里的代码块不是静态代码块）
```
class TestStaticBlock_01{

    {

        //代码块

    }

}
```

例1

public class Main {

    public static void main(String[] args) {

        Test_01.run();

        //执行静态方法，加载类信息后执行静态代码块。

    }

}

class Test_01{

    static{

        System.out.println("static code block!");

    }//静态代码块

    {

        System.out.println("code block!");

    }//代码块

    static void run(){

        System.out.println("run...");

    }//静态方法

    void work(){

        System.out.println("work...");

        run();//成员方法可以调用静态方法

    }//成员方法

}

例2

public class Main {

    public static void main(String[] args) {

        Test_01 test = new Test_01();

        test.work();

        //执行成员方法，加载类信息后执行静态代码块，加载对象信息后执行代码块

    }

}

class Test_01{

    static{

        System.out.println("static code block!");

    }//静态代码块

    {

        System.out.println("code block!");

    }//代码块

    static void run(){

        System.out.println("run...");

    }//静态方法

    void work(){

        System.out.println("work...");

        run();//成员方法可以调用静态方法

    }//成员方法

}

00x5 包（package）

1.package中容纳类

2.基本语法

package 包完整路径；

路径中使用点（.）隔开

3.主要功能是用于分类管理

4.一个类可以没有包，但是package不可以在同一个源码文件中使用多次

5.包名为了区分类名，一般全部使用小写。

6.导入类，使用关键字“import”

如果同一个包中需要导入大量类，那么使用通配符星号*简化操作。

例如导入java.util包中的大量类：import java.util.*

00x6 构造方法

1.定义

构造方法又叫构造器。用于创建实例（即对象）的时候进行初始化操作。

//TODO面向对象－构建对象

构造方法：专门用于构建对象

如果一个类中没有任何的构造方法，那么JVM会自动添加一个公共的，无参的构造方法，方便对象的调用

//TODO：基本语法：类名（）

1.构造方法也是方法，但是没有void关键字。

2.方法名和类名完全相同

3.如果类中没有构造方法，那么JVM会提供默认的构造方法

4.如果类中有构造方法，那么JVM不会提供默认的构造方法

5.构造方法也是方法，所以也可以传递参数，但是一般传递参数的目的是用于对象属性的赋值

2.分析

package study;

public class Constructor {

    public static void main(String[] args) {

        MagicBox box1 = new MagicBox();

        /*

        1.在没有定义构造方法之前或定义了public MagicBox(){}，MagicBox box1=new MagicBox（）可用.

        若此时定义了一个带有参数列表的构造方法，且未定义默认构造方法，则MagicBox box1=new MagicBox（）不可用。

         */

        MagicBox box2 = new MagicBox(2,3,4);

        box1.area();

        box1.volume();

        box2.area();

        box2.volume();

    }

}

class MagicBox{

    public int length;

    public int width;

    public int height;

    public MagicBox(){

        /*

        1.此构造方法等同于系统提供的默认的构造方法，只不过在用户未自定义构造方法之前，这个方法是由系统提供的，并且是不可见的。

        2.如果用户自定义了一个构造方法，并且与原来系统默认提供的构造方法一致，那么原来的构造方法失效。

        3.一个类中可以同时存在多个构造方法，此时形成了构造方法的重载。

        4.若访问权限设置为public，则允许其他类创建该类的对象；若设置为protected,仅允许子类调用。

         */

    }

    public MagicBox(int length, int width, int height){

        /*

        1.定义一个构造方法：它用于对MagicBox进行初始化。

        2.定义一个带有参数的方法，用于接收外界传递进来的初始化参数。

        3.构造方法没有返回值类型。

         */

        this.length = length;

        this.width = width;

        this.height = height;

    }

    int area(){

        int area = length * width;

        System.out.println(area);

        return area;

    } //面积

    int volume(){

        int volume = length * width * height;

        System.out.println(volume);

        return volume;

    } //体积

}

>>>

0

0

6

24

/*特别地：

1.若一个构造方法的结构能够包含另一个构造方法的结构，则它们之间是存在可调用的关系的。

2.普通方法无法调用构造方法。

*/

package study;

public class Constructor {

    public static void main(String[] args) {

        MagicBox box2 = new MagicBox(2,3);

        MagicBox box2 = new MagicBox(2,3,4);

    }

}

class MagicBox{

    public int length;

    public int width;

    public int height;

    public MagicBox(int length, int width){

        this.length = length;

        this.width = width;

    }

    public MagicBox(int length, int width, int height){

        this(length,width);

        //1.可以使用this关键字对构造方法进行调用

        //2.被调用的语句必须放在第一行

        this.height = height;

    }

}

00x7 一个对象的创建过程

Person p = new Person("zhangSan",20);

该句话都做了什么事情？

1，因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。

2，执行该类中的static代码块，如果有的话，给Person.class类进行初始化。

3，在堆内存中开辟空间，分配内存地址。

4，在堆内存中建立对象的特有属性。并进行默认初始化。

5，对属性进行显示初始化。

6，对对象进行构造代码块初始化。

7，对对象进行对应的构造方法初始化。

8，将内存地址付给栈内存中的p变量。

00x8 继承

1.三个特征

面向对象中有个三个非常重要的特征：继承，封装，多态

// TODO 继承

// 类存在父子关系：

// （1）子类可以直接获取到父类的成员属性和成员方法类的继承只能是单继承，

// （2）一个类只能有一个父类，不能存在多个父类

// （3）一个父类可以有多个子类

// （4）继承采用extends语法：子类 extends 父类

//举个栗子

package study;

public class Study_01 {

    public static void main(String[] args) {

        Child child = new Child();

        System.out.println(child.name);

        child.test();

    }

}

class Parent {

    String name = "zhangSan";

    void test(){

        System.out.println("test");

    }

} //父类

class Child extends Parent {

} //子类

2.super、this

// 如果父类和子类含有相同的属性，使用关键字this、super进行区分。

//this代表字类属性，super表示父类属性。

//举个栗子

package study;

public class Study_01 {

    public static void main(String[] args) {

        Child child = new Child();

        child.test();

    }

}

class Parent {

    String name = "zhangSan";

}

class Child extends Parent {

    String name = "liSi";

    void test(){

        System.out.println(this.name);

        System.out.println(super.name);

    }

}

3.继承中的构造方法

1.子类的构造的过程中必须调用其父类的构造方法。

2.子类可以在自己的构造方法中使用super()调用基类的构造方法。

	·使用this()调用本类的另外的构造方法

    ·如果调用了super，必须写在子类构造方法的第一行

3.如果子类的构造方法中没有显示地调用基类构造方法，则系统默认调用基类无参的构造方法

4.如果子类构造方法中既没有显式调用基类构造方法，而基类中又没有无参的构造方法,则编译出错

举个栗子

package study;

public class Extends {

    public static void main(String[] args) {

        Child c1 = new Child();

        System.out.println(c1.parentName);

    }

}

class Parent{

    String parentName;

    public Parent(String name){

        parentName = name;

        System.out.println("父类构造方法");

    }//带参构造方法

}

class Child extends Parent{

    public Child(){

        super("zhangSan");//调用父类构造方法

        System.out.println("子类构造方法");

    }

}

<<<

父类构造方法

子类构造方法

zhangSan

00x9 多态

1.概述

（1）多态即方法或对象具有多种形态，是建立在封装和继承继承上的。具体表现为：父类引用变量可以指向子类对象

（2）前提条件：必须存在继承关系

（3）格式：父类类型变量名 = new 子类类型();

2.多态的具体体现

（1）方法的多态

方法的重写体现多态
方法的重载体现多态

（2）对象的核心（核心）

一个对象的编译类型和运行类型可以不一致
编译类型在定义对象时，就确定了，不能改变
运行类型是可以变化的
编译类型看定义时=号的左边，运行类型看=号的右边

//注释

//1.关于编译类型和运行类型

    Animal animal = new Dog();

	Animal animal = new Cat();

//Animal为Dog和Cat的父类，语句中Animal即为编译类型，Dog和Cat为运行类型。

//animal是父类Animal的一个变量引用，存在于栈中，它指向堆的对象Dog。

巴特西