zoukankan      html  css  js  c++  java
  • java学习--基础知识进阶第一天--static静态关键字、代码块

    今日内容介绍

    u 知识回顾

    u static静态关键字

    u 代码块

    第1章 知识回顾

    1.1 方法的回顾

    1.1.1 案例代码一:

    package com.itheima_01;

    /*

     * 需求:定义一个方法求两个数的和,并在主方法中调用

     *

     * 方法:类中的一段具有特定功能的程序,提高了代码的复用性和可维护性

     * 定义格式:

     * public static 返回值类型(没有返回值写void) 方法名(参数类型 参数名,参数类型 参数名2) {//形参

     * 方法体;

     * }

     * 调用方式:

     * 有明确返回值类型:

     * 赋值调用,将方法的返回值赋值给一个变量

     * 输出调用,使用输出语句直接输出方法的返回值

     * 直接调用,没法获取方法的返回值

     * 没有明确返回值类型:

     * 直接调用

     * 方法重载:在一个类中有多个重名的方法,这些方法参数不同,和返回值无关

     *

     * 注意:

     * 形参:方法声明的变量,只能是变量,接收方法调用时传递进来的数据

     * 实参:调用方法时传递的数据,可以是常量也可以是变量

     *

     */

    public class MethoDemo {

    public static void main(String[] args) {

    //赋值调用

    //int sum = sum(10,20);//实参

    //System.out.println(sum);

    //输出调用

    int a = 10;

    int b = 20;

    System.out.println(sum(a,b));

    }

    public static int sum(int a,int b) {

    /* //使用变量接收求和结果并返回

    int sum = a + b;

    return sum;*/

    //直接返回求和结果

    return a + b;

    }

    }

    1.2 数组的回顾

    1.2.1 案例代码二:

    package com.itheima_02;

    /*

     * 需求:定义一个元素类型为int的数组,遍历数组并求和

     *

     * 数组:用于存储多个元素的一种容器

     * 数组的特点:

     * 元素类型必须一致

     * 元素有整数索引

     * 一旦定义好长度则无法改变

     * 可以存储基本数据类型

     * 也可以存储引用数据类型

     * 定义格式:

     * 动态初始化

     * 元素类型[] 数组名 = new 元素类型[10];

     * 静态初始化

     * 元素类型[] 数组名 = {元素1,元素2,元素3};

     * 元素类型[] 数组名  = new 元素类型[]{元素1,元素2,元素3};

     *

     */

    public class ArrayDemo {

    public static void main(String[] args) {

    //使用静态初始化定义数组

    int[] arr = {1,2,3,4,5};

    //定义一个变量用于存储求和结果

    int sum = 0;

    //遍历数组

    for(int x = 0;x < arr.length;x++) {

    sum += arr[x];

    }

    System.out.println(sum);

    }

    }

    1.3 标准类定义和使用回顾

    1.3.1 案例代码三:

    package com.itheima_03;

    /*

     * 定义一个标准的学生类,在主方法中创建对象并调用

     * 姓名,年龄,性别3个成员变量

     * 无参,有参两个构造方法

     * 为每个成员变量定义getter/setter方法

     * 定义一个show方法,输出成员变量

     */

    public class Student {

    private String name;//姓名

    private int age;//年龄

    private String gender;//性别

    /*//无参构造

    public Student() {}

    //有参构造

    public Student(String name,int age,String gender) {

    this.name = name;

    this.age = age;

    this.gender = gender;

    }

    //name

    public String getName() {

    return name;

    }

    public void setName(String name) {

    this.name = name;

    }

    //age

    public int getAge() {

    return age;

    }

    public void setAge(int age) {

    this.age = age;

    }

    //gender

    public String getGender() {

    return gender;

    }

    public void setGender(String gender) {

    this.gender = gender;

    }*/

    //show:用于输出所有的成员变量

    public void show() {

    System.out.println(name + "," + age + "," + gender);

    }

    public Student() {

    super();

    // TODO Auto-generated constructor stub

    }

    public Student(String name, int age, String gender) {

    super();

    this.name = name;

    this.age = age;

    this.gender = gender;

    }

    public String getName() {

    return name;

    }

    public void setName(String name) {

    this.name = name;

    }

    public int getAge() {

    return age;

    }

    public void setAge(int age) {

    this.age = age;

    }

    public String getGender() {

    return gender;

    }

    public void setGender(String gender) {

    this.gender = gender;

    }

    }

    package com.itheima_03;

    public class StudentTest {

    public static void main(String[] args) {

    //创建学生对象

    Student s = new Student();

    //为成员变量进行赋值

    s.setName("张三");

    s.setAge(18);

    s.setGender("男");

    s.show();

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

    Student s2 = new Student("李四",20,"其他");

    //s2.show();

    System.out.println(s2.getName());

    }

    }

    第2章 static静态关键字

    2.1 静态的概述

    当在定义类的时候,类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。当在调用对象的某个方法时,这个方法没有访问到对象的特有数据时,方法创建这个对象有些多余。可是不创建对象,方法又调用不了,这时就会想,那么我们能不能不创建对象,就可以调用方法呢?

    可以的,我们可以通过static关键字来实现。static它是静态修饰符,一般用来修饰类中的成员。

    2.2 静态的特点

    A: 被static修饰的成员变量属于类,不属于这个类的某个对象。(也就是说,多个对象在访问或修改static修饰的成员变量时,其中一个对象将static成员变量值进行了修改,其他对象中的static成员变量值跟着改变,即多个对象共享同一个static成员变量)

    B: 被static修饰的成员可以并且建议通过类名直接访问

    访问静态成员的格式:

    类名.静态成员变量名

    类名.静态成员方法名(参数)

    C: 静态的加载优先于对象,随着类的加载而加载

    2.2.1 案例代码四

    package com.itheima_01;

    /*

     * static:是一个关键字,用于修饰成员变量和成员方法

     * static的特点:

     * 被所有的对象所共享

     * 可以使用类名调用

     * 静态的加载优先于对象

     * 随着类的加载而加载

     *

     */

    public class StaticDemo {

    public static void main(String[] args) {

    Person.graduateFrom = "传智学院";

    Person p = new Person();

    p.name = "小苍同学";

    p.age = 18;

    //p.graduateFrom = "传智学院";

    p.speak();

    Person p2 = new Person();

    p2.name = "小波同学";

    p2.age = 20;

    //p2.graduateFrom = "传智学院";

    p2.speak();

    }

    }

    class Person {

    String name;

    int age;

    static String graduateFrom;//毕业院校

    public void speak() {

    System.out.println(name + "---" + graduateFrom);

    }

    }

    2.3 静态的注意事项

      A:静态成员只能直接访问静态成员

      B:非静态成员既可以访问非静态成员也可以访问静态成员

    2.3.1 案例代码五

     package com.itheima_01;

    /*

     * static的注意事项:

     * 静态方法:

     * 可以调用静态的成员变量

     * 可以调用静态的成员方法

     * 不可以调用非静态成员变量

     * 不可以调用非静态成员方法

     * 静态方法只能调用静态的成员

     * 非静态方法:

     * 可以调用静态的成员变量

     * 可以调用静态的成员方法

     * 可以调用非静态的成员变量

     * 可以调用非静态的成员方法

     *

     * 静态的方法中是否有this这个对象?没有的

     *

     *

     */

    public class StaticDemo2 {

    public static void main(String[] args) {

    Student.graduateFrom = "传智学院";

    Student.study();

    }

    }

    class Student {

    String name;

    int age;

    static String graduateFrom;//毕业院校

    public static void study() {

    ///System.out.println(graduateFrom);

    //sleep();

    //System.out.println(name);

    //eat();

    }

    public static void sleep() {

    System.out.println("sleep");

    }

    public void eat() {

    System.out.println("eat");

    System.out.println(graduateFrom);

    sleep();

    }

    }

    2.4 静态的优缺点

    A:静态优点:

    对对象的共享数据提供单独空间的存储,节省空间,没有必要每一个对象都存储一份

    可以直接被类名调用,不用在堆内存创建对象

    静态成员可以通过类名直接访问,相对创建对象访问成员方便

      B:静态弊端:

    访问出现局限性。(静态虽好,但只能访问静态)

    2.5 静态应用

    2.5.1 Math类使用

    A:Math 类包含用于执行基本数学运算的方法。数学操作常用的类。

    B:Math类的构造方法被private,无法创建对象,也就无法通过对象来访问Math类中的成员

     C:Math类中所有的成员都被静态修饰,因此我们可以直接通过类名访问

    2.5.1.1 案例代码三:

    package com.itheima_02;

    public class MathDemo {

    public static void main(String[] args) {

    //Math:包含了一些基本的数学运算方法

    //static double PI  

    //System.out.println(Math.PI);

    //static double abs(double a)  :返回绝对值

    //System.out.println(Math.abs(15));15

    //System.out.println(Math.abs(-10));10

    //static double ceil(double a) 天花板   向上取整

    //System.out.println(Math.ceil(1.2));2

    //System.out.println(Math.ceil(1.6));2

    //System.out.println(Math.ceil(-1.6));-1

    //static double floor(double a)  地板  向下取整

    //System.out.println(Math.floor(1.2));1

    //System.out.println(Math.floor(1.6));1

    //System.out.println(Math.floor(-1.6));-2

    //static long round(double a)  :四舍五入

    //System.out.println(Math.round(1.2));1

    //System.out.println(Math.round(1.6));2

    //static double max(double a, double b)

    //System.out.println(Math.max(3, 4));4

    //static double pow(double a, double b) :返回第一个参数的第二个参数次幂

    //System.out.println(Math.pow(3, 2));8

    //static double random() :返回一个随机数,大于零且小于一

    System.out.println(Math.random());

    }

    }

    2.5.2 自定义工具类

    A:需求:自定义一个专门对数组操作的工具类,具有的功能如下

    1.定义一个方法,该方法可以返回数组中最大元素

    2.定义一个方法,该方法根据指定的值去数组中查找是否存在该值

    存在,返回该值在数组中的索引

    不存在,返回-1

    2.5.2.1 案例代码四:

    package com.itheima_03;

    public class MyArrays {

    private MyArrays() {}

    /*

    * 返回数组中最大的元素

    *

    */

    public static int getMax(int[] arr) {

    int max = 0;//参照物

    //遍历数组

    for(int x = 0;x < arr.length;x++) {

    if(arr[x] > max) {

    max = arr[x];//替换参照物

    }

    }

    return max;

    }

    /*

    * 返回数组中指定参数的索引

    *

    */

    public static int getIndex(int[] arr,int a) {

    //遍历数组

    for(int x = 0;x < arr.length;x++) {

    if(arr[x] == a) {

    return x;

    }

    }

    return -1;//如果查不到制定的参数,则返回-1

    }

    }

    package com.itheima_03;

    public class MyArraysDemo {

    public static void main(String[] args) {

    int[] arr = {3,5,8,10,1};

    int max = MyArrays.getMax(arr);

    System.out.println(max);

    int index = MyArrays.getIndex(arr, 8);

    System.out.println(index);

    }

    }

    2.6 类变量与实例变量辨析

    A:类变量:其实就是静态变量

         定义位置:定义在类中方法外

         所在内存区域:方法区

    生命周期:随着类的加载而加载

    特点:无论创建多少对象,类变量仅在方法区中,并且只有一份

    B:实例变量:其实就是非静态变量

         定义位置:定义在类中方法外

         所在内存区域:堆

         生命周期:随着对象的创建而加载

         特点:每创建一个对象,堆中的对象中就有一份实例变量

    第3章 代码块

    3.1 局部代码块

    局部代码块是定义在方法或语句中

    3.1.1 案例代码六:

    public class BlockDemo {

    public static void main(String[] args) {

    //局部代码块:存在于方法中,控制变量的生命周期(作用域)

    {

    for(int x = 0;x < 10;x++) {

    System.out.println("我爱Java");

    }

    int num = 10;

    }

    //System.out.println(num);//无法访问num,超出num的作用域范围

    }

    }

    3.2 构造代码块

    构造代码块是定义在类中成员位置的代码块

    3.2.1 案例代码七:

    package com.itheima_04;

    class Teacher {

    String name;

    int age;

    {

    for(int x = 0;x < 10;x++) {

    System.out.println("我爱Java");

    }

    System.out.println("我爱Java");

    }

    public Teacher() {

    System.out.println("我是无参空构造");

    }

    public Teacher(String name,int age) {

    System.out.println("我是有参构造");

    this.name = name;

    this.age = age;

    }

    }

    3.3 静态代码块

    A:静态代码块是定义在成员位置,使用static修饰的代码块

    3.3.1 案例代码八:

    class Teacher {

    String name;

    int age;

    //静态代码块:随着类的加载而加载,只加载一次,加载类时需要做的一些初始化,比如加载驱动

    static {

    System.out.println("我爱Java");

    }

    public Teacher() {

    System.out.println("我是无参空构造");

    }

    public Teacher(String name,int age) {

    System.out.println("我是有参构造");

    this.name = name;

    this.age = age;

    }

    }

    3.4 每种代码块特点:

    3.4.1 局部代码块:

    以”{}”划定的代码区域,此时只需要关注作用域的不同即可

    方法和类都是以代码块的方式划定边界的

    3.4.2 构造代码块

    优先于构造方法执行,构造代码块用于执行所有对象均需要的初始化动作

    每创建一个对象均会执行一次构造代码块。

    3.4.3 静态代码块

    它优先于主方法执行、优先于构造代码块执行,当以任意形式第一次使用到该类时执行。

    该类不管创建多少对象,静态代码块只执行一次。

    可用于给静态变量赋值,用来给类进行初始化。

    3.4.4 案例代码九:

    package com.itheima_04;

    /*

     *   Coder静态代码块执行 --- Coder构造代码块执行 --- Coder无参空构造执行

     *   

     *   

     *   BlockTest静态代码块执行 --- BlockTest的主函数执行了 --- Coder静态代码块执行 --- Coder构造代码块执行 --- Coder无参空构造执行

     *   Coder构造代码块执行 --- Coder无参空构造执行

     *

     */

    public class BlockTest {

    static {

    System.out.println("BlockTest静态代码块执行");

    }

    {

    System.out.println("BlockTest构造代码块执行");

    }

    public BlockTest(){

    System.out.println("BlockTest无参构造执行了");

    }

    public static void main(String[] args) {

    System.out.println("BlockTest的主函数执行了");

    Coder c = new Coder();

    Coder c2 = new Coder();

    }

    }

    class Coder {

    static {

    System.out.println("Coder静态代码块执行");

    }

    {

    System.out.println("Coder构造代码块执行");

    }

    public Coder() {

    System.out.println("Coder无参构造执行");

    }

    }

  • 相关阅读:
    Delphi公用函数单元
    Delphi XE5 for Android (十一)
    Delphi XE5 for Android (十)
    Delphi XE5 for Android (九)
    Delphi XE5 for Android (八)
    Delphi XE5 for Android (七)
    Delphi XE5 for Android (五)
    Delphi XE5 for Android (四)
    Delphi XE5 for Android (三)
    Delphi XE5 for Android (二)
  • 原文地址:https://www.cnblogs.com/bigorangehasc/p/8639240.html
Copyright © 2011-2022 走看看