QU5aIFNvc3BlbmRlIGkgUHJlbGlldmkgaW4gQ29udGFudGkgaW4gUmlzcG9zdGEgYWxsYSBQcmVzc2lvbmUgUHViYmxpY2E=

2023-04-12, 07:27

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""><br>ANZ Australia, Commonwealth Bank e NAB hanno pianificato di limitare il numero di filiali bancarie nel paese.</p>
<p>CBA e ANZ hanno indicato di aver accantonato la razionalizzazione dei servizi bancari fino al completamento dell’inchiesta del comitato del Senato.</p>
<p>La chiusura di alcuni degli sportelli bancari citati metterà in difficoltà i clienti delle comunità rurali e delle persone anziane.</p>
<p>Una commissione del senato sta conducendo un’indagine sugli effetti della chiusura delle banche sull’economia e sulle comunità rurali.</p>
<p>Parole chiave: ANZ Australia, ANZ AU, le più grandi banche in Australia, prelievo di contanti, banche dell’Australia, Banche in Australia</p>
<h2 id="h2-Introduzione533745"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>I cambiamenti in atto in Australia mostrano le modifiche che stanno avvenendo nel settore bancario, dove molte banche hanno smesso di gestire contanti in alcune filiali. Di conseguenza, alcuni analisti ritengono che la società stia lentamente avanzando verso una società senza contanti che probabilmente adotterà denaro digitale. In questo articolo, ci concentriamo sulle ragioni per cui diverse grandi banche stanno chiudendo alcune filiali e sul loro impatto sulla società.</p>
<h2 id="h2-ANZ20smetter20di20gestire20contanti20in20alcune20filiali575408"><a name="ANZ smetterà di gestire contanti in alcune filiali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ANZ smetterà di gestire contanti in alcune filiali</h2><p>In Australia c’è stata una protesta pubblica quando ANZ AU, una delle più grandi banche del paese, ha svelato il suo piano di smettere di gestire il contante in alcune delle sue filiali in tutto il paese. La ragione principale è una diminuzione del volume delle transazioni in contanti in queste filiali.</p>
<p>ANZ ha confermato questa sviluppo a NCA NewsWire quando ha detto che rimuoverà alcuni servizi bancari in alcune delle sue filiali. In particolare, alcune filiali non permetteranno ai clienti di prelevare o depositare fisicamente contanti. Tuttavia, tali filiali avranno membri dello staff che aiuteranno i clienti a prelevare o depositare contanti utilizzando gli Smart ATM e i depositi di monete.<br><img src="https://gimg2.gateimg.com/image/article/168128419601.png" alt=""><br>ANZ - Globalcapital</p>
<p>Un portavoce di ANZ ha dichiarato: “In queste filiali, i depositi in contanti e assegni e i prelievi in contanti possono continuare ad essere effettuati utilizzando i nostri Smart ATM e i nostri macchinari per il deposito di monete e abbiamo personale a disposizione per aiutare i clienti che potrebbero utilizzarli per la prima volta.”</p>
<p>La Reserve Bank of Australia (RBA) conferma che l’uso del contante nel paese stava diminuendo. In uno dei suoi sondaggi, la RBA ha scoperto che c’è stato un calo dell’uso del contante nei pagamenti al dettaglio, dal 69% nel 2007 al 27% nel 2019.</p>
<p>Articolo correlato: <a href="https://www.gate.io/zh/blog_detail/378/how-are-cryptocurrencies-currently-regulated-in-countries-around-the-world?lang=en" target="_blank">Come sono attualmente regolamentate le criptovalute nei paesi di tutto il mondo?</a></p>
<p>Il sondaggio ha detto,<br><strong>“Le carte vengono sempre più utilizzate per transazioni di importo inferiore, a testimonianza dell’adozione della funzionalità di pagamento senza contatto ‘toca e vai’ al punto vendita. Anche se la quota di pagamenti in contanti ha continuato a diminuire, il contante è stato ancora utilizzato per oltre un quarto dei pagamenti dei consumatori.”</strong></p>
<p>Inoltre, i dati dell’Australian Prudential Regulation Authority indicano una netta diminuzione del numero di filiali bancarie che forniscono contanti ai clienti. Ha dichiarato che il numero di filiali che gestiscono contanti è diminuito da 4.323 a 4.014 al 30 giugno 2022.</p>
<p>Attualmente, i clienti effettuano la maggior parte dei pagamenti utilizzando bonifici online diretti, pagamenti mobili e carte Tap-and-go. Un portavoce di ANZ ha dichiarato: “I nostri clienti stanno cambiando il modo in cui gestiscono il loro conto, con una diminuzione del 50 per cento delle transazioni in filiale in ANZ negli ultimi quattro anni. La maggior parte preferisce metodi di banking online e mobile.”</p>
<h2 id="h2-Reazione20della20societ20al20piano20di20ANZ415585"><a name="Reazione della società al piano di ANZ" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Reazione della società al piano di ANZ</h2><p>Molti clienti e commentatori sono rimasti scioccati dallo sviluppo e hanno chiesto alle autorità competenti di intervenire a favore di alcuni membri vulnerabili della comunità, come gli anziani.</p>
<p>Come esempio, Steve Worthington, un professore presso la Swinburne University of Technology, ha affermato che tale azione è escludente. Ha spiegato a 7NEWS: “Gli anziani, i nuovi migranti, le persone disabili, hanno bisogno di assistenza faccia a faccia, c’è qui il pericolo di escludere alcuni elementi della nostra società.”</p>
<p>Gli australiani rurali sono alcune delle persone maggiormente colpite da questa decisione. Questo perché molti di loro devono attraversare alcune montagne e percorrere lunghe distanze per raggiungere i punti vendita bancari più vicini. Di conseguenza, molte persone e organizzazioni hanno supplicato queste banche di pensare alla gente di campagna e alle loro comunità.</p>
<p>Un commentatore ha detto: ‘Il Black Spur è molto ventoso e ripido, ha molti animali che lo attraversano, ci sono autobus, camion trasportatori di tronchi e molti turisti… che lo utilizzano. La strada è spesso avvolta dalla nebbia, coperta di ghiaccio’. Secondo lui, le banche dovrebbero permettere alle persone di accedere al loro denaro presso le filiali più vicine senza problemi.</p>
<p>Jim Seymour, un ex residente di Tenterfield nel nord del NSW, ha detto: “Per favore, io vi supplico, non permettete che questa questione venga insabbiata, per il bene del futuro di questa nazione.”</p>
<p>Un altro cliente ha detto: “Qualsiasi banca che segue questa strada perderà clienti e alla fine fallirà … è abbastanza brutto che stiano chiudendo le filiali.”</p>
<p>Nel frattempo, il senato sta effettuando un’indagine sulle chiusure degli sportelli bancari rurali e regionali da parte di ANZ e altre banche dell’Australia. Una commissione del senato ha avviato l’indagine nel febbraio che terminerà nel dicembre 2023. Questa commissione mira a individuare l’impatto della chiusura degli sportelli bancari e gli effetti dell’interruzione dei servizi bancari di persona sull’economia e sul benessere dei clienti.</p>
<p>Annuncio recente: <a href="https://www.gate.io/vi/blog_detail/708/gate.io-vip-sharing-campaign-vitalik-on-the-cover-of-time-magazine-opensea-may-have-supported-sol-payments-russia-accepts-bitcoin-as-export-payment-method?lang=en" target="_blank">ANZ diventa la prima banca australiana a coniare stablecoin</a></p>
<h2 id="h2-Piani20di20altre20grandi20banche20Westpac20NAB20e20Commonwealth20Bank227483"><a name="Piani di altre grandi banche (Westpac, NAB e Commonwealth Bank)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Piani di altre grandi banche (Westpac, NAB e Commonwealth Bank)</h2><p>La chiusura di alcune filiali bancarie non è limitata solo ad ANZ poiché anche altre banche in Australia hanno promesso di fare lo stesso. La Commonwealth Bank aveva anche pianificato di chiudere il suo ramo di Junee. Tuttavia, ha già accantonato il piano di chiudere qualsiasi filiale mentre attende l’esito dell’inchiesta del comitato del Senato sulle chiusure delle banche regionali.<br><img src="https://gimg2.gateimg.com/image/article/168128432702.png" alt=""><br>Commonwealth Bank - ABCnet</p>
<p>Un portavoce della CBA ha dichiarato: “A seguito dell’esame di una richiesta della Commissione del Senato, la CBA non chiuderà alcuna filiale regionale mentre l’inchiesta è in corso nel 2023. Come ulteriore segno di buona fede, mentre l’inchiesta è in corso nel 2023, CBA rinvierà la chiusura di due filiali [tra cui Junee] già annunciata”.</p>
<p>Anche se Westpac, una delle altre grandi banche in Australia, aveva annunciato in precedenza l’intenzione di chiudere alcune filiali nel Queensland, Victoria, NSW e South Australia, ha dichiarato a NCA NewsWire che attualmente non ha piani per chiudere nessuna di queste filiali. <a href="https://regionriverina.com.au/westpac-and-anz-to-push-ahead-with-riverina-bank-closures/" rel="nofollow noopener noreferrer" target="_blank">portavoce ha detto</a>,<br><strong>I nostri clienti possono accedere ai servizi di contanti over-the-counter presso tutte le filiali del Westpac Group cinque giorni alla settimana e presso più di 3500 sportelli postali in tutto il paese grazie alla nostra partnership con Bank Post.</strong></p>
<p>La National Australia Bank (NAB) ha annunciato l’intenzione di chiudere alcune delle sue filiali nel 2022. Le filiali interessate si trovano a Narrandera, Corrimal Lavington, Maroubra, Figtree e Cronulla. Recentemente, la NAB ha dichiarato che proseguirà con le chiusure previste.</p>
<p><a href="https://aboutregional.com.au/westpac-and-anz-to-push-ahead-with-riverina-bank-closures/" rel="nofollow noopener noreferrer" target="_blank">Krissie Jones, utive del settore retail di NAB, ha detto</a>, “Continueremo il nostro processo di ristrutturazione delle filiali durante le delibere del Comitato nel 2023, che includerà chiusure, consolidamenti e nuovi investimenti per soddisfare le esigenze dei nostri clienti.”</p>
<h2 id="h2-Denaro20digitale20o20banche2020chi20vincer870837"><a name="Denaro digitale o banche - chi vincerà" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Denaro digitale o banche - chi vincerà</h2><p>C’è un aumento dell’uso di denaro digitale in tutto il mondo. In termini semplici, il denaro digitale è qualsiasi forma di pagamento che avviene su Internet. Il denaro digitale non ha un corrispettivo fisico come banconote e monete. Esempi di valute digitali sono le criptovalute e la valuta digitale delle banche centrali (CBDC).</p>
<h2 id="h2-La20moneta20digitale20ha20i20suoi20vantaggi20e20svantaggi86037"><a name="La moneta digitale ha i suoi vantaggi e svantaggi." class="reference-link"></a><span class="header-link octicon octicon-link"></span>La moneta digitale ha i suoi vantaggi e svantaggi.</h2><p>Uno dei principali vantaggi del denaro digitale è quello delle transazioni rapide. Qualcuno può trasferire fondi a un’altra persona in un altro paese in pochi minuti. Questo è diverso dalle banche che possono richiedere diversi giorni perché i soldi raggiungano la destinazione prevista.</p>
<p>Con denaro digitale non è necessario avere portafogli fisici per conservare il denaro. È sufficiente gestire i soldi online utilizzando il proprio conto digitale.</p>
<p>Il denaro digitale non ha bisogno di intermediari che assistano nel processo delle transazioni. Le persone semplicemente tengono i loro fondi nei conti e li usano come vogliono.</p>
<p>Tuttavia, i soldi digitali hanno i loro svantaggi. Il problema principale dei soldi digitali è quello dell’hacking. Gli hacker possono facilmente rubare i soldi dai portafogli. Non c’è possibilità di hackerare il denaro contante fisico. È importante notare che la migliore società moderna avrebbe bisogno sia di soldi digitali che di soldi fisici.</p>
<h2 id="h2-Conclusione321019"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Le principali banche in Australia, cioè ANZ, NAB e CBA, intendono razionalizzare i loro servizi bancari. In alcuni casi, intendono chiudere completamente gli sportelli, mentre in altri intendono interrompere i prelievi e i depositi in contanti fisici. Attualmente, ANZ e CBA hanno interrotto i loro processi di razionalizzazione bancaria mentre attendono l’esito dell’inchiesta del comitato del Senato.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Mashell C.</strong>, Ricercatore Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>