1 函数题
1,super.a 来明确访问父类的字段。super(a); 表示调用父类的构造函数,并传递参数 a
2,
抽象类继承需要写新的构造器,重写抽象方法
class Circle extends shape{
private double radius;
public Circle(double radius){
this.radius=radius;
}
//构造器比较容易忘
//新的类型有新的变量所以要用构造器初始化
@Override
public double getArea(){
return Math.PI*radius*radius;
}// 求面积
public double getPerimeter(){
return 2*Math.PI*radius;
} // 求周长
}
3,比较类对象
public boolean equals(Object o) {
if (this == o) return true; // 同一对象
if (o == null || getClass() != o.getClass()) return false; // 空或不同类
Point point = (Point) o; // 类型转换
return this.xPos == point.xPos && this.yPos == point.yPos; // 属性比较
/*不能直接写this.id=id,这个不是传入的参数,不能直接调用,需要通过类*/
}
//而不是
public boolean equals(int x,int y)
{
if((this.xPos==x)&&(this.yPos==y))
return true;
else
return false;
}
//另一个
public boolean equals(Object o) {
if (this == o) return true; // 同一对象
if (o == null || getClass() != o.getClass()) return false; // 空或不同类
Student student = (Student) o; // 类型转换
return this.id==student.id; // 属性比较
}
4,接口
class Octagon implements Comparable<Octagon>,Cloneable{
private double side;
public Octagon(double side) {
this.side = side;
}
public double getSide() {
return side;
}
public void setSide(double side) {
this.side = side;
}
public double getPerimeter()
{
return side*8;
}
public double getArea()
{
return (2+4/Math.sqrt(2))*side*side;
}
@Override
public int compareTo(Octagon o){
if(this.side>o.getSide())
return 1;
else if(this.side<o.getSide())
return -1;
else
return 0;
}
/*
在 Java 中,Comparable<T> 是一个泛型接口,
用于定义对象的自然顺序。这里的 <T> 表示一个类型参数,
允许您指定将要比较的对象的类型。
在 Comparable<Octagon> 中,<> 符号是用于指定泛型类型参数的
意味着在调用 compareTo 方法时,
参数必须是 Octagon 类型,确保类型安全。
*/
@Override
protected Object clone() {
return this;
}
}
5,类和子类
class Account{
private int id;
private int balance;
public Account() {
}
public Account(int id, int balance) {
this.id = id;
this.balance = balance;
}
public int getBalance() {
return balance;
}
public void setBalance(int balance) {
this.balance = balance;
}
public boolean withdraw(int money)
{
int tmp=balance-money;
if(tmp>=0)
setBalance(tmp);
return tmp>=0;
}
public void deposit(int money)
{
balance+=money;
}
public String toString()
{
return "The balance of account "+id+" is "+balance;
}
}
class CheckingAccount extends Account{
private int overdraft;
public CheckingAccount() {
}
public CheckingAccount(int id, int balance, int overdraft) {
super(id, balance);
this.overdraft = overdraft;
}
@Override
public boolean withdraw(int money) {
int tmp=getBalance()+overdraft-money;
if(tmp>=0)
setBalance(getBalance()-money);
return tmp>=0;
}
}
6,因为传入参数的不确定,我们要手动调用有参和无参方法。
public void pay(int hour)
{
pay();
}
public void pay()
{
System.out.println(40.0*rate);
}
7,继承
class Media{
String name;
public double getDailyRent(){
return 0.0;
}
}
class Book extends Media{
double price;
public Book(String name,double price)
{
this.name=name;
this.price=price;
}
//构造块
public double getDailyRent(){
return 0.01*price;
//重写
}
}
class DVD extends Media{
public DVD(String name)
{
this.name=name;
}
public double getDailyRent(){
return 1;
}
}
class MediaShop{
public static double calculateRent(Media[] medias, int days){
double sum=0;
//静态方法全局方法,数组长度没有括号
for(int i=0;i<medias.length;i++)
{
sum+=medias[i].getDailyRent()*days;
}
return sum;
}
}
8,子类的继承
//样例2不通过
class ComputerPlayer extends Player {
String name;
public ComputerPlayer(String name) {
// this.name = name;这样写需要在父类定义无参构造器
super(name);
}
}
class PersonPlayer extends Player {
String name;
public PersonPlayer(String name) {
// this.name = name;
super(name);
}
int show() {
Scanner sc = new Scanner(System.in);
int show = sc.nextInt();
return show;
}
}
class Game {
int A;
int B;
Game(Player A, Player B) {
this.A = A.show();
this.B = B.show();
}
public void start() {
if (A == B) {
System.out.println("A Draw.");
} else if ((A == 1 && B == 2) || (A == 2 && B == 3) || (A == 3 || B == 1)) {
System.out.println("Winner is personPlayer.");
} else {
System.out.println("Winner is computerPlayer.");
}
}
}
标签:return,name,int,double,08,多态,JAVA,balance,public
From: https://www.cnblogs.com/hoshino-/p/18457017