Java基础_面向对象_创建类，对象_局部，成员变量_权限修饰符_方法的重写_构造器_代码块_11

Java基础_面向对象_Java三大特性_封装，继承，多态_12

面向对象与面向过程的区别

面向过程：当事件比较简单的时候，利用面向过程，注重的是事件的具体的步骤/过程，注重的是过程中的具体的行为，以函数为最小单位，考虑怎么做。

面向对象：注重找“参与者”,将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

面向过程：编年体
面向对象：纪传体

二者相辅相成,并不是对立的。解决复杂问题,通过面向对象方式便于我们从宏观上把握事物之间复杂的关系、方便我们分析整个系统;具体到微观操作,仍然使用面向过程方式来处理

类和对象

万物皆有对象
我给我自己new一个对象。对象 ZT = new 对象()；┭┮﹏┭┮😭

对象：具体的事物，具体的实体，具体的实例，模板下具体的产品。
类：对对象向上抽取出像的部分，公共的部分，形成类，类是抽象的，是一个模板。
如：无籽西瓜和有籽西瓜都是对象，但他们都属于西瓜这个类。
同一个事物既有类，也有对象的属性。两者不可分割。没有先有谁后有谁的道理。

一般在写代码的时候先写类，然后在根据类创建对应的对象。

1. 面向对象分析OOA – Object Oriented Analysis
   对象：张三，王五，朱六，你，我
   ·
   抽取出一个类---->人类
   类里面有什么：
   动词–>动态特性–>方法
   名词–>静态特性–>属性

2. 面向对象设计OOD – Object Oriented Design
   先创建类，再创建对象：
   类：人类： Person
   对象：zhangsan ，lisi，zhuliu

3. 面向对象编程OOP – Object Oriented Programming

创建类

1. 属性（field 成员变量）
   属性用于定义该类或该类对象包含的数据或者说静态特征。属性作用范围是整个类体。
   属性定义格式：
   [修饰符] 属性类型 属性名 = [默认值] ;

2. 方法
   方法用于定义该类或该类实例的行为特征和功能实现。方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
   方法定义格式：
   [修饰符] 方法返回值类型 方法名(形参列表) {
   // n条语句
   }
   void代表没有返回值；方法的作用：重用代码，封装功能，便于修改

代码：

//创建类Person
public class Person {
    //名词-->属性，只需要把有需要的内容写到代码里，不相关的东西不要放在代码里
    //成员变量-->放在类中方法外
    int age;
    String name;
    double height;
    double weight;

    //动词-->方法
    public void eat(){
        int num = 10;//局部变量，放在方法中，最好初始化
        System.out.println();
    }
    public void sleep(String address){

    }

    public String introduce(){
        return "我的名字是："+name+",我的年龄是："+age;
    }
}

对象

对象是根据类创建的。在Java中，使用关键字 new 来创建一个新的对象。创建对象需要以下三步：

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

public class Test {//测试类

    //main方法，程序的入口
    public static void main(String[] args) {
        //创建一个人类的具体的对象/实例
        //创建一个对象，名字叫zt
        //Person属于引用数据类型，因为在person中既有int，也有String，也有double等等；
        //第一次加载类的时候，会进行类的加载，初始化创建对象的时候，对象的属性没有给赋值，有默认的初始化的值。

        Person zt = new Person();
        zt.age=19;
        zt.height=180;
        zt.name="ZhouT";
        zt.weight=90;

        //再创建一个对象
        //再次创建类的时候，就不会进行类的加载了，类的加载只在第一次需要的时候加载一次
        Person ls = new Person();
        ls.name="李四";
        ls.weight=0;
        ls.height = 1;
        ls.age = 10;

        //对属性的值进行读取
        System.out.println(zt.name);
        System.out.println(ls.age);

        //对方法进行操作
        //不同的对象，属性有自己的特有的值，但是方法都是调用类中通用的方法。
        //属性：各个对象的属性是独立的，
        //方法：各个对象的方法是共享的。
        zt.eat();
        ls.eat();
        zt.sleep("教室");

        String introduce = zt.introduce();
        System.out.println(introduce);
        //两句合为一句
        System.out.println(zt.introduce());


    }
}

成员变量和局部变量，类变量

局部变量：

在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

成员变量：

成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。

类变量：

类变量也声明在类中，方法体之外，但必须声明为 static 类型。静态代码块 static{ }，静态代码块只会被执行一次；
类定义的时候，类中变量创建在代码区，此时静态代码块会被自动执行；

成员变量和局部变量的区别

区别1：代码中位置不同
·········· 成员变量：类中方法外定义的变量
··········局部变量：方法中定义的变量 代码块中定义的变量

区别2：代码的作用范围
··········成员变量：当前类的很多方法
··········局部变量：当前一个方法（当前代码块）

区别3：是否有默认值
··········成员变量：有
··········局部变量：没有

区别4：是否要初始化
·········· 成员变量：不需要，不建议初始化，后续使用的时候再赋值即可
·········· 局部变量：一定需要，不然直接使用的时候报错

区别5：内存中位置不同
···········成员变量：堆内存
···········局部变量：栈内存
区别6：作用时间不同
··········成员变量：当前对象从创建到销毁
··········局部变量：当前方法从开始执行到执行完毕

public class Student {
    byte e;
    short s;
    int c;
    long num2;
    float f;
    double d;
    char ch;
    String str;
    boolean boo;

    public void study(){
        int num = 10 ; //局部变量：在方法中
        System.out.println(num);//10
        //int num ;重复命名，出错了
        {
            int a;//局部变量：在代码块中
        }
        int a;
        if(1==3){
            int b;
        }
        System.out.println(c);

    }
    public void eat(){
        System.out.println(c);
    }

    public static void main(String[] args) {
        Student stu = new Student();
        System.out.println(stu.boo);
        System.out.println(stu.c);
        System.out.println(stu.ch);
        System.out.println(stu.d);
        System.out.println(stu.f);
        System.out.println(stu.str);
        System.out.println(stu.e);
        System.out.println(stu.s);

    }
}

构造方法（构造器）

new方法：
new关键字实际上在调用一个方法，这个方法叫构造方法（构造器），调用构造器的时候，如果类中没有写构造器，那么系统会默认给你分配一个构造器，只是我们看不到罢了

    可以自己显式的将构造器编写出来
    构造器的格式：
    [修饰符] 构造器的名字（）{

    }
    构造方法和方法的区别：
    1.没有方法的返回类型
    2.方法体内不能有return语句；
    3.构造器的方法名必须和类名相同

构造器的作用：不是为了创建对象，因为在调用构造器之前，这个对象就已经创建好了，并且属性有默认的初始化的值。

调用构造器的目的是给属性进行赋值操作的。

注意：我们一般不会在空构造器中进行初始化操作，因为那样的话每个对象的属性就一样了。

实际上，我们只要保证空构造器的存在就可以了，里面的东西不用写

构造方法的重载

public class Person {
    public Person(){
        //构造器，没有任何参数的构造器-->空参构造方法
    }
    public  Person(String name,int age,double height){
        //构造方法的重载
        // 当形参名字和属性名字重名的时候，程序就会有就近原则
        //在要表示对象的属性前加上this.来修饰 ，因为this代表的就是你创建的那个对象
        this.name = name;
        this.age = age;
        this.height= height;
    }
    //属性
    String name;
    int age;
    double height;

    }
}

代码块：普通块，构造块，静态块

代码块分类：普通块，构造块，静态块，同步块（多线程）

1. 最先执行静态块，只有在类加载的时候执行一次，一般用于执行一些全局性的初始化工作
2. 再执行构造块
3. 再执行构造块器
4. 再执行方法中的普通块

package com.ZhouT6;

public class Test {
    int id;
    static int sid;

    public Test(){
        System.out.println("这是空构造块");
    }
    public void a(){
        System.out.println("--------a");
        {
            //普通块限制了局部变量的作用范围
            System.out.println("这是普通块");

        }
    }
    
    //构造块
    {
        System.out.println("这是构造块");
    }

    //静态块
    static {
        System.out.println("这是静态块");
        //在静态块中只能访问静态方法和静态属性
    }

    public static void main(String[] args) {
        Test t = new Test();
        t.a();

        Test t2 = new Test();
        t2.a();
    }
    //先执行静态块，且加载一次

    //最先执行静态块，只有在类加载的时候执行一次，一般用于执行一些全局性的初始化工作
    //再执行构造块
    //再执行构造块器
    //再执行方法中的普通块
}

输出结果：

		这是静态块
		这是构造块
		这是空构造块
		--------a
		这是普通块
		这是构造块
		这是空构造块
		--------a
		这是普通块

包import

包名定义：

1. 名字全部小写
2. 中间用.隔开
3. 一般都是公司域名倒着写 ： com.jd com.msb
4. 加上模块名字：com.jd.login com.jd.register
5. 不能使用系统中的关键字：nul,con,com1—com9…
6. 包声明的位置一般都在非注释性代码的第一行：

总结：
7. 使用不同包下的类要需要导包： import **..; 例如：import java.util.Date;
8. 在导包以后，还想用其他包下同名的类，就必须要手动自己写所在的包。
9. 同一个包下的类想使用不需要导包，可以直接使用。
10. 在java.lang包下的类，可以直接使用无需导包：
11. IDEA中导包快捷键：alt+enter 可以自己设置自动导包
12. 可以直接导入

静态导入：

package com.msb11;
//静态导入：
import static java.lang.Math.*;
//导入：java.lang下的Math类中的所有静态的内容
/**
 * @Auther: msb-zhaoss
 */
public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
        System.out.println(round(5.6));
    }
    //在静态导入后，同一个类中有相同的方法的时候，会优先走自己定义的方法。
    public static int round(double a){
        return 1000;
    }
}

权限修饰符

• default (即默认，什么也不写，在变量前写default会出错）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

• private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

• public : 对所有类可见。使用对象：类、接口、变量、方法

• protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
  
  private和protected不能修饰类

写代码：
一般属性：用private修饰；
方法：用public 修饰

方法的重写

重写的定义：

发生在子类和父类中，当子类对父类提供的方法不满意的时候，要对父类的方法进行重写。

重写有严格的格式要求：
子类的方法名字和父类必须一致，参数列表（个数，类型，顺序）也要和父类一致。（修饰符，返回值类型，方法体不同）

public class Person {
    public Person(){

    }
    public void eat(){
        System.out.println("吃Person");
    }
    public void sleep(){
        System.out.println("睡觉Person");
    }

}

public class Student extends Person {
    public void eat(){
        System.out.println("吃Student");

    }
    public void sleep(){
        System.out.println("睡觉Student");
    }
}

public class Test {
    public static void main(String[] args) {
        Student s = new Student();
        s.eat();
        s.sleep();
        System.out.println();
    }
}

重写和重载的区别

项目	英文	位置	修饰符	返回值	方法名	参数	方法体	返回异常
重 载	overload	同一个类中	无关	无关	必须相同	必须不同	不同	无关
重 写	override	子类父类中	父类的权限修饰符要低于或等于子类的	（基本数据类型）返回值类型必须一样·························（引用数据类型）父类的返回值类型大于等于子类	必须相同	必须相同	不同	小于等于

~
有不懂的地方可以私信~

内容来源于马士兵教育赵珊珊老师的Java笔记。

Java基础_面向对象_Java三大特性_封装，继承，多态_12