Java面向对象（类、对象、变量、方法、方法重载、对象与引用、static）

Java面向对象（类、对象、变量、方法、方法重载、对象与引用、static）

面向过程和面向对象设计思想

面向过程：分析出解决问题的步骤，然后一步步实现。（注重解决步骤，简单有效）

面向对象：面向编程语言，以分类的方式进行思考和解决问题，面向对象的思维方式适合处理复杂问题。（宏观，整体上的设计，处理复杂问题，细节处理）

Java类

类是一个模板，描述对象属性和行为。类中定义事物特征

对象是具体存在的，在内存中存储

结构：成员变量（对对象属性进行描述）；

​ 方法 （对象的行为）;

​ 构造方法 (用于创建对象);

​ 内部块 (在类体中声明的类)

​ 块(代码块)

类的声明格式:

public class ClassName {
    /*访问权限修饰符public,default;
  修饰符:final,abstract;
  关键词class定义一个类;*/
//[访问权限修饰符] [修饰符] class ClassName{}
        /*成员变量定义
            [访问权限修饰符] [修饰符] 数据类型  变量名 [=值];
            成员变量定义在类中,方法体之外*/
        String name;//定义名称
        String color;//定义颜色
        float price;//定义价格
        private int aaa;//定义一个私有变量aaa
        //方法声明格式
    /*访问权限修饰符public,default,protected private
       如无返回值，必须给出返回值类型void*/
//    [访问权限修饰符][修饰符] void methodName()
        public void methodName(){
            System.out.println("这里是输出结果");
//        [return   返回值;]
        }
    }

Java对象

对象的创建和使用

    public static void main(String[] args) {
   /*     使用new关键词+构造方法创建对象
        lassName  aaa  = new ClassName();(ClassName类就是aaa的类型)
        在内存空间中创建了一个对象 实际存在的
        通常叫实例化对象*/
        ClassName  aaa  = new ClassName();
        //使用对象(引用) 成员变量来引用对象的成员变量
        aaa.name = "阿坤哥哥";
        //使用对象(引用) 成员变量来调用对象的方法
        aaa.methodName();
        //每一个类的每个有不同的成员变量存储空间
        //每个类的对象共享该类的方法
    }

变量分类

成员变量

成员变量是定义在类中，方法体之外的变量。

成员变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。

在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。

成员变量在创建对象的时候会从类中复制一份到对象中。

成员变量可以被类中方法、构造方法和特定类的语句块访问。

成员变量的作用范围为整个类体。

局部变量

在方法、构造方法或者语句块中定义的变量被称为局部变量。

局部变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。

局部变量在使用前必须初始化赋值。

变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

类变量（也叫静态变量）

类变量也声明在类中，方法体之外，但必须声明为static类型。

构造方法

构造方法是定义在 Java 类中的一个用来创建对象的方法。

构造方法名与类名相同,且没有返回值,且不需要使用void修饰

使用 new + 构造方法 创建一个新的对象。在创建一个对象的时候，至少要调用一个构造方法。一个类可以有多个构造方法。

每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法,但是只要在一个Java类中定义了一个构造方法后，默认的无参构造方法即失效。

public class Person {
    /*
       成员变量
    */
    String name;
    int age;
    /*
       构造方法
       方法名与类名相同,没有返回值
       不需要void修饰,
       有void修饰就不是构造方法,是与类名相同的成员方法
       一个类中可以有多个构造方法(方法的重载)
       一旦类中定义了有参的构造方法,默认无参的方法就会被覆盖,建议显示的写出来
    */
    public Person(){
        System.out.println("这里是无参的构造方法");
    }
    public Person(String a){
        age = a;
        System.out.println("这里是有参的构造方法");
    }
    /*
       成员方法
    */
    public void eat(){

    }
    public void study(){

    }
}

public class Test {                              
    public static void main(String[] args) {     
        //构造方法作用:创建对象,可以给对象中的属性初始化赋值	 
        new Person();//没有显示的定义构造方法,默认会提供一个无参的构造方法
        Person p = new Person(a:"aaaa");    //给a赋值"aaaa"     
    }                                            
}                                                

方法的重载

方法重载是指一个类中可以定义有相同的名字,但参数不同的多个方法.

调用时,会根据不同的参数表选择对应的方法.

参数不同:可以是数量不同,类型不同,顺序不同三种

注意:方法的重载跟方法的返回值类型没有任何关系.

成员方法和构造方法都可以重载

对象与引用

Java语言中除了基本类型之外的变量都称之为引用变量.

Java中的对象是通过引用对其操作的

Person person = new Person()

1.右边的“ new Person（）”，是以Person类为模板，调用Person类函数，在堆空间里创建一个Person类对象。

2.左边的“Person person”创建了一个Person类引用变量。所谓Person类的引用，就是以后可以用来指向Car对象的对象引用。

3.“=”操作符使对象引用指向刚创建的那个Car对象。

值传递和引用传递

值传递与引用传递•Java中进行方法调用中传递参数时，参数传递有两种：

1.值传递：(形式参数类型是基本数据类型)：方法调用时，实际参数把它的值传递给对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。

public class TestValue {
    // 传递值 把a的值传递给num  num是一个新的独立的变量
    public void test(int num){
        System.out.println("test:"+num);
        num =num +3;
    }

    public static void main(String[] args) {
        TestValue t = new TestValue();
        int a = 10;
        t.test(a);
        System.out.println(a);
    }
}

2.引用传递：(形式参数类型是引用数据类型参数)：也称为传地址。方法调用时，实际参数是对象，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下来，所以方法执行中形式参数的改变将会影响实际参数。

public class Test1 {
    public static void main(String[] args) {
        Test1 a = new Test1();
        Person person = new Person();
        person.name = "小任";
        a.test(person);
        System.out.println(person.name);
    }
    //引用传递
    public void test(Person person1){
      person1.name = "阿坤"; //只是将对象引用传递   形参中值发生变化会影响实参
    }
}

​ 基本类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象本身 。

static

static 静态的

关键字：被语言赋予特定含义的单词 修饰作用

static：修饰类的属性，方法，代码块，内部类

​ 特点：随着类的加载而加载

​ 优于对象存在

		   修饰的成员，被所有对象所共享

​ 可不创建对象，直接被类调用

static修饰的变量为（静态）类变量，类只有一份，static修饰的变量在内存中也只有一份，建议直接用类名调用。

成员方法中可以访问成员变量，还可以访问静态变量

静态方法中不能访问成员变量，静态方法先于对象存在

静态方法可以通过类名调用

public class TicketSeller {
    static int ticket = 11;//票数只有一份，声明为静态变量
    public static void SellTicket(){
        ticket = ticket - 1;
        System.out.println("买票的静态方法"+ticket);
    }

    public static void main(String[] args) {
        TicketSeller.SellTicket();//静态方法可以直接通过类名调用

    }
}

代码块

代码块在类中声明，类似一个没有名称的方法体（代码体），代码分实例块和静态块

实例块：每次创建对象自动调用

{

//任何符合语法的Java代码

}

静态块：类加载时自动调用，仅一次，与是否创建对象无关。

static{

​ //任何符合语法的Java代码

}

public class StaticTest {
    /*
    代码块定义在类中，类似一个没有名字的方法
    实例块
    静态块
    */
    /*
    实例块：与成员方法相似，  属于对象的
          每次在创建对象时调用   先于构造方法执行 可以有多个
    */
    static int PI = 1234;
    {
        System.out.println("实例代码块1");
    }
    {
        System.out.println("实例代码块2");
    }
    /*
    静态块  属于类
    类加载时执行  多个静态块按顺序执行
    */
    static{

            System.out.println("静态块1");
    }
    static{
        System.out.println("静态块1");
    }
    public static void main(String[] args)  {
       System.out.println(StaticTest.PI);
//        new StaticTest();

    }
}

public class Test {
       //当类被加载时（创建对象，使用类中的静态变量和静态方法） 加载一次（长期不用销毁 再用在加载）
        static int num;//1
        int age;
        static{//1
            System.out.println("test static");
        }
        {//2
            System.out.println("test");
        }
        public Test() {//3
            System.out.println("test constructor");
        }

        public static void main(String[] args) {
            System.out.println(Test.num);
            new Test();
        }
    }

第一次分享，感谢大家观看。