Java高级 - 技术栈

类变量/静态变量package com.study.static_;

通过static关键词声明,是该类所有对象共享的对象,任何一个该类的对象去访问他的时候,取到的都是相同的词,同样任何一个该类的对象去修改,所修改的也是同一个对象.

如何定义及访问?

遵循相关访问权限

访问修饰符 static 数据类型变量名;(推荐)

static 访问修饰符数据类型变量名;都可

通过类名.类变量名(推荐)或对象名.类变量名

使用细节

1.想让某个类的所有对象使用同一个变量时可以使用类变量

2.与普通属性的区别是是否是共享

3.声明和修饰**访问修饰符 static 数据类型变量名; 类名.类变量名,**需满足访问权限

4.实例变量不可以用类名.变量名.

5.类变量是在类加载的时候就初始化了.也就是说,即使没有创建对象,只要类加载了就可以使用类变量了

6.类变量的生命周期是随类的加载开始,随类的消亡而销毁

类变量内存剖析

1.静态变量是被对象共享的

2.类加载的时候就生成了

类方法

声明和调用

访问修饰符 static 数据返回类型方法名(){}; (推荐)

static 访问修饰符数据返回类型方法名(){};都可

遵循相关访问权限

通过类名.类方法名(推荐)或对象名.类方法

最佳实践

当方法中不涉及到任何和对象相关的成员,则可以将方法设计成静态方法,提高开发效率,如排序.打印数组...

注意事项

1.类方法和普通方法都随着类的加载而加载,而构造器是创建对象的时候初始化,将结构信息存储在方法区

2.类方法中无this参数

3.可以通过类名和对象名调用,普通方法和对象名有关,需要通过对象名调用

4.类方法中不允许使用和对象有关的关键词,如super,this,普通方法可以

5.类方法中只能访问静态变量和静态方法

6.普通成员方法,既可以访问普通方法又可以访问静态方法

静态VS非静态

在Java中，每次使用new关键字创建类的实例时，都会在内存（主要是堆内存）中为该实例分配一块新的空间。这块空间是独立的，用于存储该实例的所有属性（无论是静态的还是非静态的，但这里有一个重要的区别需要注意）。

对于非静态属性（也称为实例变量或成员变量），它们是属于类的每个实例的。每个实例都会拥有自己独立的这些属性的副本。因此，当你修改一个实例的非静态属性时，这个修改只会影响那个特定的实例，而不会影响到其他实例或类的其他任何部分。

然而，对于静态属性（也称为类变量），情况就不同了。静态属性是属于类的，而不是属于类的任何特定实例。这意味着无论创建多少个类的实例，这些实例都会共享同一个静态属性。因此，对静态属性的修改会影响到所有实例。

main方法package com.study.main;

1.main方法是java虚拟机调用

2.因java虚拟机需要调用main方法,故main方法访问权限必须是public

3.java虚拟机在执行main方法是不必创建对象,故该方法必须是static

4.该方法接收String类型的数组参数,该数组中保存执行java命令时传递给所运行的类的参数

5.java执行的程序 String[] args数组名,传入参数

特别说明

1.main方法中,我们可以直接调用main方法所在类的静态方法和静态属性

2.但不能直接访问该类中的非静态成员,必须创建该类的一个实例对象后,才能调用这个对象去访问类中的非静态成员

复制代码

package com.study.main;

public class Main01 {
    private static String name = "韩顺平教育";
    public static void hi(){
        System.out.println("Main01的 hi方法");
    }
    private int n1=1000;
    private static int n2=2000;
    public void cry(){
        System.out.println("Main01的cry方法");
    }
    public static void main(String[] args) {
         //1.静态方法可以访问本类的静态成员
        System.out.println("name="+name);
        hi();
        //2.静态方法main 不可以访问本类的非静态成员
//        System.out.println("n1"+n1);x
//        cry();也不行,需要创建对象来用
        new Main01().cry();
    }
}

代码块package com.study.codeblock;

基本介绍

代码块又称初始化块,属于类中的成员[即是类的一部分],类似于方法,将逻辑语句封装在方法体中,通过{}包围起来

但和方法不同,没有方法名,没有返回,没有参数,只有方法体,而且不用通过对象或类显示调用,而是加载类时(静态),或创建对象时隐式调用

基本语法

接口多态特性

1.创建多个类接收接口,每个类中都提供接口中声明方法的具体实现,这些实现可以各不相同,体现出接口的多态

2.多态性的真正力量在于能够使用接口类型的引用来引用实现了该接口的任何对象

3.多态数组,让接口类型的引用分别指向不同的实例对象

4.多态传递现象:让一个接口继承一个接口,访问接口的变量接口.属性

访问父类super.属性访问本类 this.属性

复制代码

package com.study.Interface_;

public class InterfaceExmple {
}
interface Animal {
    void makeSound();
}
class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("小狗汪汪叫");
    }
}

class Cat1 implements Animal {
    @Override
    public void makeSound() {
        System.out.println("我嘞个骚刚");
    }
    public void food(){
        System.out.println("coke爱看美女");
    }
}
class TestPolymorphism {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat1();

        // 调用同一个方法，但根据对象的实际类型执行不同的操作
        //myDog.makeSound(); // 输出: Woof!
        //myCat.makeSound(); // 输出: Meow!
        //定义接口数组,让接口数组的引用指向实例对象
       // Animal[] animal = {myDog, myCat};
        Animal[] animal1 = new Animal[2];
        animal1[0] = new Dog();
        animal1[1] = new Cat1();
        for(int i=0;i<animal1.length;i++){
            animal1[i].makeSound();//动态绑定,输出不同
            //想要调用Cat1的特有方法需要进行类似于向下转型的操作
            if(animal1[i] instanceof Cat1){
                ((Cat1)animal1[i]).food();
            }
        }
    }
}
package com.study.Interface_;

/**
 * 演示多态传递现象
 */
public class InterfacePloyPass {
    public static void main(String[] args) {
        //接口类型的变量可以指向,实现了接口对象的实例
        IG ig = new Teacher();
        //如果IG 继承了 IH 接口,而Teacher类实现了IG 接口
        //那么实际上就相当于 Teacher类也实现了IH 接口
        //这就是 接口多态传递现象
        IH ih = new Teacher();
    }
}

interface IH{}
interface IG extends IH{}
class Teacher implements IG{

}

内部类***package com.study.innerclass;

一个类的内部又完整的嵌套了另一个类结构.被嵌套的称为内部类.

类的五大成员

属性方法构造器代码块内部类

内部类的分类

定义在外部类局部位置上(比如方法内)

1.局部内部类(有类名)

2.匿名内部类(没有类名,*******)

定义在外部类的成员位置上:

3.成员内部类(没有static修饰)

4.静态内部类(使用static修饰)

局部内部类

1.局部内部类定义在外部类的局部位置,通常在方法,并且有类名

2.//不能添加访问修饰符,但可以用final修饰,他类似于局部变量,这也导致了外部其他类不能访问局部内部类

3.可以直接访问外部类的所有成员,包括私有成员

4.作用域:仅仅在定义它的方法和代码块中

5.外部类可以在方法中,创建内部类的对象实例,然后调用方法

6.如果外部类和局部内部类的成员重名时,默认遵循就近原则,如果想访问外部类的成员可以使用(外部类名.this.成员)去访问

LocallnnerClass

匿名内部类*****

本质还是类,而且是内部类,该类有没名字,同时还是一个对象

基本语法

new 类或接口(参数列表){

类体

};

这个类或接口会被隐式的继承或实现

细节

1.匿名内部类就是一个类的定义,同时它本身也是一个对象

2.可以直接访问外部类的所有成员包括私有

3.不能添加访问修饰符,因为他只是一个局部变量

4.作用域:仅仅在它定义的方法或代码块中

5.外部其他类不能访问匿名内部类

6.如果外部类和匿名内部类的成员重名时,匿名内部类访问的话,默认遵循就近原则,如果想访问外部类成员,则可以使用(外部类名.this.成员)去访问

7.匿名内部类必须继承一个父类或实现一个接口，但不能同时继承一个父类和实现一个接口,一般是在定义的时候隐式实现,

复制代码

package com.study.innerclass;

public class AnonymousInnerClass {
    public static void main(String[] args) {
        new Outer04().method();
    }
}

class Outer04 {
    private int n1 = 10;

    public void method() {
        //基于接口的匿名内部类
        //对于只是用一次的类去创建对象实现接口比较麻烦
        //可以使用匿名内部类来简化开发
        //tiger的编译类型是?A等号左边,运行类型就是匿名内部类XXX=>Outer04$1
        /*
        * 我们看底层,底层会分配一个类名
        * class XXX implements A{
            * @Override
            * public void cry() {
                    System.out.println("老虎叫唤...");
                }
              }
        * */
        //jdk底层创建匿名内部类,立即就创建了Outer04$1实例,并把地址返回给tiger
        //匿名内部类使用一次就不能再使用,但对象会存在
        A tiger = new A() {
            public void cry() {
                System.out.println("老虎叫唤...");
            }
        };
        System.out.println("tiger的运行类型" + tiger.getClass());
        //tiger的运行类型class com.study.innerclass.Outer04$1
        tiger.cry();
        //演示基于类的匿名内部类
        //编译类型Father,运行类型Outer04$2按顺序...
        //Father father = new Father("jack");带大括号就是匿名内部类了
        //底层会创建匿名内部类
        /*
            class Outer04$2 extends Father{
                  @Override
                public void test() {
                    System.out.println("匿名内部类重写了test方法");
                }
            }
         */
        //参数列表会传递给构造器
        Father father = new Father("jack") {
            @Override
            public void test() {
                System.out.println("匿名内部类重写了test方法");
            }
        };//隐式的继承了Father类
        System.out.println("father的运行类型是" + father.getClass());
        //father的运行类型是class com.study.innerclass.Outer04$2
        father.test();
        //基于抽象类的匿名内部类
        B b = new B(){
            @Override
            public void eat(){
                System.out.println("重写了抽象类的方法eat()");
            }
        };
        b.eat();
    }
}

interface A {
    public void cry();
}

class Father {
    public Father(String name) {
        System.out.println("接收到了name="+name);
    }

    public void test() {
    }
}
abstract class B{
    abstract void eat();
}

匿名内部类的最佳实践

将匿名内部类当做实参传递,更加简洁高效

复制代码

package com.study.innerclass;

public class InnerClassExercise {
    public static void main(String[] args) {
        CellPhone cellphone = new CellPhone();
        cellphone.alarmClock(new Bell(){
            @Override
            public void ring(){
                System.out.println("懒猪起床了");
            }
        });
        cellphone.alarmClock(new Bell(){//隐式的实现了Bell接口
            @Override
            public void ring(){
                System.out.println("上课了");
            }
        });
    }
}

interface Bell{
    void ring();
}
class CellPhone{
    public void alarmClock(Bell bell){//形参是接口类型
        bell.ring();//传进来的bell运行类型是匿名内部类型,调用ring的时候
        //会访问匿名内部类的ring()方法,导致匿名内部类中怎样重写就怎样输出
    }
}

成员内部类

定义在外部类的成员位置,并且没有static修饰

1.可以直接访问外部类的所有成员包括私有

2.可以添加任意访问修饰符,因为他的地位就是一个成员

3.作用域:整个类体

4.外部类可以通过创建对象的方式来访问成员内部类

5.外部其他类访问成员内部类的方式看例子, 在外部其他类创建外部类的对象.内部类内部类对象 = 外部类的对象.new 内部类

也可以写一个方法

6.如果外部类和成员内部类的成员重名时,成员内部类访问的话,默认遵循就近原则,如果想访问外部类成员,则可以使用(外部类名.this.属性)去访问

复制代码

package com.study.innerclass;

public class MemberInnerClass01 {
    public static void main(String[] args) {
        Outer03 outer03 = new Outer03();
        outer03.t1();
        //外部其他类访问成员内部类的方式
        //将Inner03成员内部类看做一个属性来访问;相当于把 new Inner03()当做Outer03的成员
        Outer03.Inner03 inner08 = outer03.new Inner03();
        //第二种方式,在外部类中,编写一个方法可以放回Inner03对象
        Outer03.Inner03 inner03 = outer03.getInner03();
        inner03.say();
        
    }
}

class Outer03{
    private int n1 = 10;
    public String name = "张三";
    private void hi(){
        System.out.println("hi");
    }
    class Inner03{
        private double sal = 99.8;
        public void say(){
            System.out.println("n1="+n1+",name="+name);
            hi();
        }
    }
    Inner03 inner03 = new Inner03();
    public void t1(){
        //使用成员内部类
        System.out.println(inner03.sal);
        Inner03 in = new Inner03();
        in.say();
    }
    public Inner03 getInner03(){
        return new Inner03();
    }
}

静态内部类

1.放在外部类的成员位置

2.使用static修饰,可以添加任意访问修饰符

3.可以访问外部类的所有静态成员,包括私有,但不能访问非静态成员

4.作用域:同其他的成员,为整个类体

5.静态内部类可以访问外部类的所有静态成员

6.外部类访问静态内部类需要创建对象在访问

7.外部其他类想访问

复制代码

//方式1
Outer10.Inner10 inner10 = new Outer10.Inner10();
inner10.say();//通过对象名直接访问但需遵循访问权限
//方式2
//编写一个一个方法,可以返回静态内部类的对象实例
Outer10.Inner10 inner101 = outer10.getInner10();
inner101.say();
Outer10.Inner10 inner102 = outer10.getInner10_();
inner102.say();

8.如果外部类和静态内部类的成员重名时,静态内部类访问的话,默认遵循就近原则,如果想访问外部类成员,则可以使用(外部类名.属性)去访问