blog2
作者：互联网
实现如下功能：读入关于蛟龙号载人潜水器探测数据的多行字符串，从给定的信息找出数字字符，输出每行的数字之和。
提示 若输入为“2012年2月”，则该行的输出为：2014。若干个连续的数字字符作为一个整体，以十进制形式相加。
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (true) {
String line = sc.nextLine(); // 读入字符串
if (line.equals("end"))
break;
String[] split = line.split("\\D+");
//System.out.println(Arrays.toString(split));
int i;
long sum = 0;
for (i = 0; i < split.length; i++) {
if (!split[i].equals("")) {
int digit = Integer.parseInt(split[i]);
sum += digit;
}
}
System.out.println(sum);
}
}
}
使用正则表达式搜索文中的数字
find 和 matches 的区别
find 是部分匹配，适合判断是否含有某些内容，比如字符中是否含有数字
matches 是全匹配，适合判断是否为数字或是字母
public static void main(String[] args) {
String str2 = "1aa564sdfp5324";
System.out.println("======= "+str2+" =========");
hasDigit(str2);
str2 = "234564";
System.out.println("======= "+str2+" =========");
hasDigit(str2);
}
public static boolean hasDigit(String content) {
String regExp = "\\d+";
regExp = "[0-9]*";
Pattern pattern=Pattern.compile(regExp);
Matcher m = pattern.matcher(content);
System.out.println(" matches nums: " +m.matches());
System.out.println(" find nums: " +m.find());
return m.find();
}
======= 1aa564sdfp5324 =========
matches nums: false
find nums: true
======= 234564 =========
matches nums: true
find nums: true
表达式： [^0-9] 需要用到反向字符集，去掉非数字的。
public static void main(String[] args) {
String str = "curStaff[25].staffName12";
getContainsNum(str);
}
private static String getContainsNum(String str){
String regExp="[^0-9]"; // 反向字符集。匹配未包含的数字，替换着里面的数字
Pattern pattern = Pattern.compile(regExp);
Matcher matcher = pattern.matcher(str);
System.out.println("find "+matcher.find());
String nums = matcher.replaceAll("").trim();
System.out.println("nums "+nums);
return nums;
}
find true
nums 2512
数字是获取了，但是糅合在一起了，一般会需要分开。
3，分开提取的数字
替换的时候使用特殊字符进行替换，然后再进行分割，进行大小判断
）调用BankBusiness类的welcome()方法。
（2）接收键盘输入的用户名、密码信息作为参数，调用BankBusiness类带参数的构造方法，从而创建一个BankBusiness类的对象account。
（3）调用account的存款方法，输入正确的密码，存入若干元。密码及存款金额从键盘输入。
（4）调用account的取款方法，输入错误的密码，试图取款若干元。密码及取款金额从键盘输入。
（5）调用account的取款方法，输入正确的密码，试图取款若干元（取款金额大于余额）。密码及取款金额从键盘输入。
（6）调用account的取款方法，输入正确的密码，试图取款若干元（取款金额小于余额）。密码及取款金额从键盘输入。
（7）调用BankBusiness类的welcomeNext()方法。
要求编写程序模拟银行账户的存、取款操作。按要求完成以下步骤：
步骤 1：编写程序 Account.java，其中定义银行账户类 Account。该类中有账号、姓名、存款余额等数据域，余额默认是 0；有存款、取款、获取当前余额等方法。其中账号为长度为 12 位数字的字符串，姓名为字符串，存款余额为 double
步骤 2：编写名为 CreditAccount 类的信用卡账户类。该类继承自 Account 类，增加一个透支限额(double)数据域，透支限额默认为 1000。同时该类账户取款时允许透支，但不能超过透支限额。
步骤 3：编写名为 SavingAccount 的储蓄账户类 SavingAccount。该类继承自 Account 类。该类账户取款时不允许透支。
步骤 4：编写名为 Bank 的模拟银行类，其中可以存储多个类型可能是信用卡账户或储蓄账户的对象(可以用数组或 ArrayList 实现)。该类包含以下方法:
开户：即增加一个新的账户，注意：不允许两个账户的账号相同
销户：即删除一个已有的账户
查询账户：根据一个账号，查询有无该账号的账户
统计目前银行的存款总余额的方法。
统计目前银行的信用卡账户总透支金额的方法。
统计目前总账户数。
统计目前信用卡账
统计目前总账户数。
统计目前信用卡账户数
统计目前储蓄卡账户
步骤 5：编写客户端类 Client.java 完成以下功能：
编写一个静态方法，创建一个银行对象，并随机生成 10 个账号从 1000 0000 0000 0000 到 1000 0000 0000 0009、类型不同的账户。
main 方法中模拟几次开户操作。
main 方法中模拟几次销户操作。
模拟几个对指定账号的存款和取款操作。
输出银行的总账户数、总余额、总透支数、各类具体账户数。
package cn.zg;
/**
* @author zg
*/
public class Account {
/**
* 账户
*/
private String account;
/**
* 姓名
*/
private String name;
/**
* 存款余额
*/
private double money;
/**
* 构造
*/
public Account() {
this.money=0.0;
}
public Account(String account){
this.account=account;
}
public Account(String account, String name, double money) {
this.account = account;
this.name = name;
this.money = money;
}
/**
*访问器和修改器
*/
public String getAccount() {
return account;
}
public void setAccount(String account) {
this.account = account;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
/**
* 存款
*
package cn.zg;
/**
* @author zg
*/
public class CreditAccount extends Account{
/**
* 透支限额
*/
private double overdue;
/**
* 构造
*/
public CreditAccount() {
}
public CreditAccount(String account, String name, double money, double overdue) {
super(account, name, money);
this.overdue = overdue;
}
/**
* 访问器和修改器
*/
public double getOverdue() {
return overdue;
}
public void setOverdue(double overdue) {
this.overdue = overdue;
}
/**
* 取款时允许透支，但不能超过透支限额
* @param money 透支金额
* @return 是否透支成功
*/
public boolean over(double money){
if(overdue-money<0){
return false;
}
overdue-=money;
return true;
}
}
package cn.zg;
/**
* @author zg
*/
public class SavingAccount extends Account{
public SavingAccount() {
}
public SavingAccount(String account, String name, double money) {
super(account, name, money);
}
}
package cn.zg;
import java.util.ArrayList;
/**
* @author zg
*/
public class Bank {
/**
* 存储多个类型可能是信用卡账户或储蓄账户的对象
*/
ArrayList<Account> accounts=new ArrayList<>();
/**
* 开户
* @param account 待开户账户
* @return 是否开户成功
*/
public boolean add(Account account){
for (Account acc : accounts) {
if(acc.getAccount().equals(account.getAccount())){
// 不允许两个账户的账号相同
return false;
}
}
return accounts.add(account);
}
/**
* 销户
* @param account 待销户账户
* @return 是否销户成功
*/
public boolean delete(Account account){
for (Account acc : accounts) {
if(acc.getAccount().equals(account.getAccount())){
return accounts.remove(acc);
}
}
return false;
}
/**
* 根据一个账号，查询有无该账号的账户
* @param account 要查询的账号
* @return 有无该账号的账户
*/
public boolean query(Account account){
for (Account acc : accounts) {
if(acc.getAccount().equals(account.getAccount())){
return true;
}
}
return false;
}
/**
*
* @return 统计目前银行的信用卡账户总透支金额
*/
public double sumOfOverdue(){
double sum=0;
for (Account account : accounts) {
if(account instanceof CreditAccount){
sum+=(1000-((CreditAccount) account).getOverdue());
}
}
return sum;
}
/**
*
* @return 统计目前银行的存款总余额
*/
public double sumOfMoney(){
double sum=0;
for (Account account : accounts) {
sum+=account.getMoney();
}
sum-=sumOfOverdue();
return sum;
}
/**
*
* @return 统计目前总账户数
*/
public int count(){
return accounts.size();
}
/**
*
* @return 统计目前信用卡账户数
*/
public int countOfCredit(){
int count=0;
for (Account account : accounts) {
if(account instanceof CreditAccount){
count++;
}
}
return count;
}
/**
*
* @return 统计目前储蓄卡账户数
*/
public int countOfSaving(){
int count=0;
for (Account account : accounts) {
if(account instanceof SavingAccount){
count++;
}
}
return count;
}
}
package cn.zg;
import java.util.Random;
/**
* @author zg
*/
public class Client {
public static void main(String[] args) {
Bank bank=create();
// 模拟几次开户操作
boolean zg = bank.add(new SavingAccount("1000000000000001", "zg", 0));
// 1000000000000001账号已存在，开户失败
print(zg);
boolean zcg = bank.add(new SavingAccount("1000000000000010", "zcg", 0));
print(zcg);
boolean zzw = bank.add(new CreditAccount("1000000000000011", "zzw", 0,1000));
print(zzw);
// 模拟几次销户操作
print2(bank.delete(new Account("1000000000000001")));
print2(bank.delete(new Account("1000000000000006")));
print2(bank.delete(new Account("1000000000000009")));
// 模拟几个对指定账号的存款操作
for (Account account : bank.accounts) {
if("1000000000000011".equals(account.getAccount())){
account.addMoney(100000);
}else if("1000000000000001".equals(account.getAccount())){
account.addMoney(1000);
}else if("1000000000000005".equals(account.getAccount())){
account.addMoney(1688);
}
}
// 模拟几个对指定账号的取款操作
for (Account account : bank.accounts) {
if("1000000000000011".equals(account.getAccount())){
account.minusMoney(111);
}else if("1000000000000001".equals(account.getAccount())){
account.minusMoney(111);
}else if("1000000000000005".equals(account.getAccount())){
account.minusMoney(111);
}
}
// 模拟所有信用卡账号的透支操作
for (Account account : bank.accounts) {
if(account instanceof CreditAccount){
((CreditAccount)account).over(111);
}
}
// 输出银行的总账户数、总余额、总透支数、各类具体账户数
System.out.println("银行的总账户数:"+bank.count());
System.out.println("银行的总余额:"+bank.sumOfMoney());
System.out.println("银行的总透支数:"+bank.sumOfOverdue());
System.out.println("银行的信用卡账户数:"+bank.countOfCredit());
System.out.println("银行的储蓄卡账户数:"+bank.countOfSaving());
}
/**
* 随机生成 10 个账号从 1000 0000 0000 0000 到 1000 0000 0000 0009、类型不同的账户。
* @return Bank对象
*/
public static Bank create(){
Bank bank = new Bank();
Random random = new Random();
String prefix="100000000000000";
while(bank.count()<10){
int i=random.nextInt(10);
if(i%2==0){
bank.add(new CreditAccount(prefix+i,"小"+i,0,1000));
}else{
bank.add(new SavingAccount(prefix+i,"小"+i,0));
}
}
return bank;
}
public static void print(boolean flag){
if(flag){
System.out.println("开户成功！");
}else{
System.out.println("开户失败！");
}
}
public static void print2(boolean flag){
if(flag){
System.out.println("销户成功！");
}else{
System.out.println("销户失败！");
}
}
}
设计一个Point类，表示直角坐标系中的一个点。Point类包括：
double类型的私有数据域x和y，表示坐标。
无参构造方法，将坐标设置为原点。
有参构造方法，将坐标设置为给定的参数。
访问器方法getX和getY，分别用于访问点的x坐标和y坐标。
一个名为distance的方法，返回Point类型的两个点之间的距离。
一个名为distance的静态方法，返回指定Point类型的两个点之间的距离。
注意，Point类的定义应该这样开始：
class Point {
也就是说，Point类的class前面不要有public。
【输入】
有两行。
每一行给出坐标点x和y，其间以空格分隔。
【输出】
有两行
每一行中输出两个坐标点之间的距离，结果保留2位小数。
【输入示例】
0 0
10 30.5
【输出示例】
32.10
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
double x1=sc.nextDouble();
double y1=sc.nextDouble();
double x2=sc.nextDouble();
double y2=sc.nextDouble();
Point p1=new Point(x1,y1);
Point p2=new Point(x2,y2);
System.out.printf("%.2f\n",Point.distance(p1,p2));
System.out.printf("%.2f\n",Point.distance(p1,p2));
}
}
class Point {
private double x;
private double y;
public Point(){x=0;y=0;}
public Point(double x,double y){
this.x=x;
this.y=y;
}
public double getX(){
return x;
}
public double getY(){
return y;
}
public static double distance(Point p1, Point p2) {
return Math.sqrt((p1.getX() - p2.getX()) * (p1.getX() - p2.getX()) + (p1.getY() - p2.getY()) * (p1.getY() - p2.getY()));
}
public double distance(Point p) {
return distance(this,p
继承就是保持已有类的特性而构造新类的过程。继承后，子类能够利用父类中定义的变量和方法，就像它们属于子类本身一样。
单继承：在类层次中，子类只继承一个父类的数据结构和方法，一个类只有一个父类
多继承：在类层次中，子类继承了多个父类的数据结构和方法，一个类允许有多个继承
（java支持多层继承）
//父类
public class file{
public long size; //文件大小
public String name; //文件名
public void info() //显示文件信息
{
System.out.println(name + " " + size);
}
}
//子类
public class videofile extends file()
{
//父类的public成员自动继承
//private不能被继承，子类无权访问
//只需要添加子类的特性
public int duration //时长
public void play()
{
System.out.println("播放" + this.name);
}
public void stop()
{
System.out.println("停止" + this.name);
}
}
成员变量隐藏：是指在子类中定义了一个与直接超类的某个成员变量同名的成员变量，从而使超类中的那个成员变量不能直接被子类继承。
当成员变量隐藏时，在超类类题代码中用简单变量命名访问的一定是超类中的成员变量，而在子类类体代码中用简单变量名访问的则一定是在子类中的成员变量
可以用下列各式访问超类中被隐藏的成员变量
super.<变量名> 在子类类体里，访问直接超类中被隐藏的成员变量
((<超类名>)<子类实例引用>).变量名 访问指定超类中被隐藏的成员变量
<超类名>.<变量名> 访问指定超类中被隐藏的类变量
public class number {
int x;
static int y; //类变量
void set(int a)
{
x = a;
y = a;
}
void print()
{
System.out.println("x" + "\t" + x);
}
}
public class newnumber extends number {
int x;
static int y;
void newset(int a)
{
x = a;
y = a;
}
void newprint()
{
System.out.println("x" + "\t" + x); //x = 100
System.out.println("y" + "\t" + y); //y = 100
System.out.println("x" + "\t" + super.x); //x = 10
//在子类类体里，访问直接超类中被隐藏的成员变量
System.out.println("y" + "\t" + super.y); //y = 10
}
}
public class HelloWorld {
public static void main(String[] args) {
newnumber n = new newnumber();
n.set(10);
n.print();
n.newset(100);
n.newprint();
System.out.println("y" + "\t" + number.y); //y = 10
System.out.println("x" + "\t" + ((number)n).x); //x= 10
}
}
若子类和父类里都有相同的名字定义的方法，但是实现不一致。覆盖的方法是按照子类中重定义的方法进行调用，而继承的方法直接调用父类的方法
覆盖 (重写)(Override)：
1、方法名称要一样
2、返回值数据类型要一样
3、所使用的参数列表要一样，参数列表包括参数个数及每个参数的数据类型，不包括参数的变量名
4、访问修饰符只能越来越开放，不能越来越封闭
public class file {
public long size;
public String name;
public void info()
{
System.out.println(name + "\t" + size);
}
}
public class vediofile extends file{
public int duration;
public void play()
{
System.out.println("播放" + this.name);
}
public void stop()
{
System.out.println("停止" + this.name);
}
//Override 覆盖
public void info() {
System.out.println("name : " + name + " size : " + size + " time : " + time);
}
}
public class HelloWorld {
public static void main(String[] args) {
vediofile v = new vediofile();
v.size = 20000;
v.name = "abc.mp4";
v.duration = 70;
v.info();
//name : abc.mp4 size : 20000 time : 70
}
}
泛化：
抽取调整代码到父类的过程，称为泛化
Eclipse自动添加覆盖功能：
点击source，选择Override/Implement Methods
选择要覆盖的方法
子类可以选择完全重写或者在父类方法中补充
public void info() {
// TODO Auto-generated method stub
super.info(); //调用父类的实现
System.out.println("time : " + duration);
//name : abc.mp4 size : 20000 time : 70
}
构造方法的继承：
创建子类对象时，父类的构造方法会被自动调用
public class parent {
public parent()
{
System.out.println("父类构造...");
}
}
public class child extends parent {
public child()
{
System.out.println("子类构造...");
}
}
public class HelloWorld {
public static void main(String[] args) {
child c = new child();
}
}
若父类有很多个构造方法，可在子类里显示指定用哪个构造
public class parent {
private int a;
public parent() //默认构造
{
System.out.println("父类构造...");
}
public parent(int a) //带参构造
{
this.a = a;
System.out.println("带参父类构造...");
}
}
public class child extends parent {
public child()
{
super(23); //调用带参构造
System.out.println("子类构造...");
}
}
public class HelloWorld {
public static void main(String[] args) {
child c = new child();
}
}
单根继承：Java语言里，一个类只能继承一个父类
如果一个类没有指定父类，则它的默认父类就是Object
toString() 方法返回此对象本身（它已经是一个字符串）
public class Student {
public String id;
public String name;
public boolean sex;
@Override
public String toString() {
String s = " 学号 : " + id + " 姓名 : " + name;
if(sex)
{
s = s + "(男)";
}
else
{
s = s + "(女)";
}
return s;
}
}
public class HelloWorld {
public static void main(String[] args) {
Student s = new Student();
s.id = "20003";
s.name = "lisi";
System.out.println(s.toString()); // 学号 20003 姓名 lisi(女)
}
}
多态
1、使用父类类型的引用只想子类的对象
2、该引用只能调用父类中定义的方法和变量
3、如果子类中重写（覆盖）了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法
4、变量不能被重写（覆盖），重写只针对方法，如果在子类中重写了父类的变量，编译时会报错
子类转成父类是可以的（隐式转换）
当调用一个方法的时候，不是看引用类型，而是看对象的实际类型。
转化原则
子类对象可以当作父类对象使用
父类对象不能当作子类对象使用
如果父类引用实际只想的是子类对象，那么该父类引用可以通过强制转化成子类对象使用
public class file {
public long size;
public String name;
public void info()
{
System.out.println("name : " + name + " size : " + size);
}
}
public class vediofile extends file{
public int duration;
public void play()
{
System.out.println("播放" + this.name);
}
public void stop()
{
System.out.println("停止" + this.name);
}
@Override
public void info() {
// TODO Auto-generated method stub
super.info();
System.out.println("time : " + duration);
}
}
public class HelloWorld {
public static void main(String[] args) {
vediofile v = new vediofile();
v.size = 20000;
v.name = "abc.mp4";
v.duration = 70;
file f = v;
f.info(); //调用的子类的info
}
}
覆盖是动态绑定
重载是静态绑定
用instanceof操作符测试一个对象是否是一个类的实例
instanceof返回值是true或false
对象名 instanceof 类名 -> true or false
class SchoolMember
{
public void introduce()
{
System.out.println("a schoolmember");
}
}
class Student extends SchoolMember
{
public void study()
{
System.out.println("study");
}
}
class Teacher extends SchoolMember
{
public void teach()
{
System.out.println("teach");
}
}
class Test
{
static void use(SchoolMember obj)
{
obj.introduce();
//判断实例化的对象是Student还是Teacher
if(obj instanceof Student)
{
Student s = (Student)obj;
s.study();
}
if(obj instanceof Teacher)
{
Teacher t = (Teacher)obj;
t.teach();
}
}
public static void main(String[] args)
{
Student s1 = new Student();
//Teacher t1 = new Teacher();
use(s1);
//use(t1);
}
}
eg：
a schoolmember
study
方法看右侧，属性看左侧
先访问父类的构造方法再访问子类的构造方法
eg1：
class A
{ String s="class A"; }
class B extends A
{ String s="class B"; }
public class TypeConvert
{
public static void main(String args[])
{
B b1,b2=new B();
A a1,a2;
a1=(A)b2;
a2=b2;
System.out.println(a1.s); //class A
System.out.println(a2.s); //class A
b1=(B)a1;
System.out.println(b1.s); //class B
System.out.println(b2.s); //class B
}
}
class A
{ String s="class A";
void show() { System.out.println(s);}
}
class B extends A
{ String s="class B";
void show() { System.out.println(s);}
}
public class TypeConvert
{ public static void main(String args[]) {
B b1;
B b2=new B();
A a1,a2;
a1=(A)b2;
a2=b2;
System.out.println(a1.s); //class A
a1.show(); //class B
System.out.println(a2.s); //class A
a2.show(); //class B
b1=(B)a1;
System.out.println(b1.s); //class B
b1.show(); //class B
System.out.println(b2.s); //class B
b2.show(); //class B
}
}
class A
{
public A()
{
System.out.println(“The default constructor of A is invoked”);
}
}
class B extends A
{
public B()
{
}
}
public class C
{
public static void main(String[] args)
{
B b = new B();
}
}
输出 The default constructor of A is invoked
标签：account,blog2,System,public,println,class,out 来源： https://www.cnblogs.com/xkszy/p/16275517.html