DevOps开发运维
成长之路

Java面向对象编程(高级)

ChildGame.java

package com.hspedu.static_;

public class ChildGame {
    public static void main(String[] args) {
        //定义一个变量count,统计有多少小孩加入游戏
        int count = 0;
        
        Child child1 = new Child("小明");
        child1.join();
        count++;

        Child child2 = new Child("小红");
        child1.join();
        count++;

        Child child3 = new Child("小辉");
        child1.join();
        count++;

        System.out.println("共有" + count + "名小孩加入了游戏");
    }
}

class Child {
    private String name;

    public Child(String name) {
        this.name = name;
    }

    public void join(){
        System.out.println(name + "加入了游戏");
    }
}

ChildGame.java

package com.hspedu.static_;

public class ChildGame {
    public static void main(String[] args) {

        Child child1 = new Child("小明");
        child1.join();
        child1.count++;

        Child child2 = new Child("小红");
        child1.join();
        child2.count++;

        Child child3 = new Child("小辉");
        child1.join();
        child3.count++;

        //类变量,可以通过类名来访问
        System.out.println("共有" + Child.count + "名小孩加入了游戏");
        //下面的代码输出的都是3
        System.out.println("child1.count=" +child1.count);
        System.out.println("child2.count=" +child2.count);
        System.out.println("child3.count=" +child3.count);
    }
}

class Child {
    private String name;
    //定义一个变量count,是一个类变量(静态变量)
    //该变量最大的特点就是会被Child类的所有对象实例共享
    public static int count = 0;
    public Child(String name) {
        this.name = name;
    }

    public void join(){
        System.out.println(name + "加入了游戏");
    }
}

 

 

https;//blog.csdn.net/x_iya/article/details/81260154/
https://www.zhihu.com/question/59174759/answer/163207831

VisitStatic.java

package com.hspedu.static_;

public class VisitStatic {
    public static void main(String[] args) {
        //类名.类变量名
        //类变量是随着类的加载而创建,所以即使没有创建对象实例也可以访问
        System.out.println(A.name);
        A a = new A();
        //通过对象名.类变量名
        System.out.println("a.name = " + a.name);
        //类变量的访问,必须遵守相关的访问权限
        //System.out.println(A.edu);
    }
}

class A {
    //类变量
    public static String name = "韩顺平教育";
    //类变量的访问,必须遵守相关的访问权限
    private static String edu = "韩顺平教育";
    //普通属性/普通成员变量/非静态成员变量/非静态属性/实例变量
    private int num = 10;
}

StaticDetail.java

package com.hspedu.static_;

public class StaticDetail {
    public static void main(String[] args) {
        B b = new B();
        //5.实例变量不能通过类名.类变量名方式进行访问
        //System.out.println(B.n1);
        System.out.println(B.n2);
        //6.静态变量是类加载的时候就创建了,所以我们没有创建对象实例,也可以通过类名.类变量名来访问
        System.out.println(C.address);
    }
}

class B {
    public int n1 = 100;
    public static int n2 = 200;
}

class C{
    public static String address = "北京";
}

StaticMethod.java

package com.hspedu.static_;

public class StaticMethod {
    public static void main(String[] args) {
        Stu tmo = new Stu("tmo");
        //tmo.payFee(100);//正确
        Stu.payFee(100);//正确
        Stu mary = new Stu("mary");
        Stu.payFee(200);//正确
        //mary.payFee(200);//正确

        //输出当前收到的总学费
        Stu.shouFee();//300

        //如果我们希望不创建实例,也可以调用某个方法,把方法做成静态方法时非常适合
        System.out.println("9开平方的结果=" + Math.sqrt(9));

        System.out.println(MyTools.calSum(10,30));
    }
}

class Stu{
    private String name;
    //定义一个静态变量,来累计学生学费
    private static double fee = 0;

    public Stu(String name) {
        this.name = name;
    }
    //1.当方法使用了static方法修饰后,该方法就是静态方法
    //2.静态方法就可以访问静态属性变量
    public static void payFee(double fee){
        Stu.fee += fee;
    }
    public static void shouFee(){
        System.out.println("总学费有:" + Stu.fee);
    }

}

//开发自己的工具类时,可以将方法做成静态的,方便调用
class MyTools{
    public static double calSum(double n1,double n2){
        return n1+n2;
    }
}

StaticMethodDetail.java

package com.hspedu.static_;

public class StaticMethodDetail {
    public static void main(String[] args) {
        D.hi();//ok
        //D.say();//错误,3.非静态方法不能通过类名调用,需要先创建对象再调用
        D d = new D();
        d.say();
    }
}

class D {
    private int n1 = 100;
    private static int n2 = 200;
    public void say(){

    }
    public static void hi(){
    //4.类方法中不允许使用和对象有关的关键字,比如this和super,普通方法(成员方法)可以
        //System.out.println(this.n1);//错误
    }

    //5.类方法中,只能访问静态变量或者静态方法
    //口诀:静态方法只能访问静态成员
    public static void hello(){
        System.out.println(n2);//ok
        System.out.println(D.n2);//ok
        //System.out.println(n1);//错误
        //System.out.println(this.n2);//错误
        hi();//ok
        //say();//错误
    }

    //普通成员方法,即可访问非静态成员,也可以访问静态成员
    //小结:非静态方法可以访问静态成员和非静态成员
    public void ok(){
        //非静态成员
        System.out.println(n1);
        say();
        //静态成员
        System.out.println(n2);
        hello();
    }
}

Hello.java

public class Hello {
    public static void main(String[] args){
        //args是如何传入
        //遍历显示
        for(int i = 0;i < args.length;i++){
            System.out.println("第"+ (i+1) + "个参数=" + args[i]);
        }
    }
}

Main01.java

package com.hspedu.main;

public class Main01 {

    //静态变量/属性
    private static String name = "韩顺平教育";
    //静态方法
    public static void hi(){
        System.out.println("Main01的hi方法");
    }

    //非静态变量/属性
    private int n1 = 10000;
    //非静态方法
    public void cry(){
        System.out.println("Main01的cry方法");
    }
    public static void main(String[] args) {
        //可以直接使用name
        //1.静态方法main 可以访问本类的静态成员
        System.out.println("name=" + name);
        hi();

        //2.静态方法main不可以访问本类的非静态成员
        //System.out.println("n1=" + n1);//错误
        //cry();//错误
        //3.如果静态方法main要访问本类的非静态成员,需要先创建对象,再调用即可
        Main01 main01 = new Main01();//ok
        System.out.println(main01.n1);//ok
        main01.cry();//ok
    }
}

Main02.java

package com.hspedu.main;

public class Main02 {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "] = " + args[i]);
        }
    }
}
//
//args[0] = 北京
//...

CodeBlock01.java

package com.hspedu.codeblock_;

public class CodeBlock01 {
    public static void main(String[] args) {
        Movie movie = new Movie("你好,李焕英");
        System.out.println("=============");
        new Movie("唐人街探案",100,"陈思诚");
    }
}

class Movie{
    private String name;
    private double price;
    private String director;

    //3个构造器->重载
    //1.下面单个构造器都有相同的语句
    //2.代码比较冗余
    //3.可以把相同的语句放在一个代码块中
    //4.当我们不管调用哪个构造器创建对象,都会先调用代码块的内容
    //5.代码块调用的顺序优先于构造器
    {
        System.out.println("电影屏幕打开...");
        System.out.println("广告开始...");
        System.out.println("电影正式开始...");
    }

    public Movie(String name) {
//        System.out.println("电影屏幕打开...");
//        System.out.println("广告开始...");
//        System.out.println("电影正式开始...");
        System.out.println("Movie(String name)构造器被调用");
        this.name = name;
    }

    public Movie(String name, double price) {
//        System.out.println("电影屏幕打开...");
//        System.out.println("广告开始...");
//        System.out.println("电影正式开始...");
        System.out.println("Movie(String name, double price)构造器被调用");
        this.name = name;
        this.price = price;
    }

    public Movie(String name, double price, String director) {
//        System.out.println("电影屏幕打开...");
//        System.out.println("广告开始...");
//        System.out.println("电影正式开始...");
        System.out.println("Movie(String name, double price, String director)构造器被调用");
        this.name = name;
        this.price = price;
        this.director = director;
    }
}

CodeBlockDetail01.java

package com.hspedu.codeblock_;

public class CodeBlockDetail01 {
    public static void main(String[] args) {
        //类被加载的情况举例:
        // 1.创建对象实例时(new)
        //AA aa = new AA();
        /**
         * AA的静态代码块1被执行...
         */
        //2.创建子类对象实例,父类也会被加载,而且父类先被加载,子类后被加载
        //AA aa2 = new AA();
        /**
         *BB的静态代码块1被执行...
         *AA的静态代码块1被执行...
         */
        //3.使用类的静态成员时(静态属性,静态方法)
        //System.out.println(Cat.n1);
        /**
         * Animal的静态代码1被执行...
         * Cat的静态代码1被执行...
         * 999
         */
        //static代码块是在类加载时执行的,而且只会执行一次
        //DD dd = new DD();
        //DD dd1 = new DD();
        /**
         * DD的静态代码1被执行...
         * DD的静普通代码块...
         * DD的静普通代码块...
         */
        //普通的代码块,在创建对象实例时,会被隐式的调用。
        //被创建一次,就会调用一次。如果只是使用类的静态成员时,普通代码块并不会执行
        System.out.println(DD.n1);
        /**
         * DD的静态代码1被执行...
         * 8888
         */

    }
}

class DD {
    public static int n1 = 8888;//静态属性
    //静态代码块
    static {
        System.out.println("DD的静态代码1被执行...");
    }
    //普通代码块,在new对象时,被调用,每创建一个对象,就调用一次
    {
        System.out.println("DD的静普通代码块...");
    }
}

class Animal {
    static {
        System.out.println("Animal的静态代码1被执行...");
    }
}
class Cat extends Animal{
    public static int n1 = 999;//静态属性
    //静态代码块
    static {
        System.out.println("Cat的静态代码1被执行...");
    }
}
class BB{
    //静态代码块
    static {
        System.out.println("BB的静态代码块1被执行...");
    }
}

class AA extends BB{

    //静态代码块
    static {
        System.out.println("AA的静态代码块1被执行...");
    }
}

CodeBlockDetail02.java

package com.hspedu.codeblock_;


public class CodeBlockDetail02 {
    public static void main(String[] args) {
        A a = new A();
        /**
         * getN1被调用...
         * A 静态代码块01
         * getN2被调用...
         * A 普通代码块01
         * A()构造器被调用
         */
    }
}

class A{
    private int n2 = getN2();//普通属性的初始化
    {//普通代码块
        System.out.println("A 普通代码块01");
    }

    //静态属性的初始化
    private static int n1 = getN1();

    static {//静态代码块
        System.out.println("A 静态代码块01");
    }

    public static int getN1(){
        System.out.println("getN1被调用...");
        return 100;
    }
    public int getN2(){
        System.out.println("getN2被调用...");
        return 200;
    }

    //无参构造器

    public A() {
        System.out.println("A()构造器被调用");
    }
}

CodeBlockDetail03.java

package com.hspedu.codeblock_;

public class CodeBlockDetail03 {
    public static void main(String[] args) {
        new BBB();
        /**
         * AAA的普通代码块...
         * AAA()构造器被调用...
         * BBB的普通代码块
         * BBB()构造器被调用...
         */
    }
}

class AAA{
    {
        System.out.println("AAA的普通代码块...");
    }
    public AAA() {
        //1.隐藏super();
        //2.调用本类的普通代码块
        System.out.println("AAA()构造器被调用...");
    }
}

class BBB extends AAA{
    {
        System.out.println("BBB的普通代码块");
    }

    public BBB() {
        //1.隐藏super();
        //2.调用本类的普通代码块
        System.out.println("BBB()构造器被调用...");
    }
}

CodeBlockDetail04.java

package com.hspedu.codeblock_;

public class CodeBlockDetail04 {
    public static void main(String[] args) {
        //老师说明
        //(1) 进行类的加载
        //1.1 先加载 父类 A02
        //1.2 再加载 B02
        //(2) 创建对象
        //2.1 从子类的构造器开始
        new B02();//对象
        /**
         * getVal01
         * A02的一个静态代码块..
         * getVal03
         * B02的一个静态代码块..
         * A02的第一个普通代码块..
         * getVal02
         * A02的构造器
         * getVal04
         * B02的第一个普通代码块..
         * B02的构造器
         */

        //new C02();
    }
}

class A02 { //父类
    private static int n1 = getVal01();
    static {
        System.out.println("A02的一个静态代码块..");//(2)
    }
    {
        System.out.println("A02的第一个普通代码块..");//(5)
    }
    public int n3 = getVal02();//普通属性的初始化
    public static int getVal01() {
        System.out.println("getVal01");//(1)
        return 10;
    }

    public int getVal02() {
        System.out.println("getVal02");//(6)
        return 10;
    }

    public A02() {//构造器
        //隐藏
        //super()
        //普通代码和普通属性的初始化......
        System.out.println("A02的构造器");//(7)
    }

}

class B02 extends A02 { //

    private static int n3 = getVal03();

    static {
        System.out.println("B02的一个静态代码块..");//(4)
    }
    public int n5 = getVal04();
    {
        System.out.println("B02的第一个普通代码块..");//(9)
    }

    public static int getVal03() {
        System.out.println("getVal03");//(3)
        return 10;
    }

    public int getVal04() {
        System.out.println("getVal04");//(8)
        return 10;
    }
    //一定要慢慢的去品..
    public B02() {//构造器
        //隐藏了
        //super()
        //普通代码块和普通属性的初始化...
        System.out.println("B02的构造器");//(10)
        // TODO Auto-generated constructor stub
    }
}

class C02 {
    private int n1 = 100;
    private static  int n2 = 200;

    private void m1() {

    }
    private static void m2() {

    }

    static {
        //静态代码块,只能调用静态成员
        //System.out.println(n1);错误
        System.out.println(n2);//ok
        //m1();//错误
        m2();
    }
    {
        //普通代码块,可以使用任意成员
        System.out.println(n1);
        System.out.println(n2);//ok
        m1();
        m2();
    }
}


package com.hspedu.codeblock_;

public class CodeBlockExercise01 {
}
class Person {
    public static int total;//静态变量
    static {//静态代码块
        total = 100;
        System.out.println("in static block!");//(1)
    }
}

class Test1 {
    public static void main(String[] args) {
        System.out.println("total = "+ Person.total); //100
        System.out.println("total = "+ Person.total); //100
    }
}
/**
 * in static block!
 * total = 100
 * total = 100
 */

package com.hspedu.codeblock_;

public class CodeBlockExercise02 {
}

class Sample
{
    Sample(String s)
    {
        System.out.println(s);
    }
    Sample()
    {
        System.out.println("Sample默认构造函数被调用");
    }
}
class Test{
    Sample sam1=new Sample("sam1成员初始化");//
    static Sample sam=new Sample("静态成员sam初始化 ");//
    static{
        System.out.println("static块执行");//
        if(sam==null)System.out.println("sam is null");
    }
    Test()//构造器
    {
        System.out.println("Test默认构造函数被调用");//
    }
    //主方法
    public static void  main(String  str[])
    {
        Test a=new Test();//无参构造器
    }

}
/**
 * 静态成员sam初始化
 * static块执行
 * sam1成员初始化
 * Test默认构造函数被调用
 */

SingleTon01.java

package com.hspedu.single_;

public class SingleTon01 {
    public static void main(String[] args) {
        //GirlFriend xh = new GirlFriend("小红");
        //GirlFriend xb = new GirlFriend("小白");

        //通过方法可以获得对象
        System.out.println(GirlFriend.getInstance());
        GirlFriend instance1 = GirlFriend.getInstance();
        System.out.println(instance1);
        GirlFriend instance2 = GirlFriend.getInstance();
        System.out.println(instance2);
        System.out.println(instance1 == instance2);
        /**
         * GirlFriend{name='小红红'}
         * GirlFriend{name='小红红'}
         * GirlFriend{name='小红红'}
         * true
         */
        System.out.println(GirlFriend.n1);
        /**
         * 构造器被调用
         * 100
         */
        //饿汉式:在执行上面语句时,还没有用到gf对象,但是处于类的机制,gf对象已经创建好了
    }
}

//有一个类 GirlFriend
//只能有一个女朋友
class GirlFriend{
    private String name;

    public static int n1 = 100;
    //为了能够在静态方法中 ,返回gf对象,需要将其修饰为static
    //对象通常是重量级的对象,饿汉式可能造成创建了对象,但是没有使用
    private static GirlFriend gf = new GirlFriend("小红红");
    //如何保证只能创建一个GirlFriend对象
    //步骤[单例模式-饿汉式]:
    //1.将构造器私有化
    //2.在类的内部直接创建对象(该对象是static)
    //3.提供一个公共的static方法,返回gf对象
    private GirlFriend(String name) {
        System.out.println("构造器被调用");
        this.name = name;
    }
    public static GirlFriend getInstance(){
        return gf;
    }

    @Override
    public String toString() {
        return "GirlFriend{" +
                "name='" + name + '\'' +
                '}';
    }
}

SingleTon02.java

package com.hspedu.single_;

/**
 * 演示懒汉式的单例模式
 */
public class SingleTon02 {
    public static void main(String[] args) {
        System.out.println(Cat.n1);//999

        Cat instance = Cat.getInstance();
        System.out.println(instance);

        //再次调用getInstance
        Cat instance2 = Cat.getInstance();
        System.out.println(instance2);
        System.out.println(instance == instance2);

        /**
         * 999
         * 构造器被调用...
         * Cat{name='小可爱'}
         * Cat{name='小可爱'}
         * true
         */
    }
}

//希望在程序运行过程中,只能创建一个Cat对象
//使用单例模式
class Cat {
    private String name;
    public static int n1 = 999;
    private static Cat cat;//默认为null
    //步骤
    //1.构造器私有化
    //2.定义一个static静态属性对象
    //3.提供一个public的static方法,可以返回一个Cat对象
    //4.懒汉式,只有当用户使用getInstance时,才返回cat对象,后面再次调用时,会返回上次创建的cat对象,保证单例
    public Cat(String name) {
        System.out.println("构造器被调用...");
        this.name = name;
    }
    public static Cat getInstance(){
        if(cat == null){
            cat = new Cat("小可爱");
        }
        return cat;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                '}';
    }
}

Final01.java

package com.hspedu.final_;

public class Final01 {
    public static void main(String[] args) {
        //3.当不希望类的某个属性的值被修改,可以用final修饰
        //E e = new E();
        //e.TAX_RATE = 0.09;错误
    }
}

//1.如果我们要求A类不能被其他类继承,可以使用final修饰A类
final class A{

}

//class B extends A{
//
//}错误

class C{
    //2.如果我们要求hi不能被子类重写,可以使用final修饰hi方法
    public final void hi(){}
}

class D extends C{
//    public void  hi(){
//        System.out.println("我重写了父类C类的hi方法....");
//    }//错误
}

class E{
    //3.当不希望类的某个属性的值被修改,可以用final修饰
    public final double TAX_RATE = 0.08;
}
//4.当不希望某个局部变量被修改,可以使用final修饰
class F{
    public void cry(){
        //这时NUM也被称为局部变量
        final double NUM = 0.01;
        //NUM = 0.9;//错误
        System.out.println("NUM=" + NUM);
    }
}

FinalDetail01.java

package com.hspedu.final_;

public class FinalDetail01 {
    public static void main(String[] args) {
        CC cc = new CC();

        new EE().cal();//cal()方法
    }
}

class AA {
    /*
    2.final修饰的属性在定义时,必须赋初值,并且以后不能再修改,赋值可以在如下位置之一(选择一个位置赋值即可):
     a.定义时:如 public final double TAX_RATE=0.08;
     b.在构造器中
     c.在代码块中
     */
    //1.final修饰的属性又叫常量,一般用XX_XX_XX来命名
    public final double TAX_RATE = 0.08;//1.定义时赋值
    public final double TAX_RATE2 ;
    public final double TAX_RATE3 ;

    public AA() {//构造器中赋值
        TAX_RATE2 = 1.1;
    }
    {//在代码块赋值
        TAX_RATE3 = 8.8;
    }
}

class BB {
    /*
    3.如果final修饰的属性是静态的,则初始化的位置只能是
     a.定义时
     b.在静态代码块 不能在构造器中赋值。
     */
    public static final double TAX_RATE = 99.9;
    public static final double TAX_RATE2 ;

    static {
        TAX_RATE2 = 3.3;
    }

}

//4.final类不能继承,但是可以实例化对象
final class CC { }

//5.如果类不是final类,但是含有final方法,则该方法虽然不能重写,但是可以被继承,即,仍然遵守继承的机制.
class DD {
    public final void cal() {
        System.out.println("cal()方法");
    }
}
class EE extends DD { }

FinalDetail02.java

package com.hspedu.final_;


public class FinalDetail02 {
    public static void main(String[] args) {
        System.out.println(BBB.num);
        /**
         * 10000
         * 不会输出代码块
         */
        //包装类,String 是final类,不能被继承
        //String;
        //Double;
    }
}
//final 和 static 往往搭配使用,效率更高,不会导致类加载.底层编译器做了优化处理
class BBB {
    public final static int num = 10000;
    static {
        System.out.println("BBB 静态代码块被执行");
    }
}

final class AAA{
    //一般来说,如果一个类已经是final类了,就没有必要再将方法修饰成final方法
    //public final void cry(){

    }

FinalExercise01.java

package com.hspedu.final_;

public class FinalExercise01 {
    public static void main(String[] args) {
        Circle circle = new Circle(5.0);
        System.out.println("面积=" + circle.calArea());
        //面积=78.5
    }
}

class Circle {
    private double radius;
    private final double PI = 3.14;

    public Circle(double radius) {
        this.radius = radius;
        //PI = 3.14;
    }
    {
        //PI = 3.14;
    }
    public double calArea(){
        return PI * radius *radius;
    }
}

FinalExercise02.java

package com.hspedu.final_;

public class FinalExercise02 {
    public static void main(String[] args) {

    }
}
class Something {  //FinalExercise02.java
    public int addOne(final int x) {
        //下面的代码是否有误,为什么? 1min
        //++x;  //错误,原因是不能修改 final x的值
        return x + 1; //这里是可以.
    }
}

 

赞(2)

评论 抢沙发

评论前必须登录!

 

LNMP社群 不仅仅是技术

关于我们网站地图