Java（8）面向对象，静态方法与非静态方法，成员变量与局部变量，匿名对象-CFANZ编程社区

1 非静态方法声明与调用

public class Demo {
    public static void main(String[] args) {
        Demo demo = new Demo();
        demo.eat();
    }
    public void eat(){
        System.out.println("吃吃吃");
    }
}
//吃吃吃

2 类与对象

面向对象

对象
1. 万物皆对象，客观存在的事物都是对象
类
1. 什么是类
  
  类定义了一种抽象数据类型
  
  类就是模板，确定对象将会拥有的特征(属性)和行为(方法)
2. 类的特点
  - 类是对象的类型
  - 具有相同的属性和放到的一组对象的集合
什么是对象的属性

属性：对象具有的各种特征，每个对象的属性有具有特定的值,可以理解为对某类事物的描述

例如：狗类

属性：品种、尺寸、颜色、年龄

注意：对象的属性既具有默认值，这个默认值与相对的类型相关

数据类型默认值
byte 0
short 0
int 0
long 0
double 0.0
float 0.0
char 空字符
boolean false
String null
什么是对象的行为

方法：对象执行的操作
类和对象的关系

类是对象的抽象，仅仅是一个模板，在现实世界中是不存在的；而对象是具体的实例，是类这个模板的具体实例

数据类型	默认值
byte	0
short	0
int	0
long	0
double	0.0
float	0.0
char	空字符
boolean	false
String	null

3 代码编写类声明与实例化

public class Dog {
    /**
     * 品种
     */
    String breed;
    /**
     * 尺寸
     */
    int size;

    /**
     * 颜色
     */
    String color;

    /**
     * 年龄
     */
    int age;

    public void eat(){

    }

    public void run(){

    }

    public void sleap(){

    }
}

public class DogTest {
    @Test
    public void test01(){
        Dog dog = new Dog();
    }
    @Test
    public void test02(){
        Dog dog01 = new Dog();
        Dog dog02 = new Dog();
        System.out.println(dog01 == dog02);
    }
    //false

    @Test
    public void test03(){
        Dog dog01 = new Dog();
        Dog dog02 = new Dog();
        System.out.println(dog01 == dog02);
    }
    //false
}

4 静态方法与非静态方法

public class Person {
    public static void main(String[] args) {
        sleap();
    }
    /**
     * 昵称
     */
    String nickname;
    /**
     * 性别 1代表男 0代表女
     */
    int gender;
    /**
     * 年龄
     */
    int age;

    public void eat(){
        System.out.println("民以食为天");
        drink();
    }

    public void drink(){
        System.out.println("我们是什么，我们是兄弟，这酒怎么喝，你干了我随意");
        sleap();
    }

    public static void sleap(){
        System.out.println("养精蓄锐");
    }
}

import org.testng.annotations.Test;

/**
 * 静态方法可以通过类名点方法名的方式调用<br>
 * 但是不能通过类名点方法名的方式调用非静态方法<br>
 * 可以通过类的实例化对象名点方法名的方式调用静态方法<br>
 * 也可以通过类的实例化对象名点方法名的方式调用非静态方法<br>
 * 静态方法可以调用静态方法但是无法直接调用非静态方法
 * 非静态方法可以调用非静态方法与可以调用静态方法
 */
public class PersonTest {
    @Test
    public void test01(){
        // 静态方法可以通过类名点方法名的方式调用
        // 但是不能通过类名点方法名的方式调用非静态方法
        Person.sleap();
    }
    //养精蓄锐

    @Test
    public void test02(){
        // 静态方法可以通过类名点方法名的方式调用
        // 但是不能通过类名点方法名的方式调用非静态方法
        Person.sleap();
        Person person01 = new Person();
        // 可以通过类的实例化对象名点方法名的方式调用静态方法
        // 也可以通过类的实例化对象名点方法名的方式调用非静态方法
        person01.eat();
        person01.drink();
        person01.sleap();
    }
        /*
养精蓄锐
民以食为天
我们是什么，我们是兄弟，这酒怎么喝，你干了我随意
养精蓄锐
我们是什么，我们是兄弟，这酒怎么喝，你干了我随意
养精蓄锐
养精蓄锐
    */
    
}

5 成员变量与局部变量

/**
 * 成员变量 在类中定义，用来描述对象将要有什么<br>
 * 局部变量 在类的方法中定义，在方法中临时保存数据<br>
 *         同名变量不同
 *            -在同一个方法中，不允许有同名的局部变量
 *            -在不同的方法中，可以有同名的局部变量
 * 成员变量和局部变量的区别<br>
 *  a)作用域不同
 *      -局部变量的作用域仅限于定义它的方法
 *      -成员变量的作用域在整个类内部都是可见的
 *  b)初始值不同
 *      -成员变量有默认的初始值
 *      -局部变量没有默认的初始值，必须自行设定初始值
 *  c)存储位置不同
 *      -成员变量是在对象创建以后存在于堆中，对象回收时，成员变量消失
 *      -局部变量是在方法被调用时存在于栈中，方法调执行结束，从栈中清除
 *  d)生命周期不同
 *      -对象的创建而创建，对象回收时，成员变量消失
 *      -随着方法的调用被创建，方法执行结束，从栈中清除
 */
public class Variable {
    /**
     * 成员变量
     */
    public int count;
    public int x;
    public static int y;

    public void fun01() {
        int a = 10;
        System.out.println("fun01()中a的值 >>> " + a);
    }

    public void fun02() {
        int a = 20;
        System.out.println("fun02()中a的值 >>> " + a);
    }

    public void fun03() {
        int a = 30;
        int b;
        System.out.println("fun03()中a的值 >>> " + a);
        // The local variable b may not have been initialized
        // java: 可能尚未初始化变量b
        // 局部变量 如果被调用初始化
        // System.out.println("fun03()中b的值 >>> " + b);
    }

    public void fun04() {
        System.out.println("成员变量count的值 >>> " + count);
    }

    public void fun05() {
        System.out.println("成员变量count的值 >>> " + count++);
    }

    public void fun06() {
        System.out.println("成员变量count的值 >>> " + ++count);
    }

    public void fun07(){
        System.out.println("非静态成员变量x的值 >>> " + ++x);
        System.out.println("静态成员变量y的值 >>> " + ++y);
    }
    
}

public class VariableTest {
    @Test
    public void test01(){
        Variable variable = new Variable();
        variable.fun01();
        variable.fun02();
        variable.fun03();
        variable.fun04();
        variable.fun05();
        variable.fun06();
    }
    /*
fun01()中a的值 >>> 10
fun02()中a的值 >>> 20
fun03()中a的值 >>> 30
成员变量count的值 >>> 0
成员变量count的值 >>> 0
成员变量count的值 >>> 2
    */
    
    @Test
    public void test02(){
        Variable variable = new Variable();
        variable.fun06();
        variable.fun06();
    }
    /*
成员变量count的值 >>> 1
成员变量count的值 >>> 2
    */

    @Test
    public void test03(){
        Variable variable01 = new Variable();
        Variable variable02 = new Variable();
        variable01.fun06();
        variable01.fun06();
        variable02.fun06();
    }
    /*
成员变量count的值 >>> 1
成员变量count的值 >>> 2
成员变量count的值 >>> 1
    */

    @Test
    public void test04(){
        Variable variable01 = new Variable();
        Variable variable02 = new Variable();
        variable01.fun07();
        variable02.fun07();
        variable01.fun07();
        variable02.fun07();
    }
    /*
非静态成员变量x的值 >>> 1
静态成员变量y的值 >>> 1
非静态成员变量x的值 >>> 1
静态成员变量y的值 >>> 2
非静态成员变量x的值 >>> 2
静态成员变量y的值 >>> 3
非静态成员变量x的值 >>> 2
静态成员变量y的值 >>> 4
    */
    
}

6 匿名对象

public class Temp {
    public void laugh(){
        System.out.println("二十四笑头一笑，仰天长笑");
    }
}

import org.testng.annotations.Test;

/**
 * 普通变量 直接赋值
 * 引用变量 引用了一个内存地址
 * 匿名对象 没有引用类型变量指向的对象
 * 适用场景：使用之后直接从内存中消失 不会长期占用内存 适用于仅仅偶尔使用的场景
 * 不适用场景：因为使用之后直接从内存中消失 如果频繁使用该对象需要频繁在内存中创建和回收该对象 创建和回收过程都要消耗系统资源 建议频繁使用对象尽量使用引用类型变量引用
 */
public class TempTest {
    @Test
    public void test01() {
        Temp temp = new Temp();
        temp.laugh();
        temp.laugh();
        temp.laugh();
    }
    /*
二十四笑头一笑，仰天长笑
二十四笑头一笑，仰天长笑
二十四笑头一笑，仰天长笑
    */

    @Test
    public void test02() {
        // Temp temp = new Temp();
        // temp.laugh();
        new Temp().laugh();
    }
    //二十四笑头一笑，仰天长笑
}