Java基础之面向对象编程
一、类和对象
Java 是一门面向对象的编程语言，其重要的一个思想就是“万物皆对象”。而类是 Java 的核心内容，它是一种逻辑结构，定义了对象的结构，可以由一个类得到众多相似的对象。从某种意义上说，类是 Java 面向对象性的基础。Java 与 C++不同，它是一门完全的面向对象的编程语言，它的任何工作都要在类中进行。
类（class）实际上是一个模板，而对象是由这个模板产生的多个实例（instance [ˈɪnstəns]）。
实际上前面的程序中也是在类中实现的，不过全在类中的 main 方法中演示程序的使用，没有体现面向对象编程的思想。这一节里主要讲解 Java 类的相关知识，包括类的形式、类包含的内容，即属性和方法。
二、如何定义类
Java 的重要思想是万物皆对象，也就是说在 Java 中可以把所有现实中的一切人和物都看做对象，而类就是它们的一般形式。编写程序就是抽象出这些事物的共同点，用程序语言的形式表达出来。
语法如下：
class 类名{
类型 实例变量名;
类型 实例变量名;
}
案例：可以把某某人看做一个对象，那么就可以把人作为一个类抽象出来，这个人就可以作为人这个类的一个对象。
public class Person {
int age;
String name;
}
注意：在类名面前可以不加上修饰符 public，在 Java 中是允许把许多类放在一个 Java 文件中，但是这些类只能有一个类被声明为 public，而且这个类的名字必须和 Java 文件名相同。
案例：通过 Person 类创建两个对象小明和小张
Person person1 = new Person();
person1.age = 12;
person1.name = "小明";
Person person2 = new Person();
person2.age = 13;
person2.name = "小张";
System.out.println(person1);
System.out.println(person2);
说明：输出到控制台为 Person@1540e19d，原因是 toString 方法没有重写，idea 生成 toString 方法的快捷键是 alt + insert，toString 方法主要用来控制对象的输出格式。
三、成员方法(函数)
成员方法也叫成员函数、实例方法。如人类：除了有一些属性（Field [fiːld]）如：年龄、姓名…外，我们人类还有一些行为比如：可以说话、跑步、学习、还可以做算术题。这时就要用成员方法（Method [ˈmeθəd]）才能完成。
案例：
- 添加 speak 成员方法，输入出：我是谁，我是一个好人。
- 添加 calculate 成员方法，可以计算从 1+…+1000 的结果。
- 添加 calculate 成员方法，该方法可以接收一个数 n，计算返回从 1+…+n 的结果。
- 添加 add 成员方法，可以计算返回两个数的和。
public class Person {
int age;
String name;
public void speak() {
System.out.println("我是" + name + ",我是好人！");
}
public int calculate() {
int sum = 0;
for (int i = 1; i <= 1000; i++) {
sum += i;
}
return sum;
}
public int calculate(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += i;
}
return sum;
}
public int add(int x, int y) {
return x + y;
}
@Override
public String toString() {
return "Person{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}
class MainTest {
public static void main(String[] args) {
Person person1 = new Person();
person1.age = 12;
person1.name = "张三";
Person person2 = new Person();
person2.age = 18;
person2.name = "李四";
System.out.println(person1);
System.out.println(person2);
person2.speak();
int calculate = person2.calculate(5);
System.out.println(calculate);
int add = person1.add(2, 8);
System.out.println(add);
}
}
按照要求完成后两个方法，然后看看和课件上区别在哪里。
语法如下：
public 返回数据类型 方法名(参数列表){
语句;//方法(函数)主体
}
1、参数列表：表示成员函数输入
2、返回数据类型：表示成员函数输出
3、函数主体：表示为了实现某一功能代码块
注意方法有如下特性：
- 方法名在有不同参数的情况下可以使用同一个方法名，即有参数和没参数的方法可以同名。
- 返回类型和返回结果的类型要一致。
- 在调用某个成员方法的时候，给出的具体数值的个数和类型要相匹配。
练习：
请定义一个交通工具 Car 的类其中有：属性速度 speed 体积 size 等等；方法移动 move()；设置速度 setSpeed(int speed)；加速 speedUp()；减速 speedDown()等等。最后在测试类 CarTest 中的 main() 方法中实例化一个车对象并通过方法给它初始化 speed，size 的值并且通过打印出来。另外调用加速减速的方法对速度进行改变。
参考代码：
public class Car {
int speed;
String size;
public void move() {
System.out.println("正在以" + speed + "的速度运行");
}
public void setSpeed(int sp) {
speed = sp;
}
public void speedUp() {
speed += 100;
}
public void speedDown(int sp) {
speed -= 100;
}
@Override
public String toString() {
return "Car{" +
"speed=" + speed +
", size='" + size + '\'' +
'}';
}
}
class CarTest {
public static void main(String[] args) {
Car car = new Car();
car.speed = 100;
car.size = "5m^3";
car.move();
car.setSpeed(200);
car.move();
car.speedUp();
System.out.println(car);
}
}
四、访问控制修饰符
java 提供四种访问控制修饰符号控制类、方法和属性的访问权限：
1、公开级别：用 public [ˈpʌblɪk]修饰，对外公开。
2、受保护级别：用 protected [prəˈtektɪd]修饰，对子类和同一个包中的类公开。
3、默认级别：没有修饰符号，向同一个包的类公开。
4、私有级别：用 private [ˈpraɪvət]修饰，只有类本身可以访问，不对外公开。
具体如下：
访问级别 修饰符 同类 同包 子类 不同包
公 开 public √ √ √ √
受保护 protected √ √ √ ╳
默 认 没有修饰符 √ √ ╳ ╳
私 有 private √ ╳ ╳ ╳
package：包，用来区分相同类名的类，在类前面声明用于标识当前类所在的包。
import：用于表明当前类中所用到的类。如果是导入同一个包内的其他类，可省略。
五、构造方法
构造方法（Constructor [kənˈstrʌktə®]）是类的一种特殊的方法（Method），它的主要作用是完成对新对象的初始化（initialize [ɪˈnɪʃəlaɪz]）。
public class User {
public int id;
public String name;
public User() {//无参构造
}
public User(int id, String name) {//有参构造
this.id = id;
this.name = name;
}
}
class MainTest {
public static void main(String[] args) {
User user = new User(1, "张三");//调用有参构造初始化对象
User user1 = new User();//调用无参构造初始化对象(需要再设置对象属性)
user1.id = 2;
user1.name = "李四";
}
}
构造方法有几个特点：
- 方法名和类名相同，且没有返回值。
- 在创建一个类的新对象时，系统会自动的调用该类的构造方法完成对新对象的初始化。
- 一个类可以定义多个不同的构造方法。
- 如果程序员没有定义构造方法，系统会自动生成一个默认的无参构造方法。
- 如果创建了有参数的构造方法，则系统不自动生成无参数的构造方法，程序员一般需要手动创建。
注意：在类中的 this 是自身的一个对象，代表对象本身，可以理解为：指向对象本身的一个指针。
练习：
1.在程序中经常要对时间进行操作但是并没有时间类型的数据。那么我们可以自己实现一个时间类来满足程序中的需要。定义名为 MyTime 的类其中应有三个整型成员时 hour 分 minute 秒 second。为了保证数据的安全性这三个成员变量声明为私有。为 MyTime 类定义构造方法以方便创建对象时初始化成员变量。再定义 display() 方法用于将时间信息打印出来。为 MyTime 类添加以下方法 addSecond(int sec)、addMinute(int min)、addHour(int hou)、subSecond(int sec)、subMinute(int min)、subHour(int hou) 分别对时、分、秒进行加减运算。
参考代码：
public class MyTime {
private int hour;
private int minute;
private int second;
public MyTime(int x, int y, int z) {
this.hour = x;
this.minute = y;
this.second = z;
}
public void display() {
System.out.println("现在时间：" + this.hour + ":" + this.minute + ":" + this.second);
}
public void addHour(int hou) {
this.hour = this.hour + hou;
}
public void addSecond(int sec) {
this.second = this.second + sec;
}
public void addMinute(int min) {
this.minute = this.minute + min;
}
public void subHour(int hou) {
this.hour = this.hour - hou;
}
public void subMinute(int min) {
this.minute = this.minute - min;
}
public void subSecond(int sec) {
this.second = this.second - sec;
}
}
六、类变量
1.类变量
类变量（static field）是该类的所有对象共享的变量。任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量。
语法如下：
访问修饰符 static 数据类型 变量名；
案例：完成对象创建个数统计
public class Person {
public static int count;
public int age;
public String name;
public Person() {
count++;
}
public static void main(String[] args) {
Person person = new Person();
Person person1 = new Person();
System.out.println(person1.count);//2
person.age = 12;
person.name = "张三";
new Person();
System.out.println(Person.count);//3
}
}
思考一下，类变量还可以用在哪些地方。
七、类方法(静态方法)
类方法（static method）是属于所有对象实例共享的方法。
语法如下：
访问修饰符 static 数据返回类型 方法名(参数列表){}
注意：
- 类方法中不能访问普通属性（实例属性），而普通方法既可以访问普通属性也可以访问静态属性。
- 一般使用 类名.类方法名() 或者 对象名.类方法名() 调用类方法（int i = Integer.parseInt(“12”);）
案例：
public class Person {
public static int count;
public int age;
public String name;
public Person() {
count++;
}
public void say() {//普通方法既可以访问类属性，也可以普通属性
System.out.println("我是" + name + "，我是好人,共" + count + "个对象");
}
public static void staticSay() {//类方法不能访问对象属性（实例属性，普通属性）
System.out.println("创建了" + count);
}
public static void main(String[] args) {
Person person = new Person();
person.staticSay();//对象.方法名（） 方式调用静态方法
Person.staticSay();//类名.方法名（） 方式调用静态方法
new Person();
System.out.println(Person.count);
}
}
思考一下类方法在实际开发中的主要作用。
练习：
1.用自己的话描述 static 的用法，它修饰的属性与方法都有哪些特征。
八、方法重载
方法重载（overload [əʊvəˈləʊd]）就是在类的同一种功能的多种实现方法，方法的参数列表不同，到底采用哪个方法调用（Invoke [ɪnˈvəʊk]），取决于调用者给出的参数（Parameter [pəˈræmɪtə®]）。
注意事项：
- 方法名必须相同。
- 方法的参数类型、个数、顺序至少有一项不同，简称参数列表不同（Parameter list）。
- 方法的返回类型，访问级别和 throws 子句对使其成为重载方法没有任何影响。
案例:
public void aa(){
}
public void aa(int i1){
}
如上就是方法的重载，重载在我们后面开发中是非常常见的。
练习：
1.创建一个类 MathUtil 并使该类无法创建对象，里面编写三个重载的静态方法方法 max 。第一个方法求两个 int 值中的最大值，第二个方法求两个 double 中的最大值，第三个方法求三个 double 中的最大值，并且分别调用三个方法。
参考代码：
public class MathUtil {
private MathUtil() {
}
public static int max(int i, int j) {
return (i > j) ? i : j;
}
public static double max(double i, double j) {
return (i > j) ? i : j;
}
public static double max(double i, double j, double k) {
return max(i, j) > k ? max(i, j) : k;
}
}
class MainTest {
public static void main(String[] args) {
int i1 = MathUtil.max(3, 4);
System.out.println("两个int中的最大值是：" + i1);
double i2 = MathUtil.max(3.1, 3.2);
System.out.println("两个double中的最大值是：" + i2);
double i3 = MathUtil.max(3.1, 3.2, 3.3);
System.out.println("三个double中的最大值是：" + i3);
}
}
九、方法覆盖
方法覆盖也叫方法重写（override）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的那个方法。
java 里面的所有类都是 Object 的子类。
注意事项：
- 子类的方法的返回类型，参数，方法名称，要和父类的返回类型，参数，方法名称完全一样，否则不能构成方法覆盖。
- 一般在覆盖的方法上添加注解（@Override），用于检查和方法的返回类型，参数，方法名称是否完全一样。
- 子类方法不能缩小父类方法的访问权限。
案例：
Object 的 toString
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
自己的 toString
@Override
public String toString() {
return "Person{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
方法覆盖主要是子类覆盖父类的方法。
十、抽象
我们在前面去定义一个类时候，实际上就是把一类事物的共有的属性（Field）和行为（Method）抽取出来，形成一个物理模型，叫做模版类（class）。这种研究问题的方法称为抽象（abstract）。
十一、封装
封装就是把抽象出来的属性（Field）数据和对属性数据的操作封装在一起，属性数据被保护在内部，程序的其它部分只有通过被授权的成员方法（Method）操作数据，没有对应的授权方法则该属性数据不可操作。
常见的属性数据操作有：设置（setter）和获取（getter）。
public class Person {
private String wxh;
private int age;
private String name;
public Person(String wxh) {
this.wxh = wxh;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class MainTest {
public static void main(String[] args) {
Person person = new Person("wpf_123");
person.setName("张三");
person.setAge(18);
System.out.println(person.getAge());
}
}
在开发过程中，经常把一些常用的代码块放入一个方法，其他类或对象在使用时直接调用该方法，而不用再重新写一遍，从而增加代码的复用率，这种操作也叫做封装。
十二、继承
继承（extend）可以解决代码复用问题，让我们的编程更加靠近人类思维。当多个类存在相同的属性（变量）和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性（Field）和方法（Method），所有的子类不需要重新定义这些属性和方法，只需要通过 extends 语句来声明继承父类。这样，子类就会自动拥有父类定义的某些属性和方法。
语法：
class 子类 extends 父类
父类的 public、protected 和默认修饰符修饰的属性和方法被子类继承了，而父类的 private 修饰符修饰的属性和方法不能被子类继承。
public class Student extends Person {
private String classRoom;
}
注意：super 可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。
案例：当我们在 Person 里面添加一个全参构造时，在子类 Student 里面通过 super 调用父类构造方法。
public Student(int age, String name, String classRoom) {
super(age, name);
//super.setAge(age);
setName(name);
this.classRoom = classRoom;
}
java 的继承是单继承，也就是一个类最多只能有一个父类，这种单继承的机制可保证类的纯洁性，比 C++ 中的多继承机制简洁。
练习：
建立一个汽车 Auto 类：汽车颜色、车身重量、速度等成员变量。并通过不同的构造方法创建实例。至少要求汽车能够加速减速停车。再定义一个小汽车类 Car 继承 Auto 并添加空调成员变量并覆盖加速方法。
public class Auto {
private String color;
private double weight;
private int speed;
public void speedUp() {
System.out.println("我在加速");
}
public void speedDown() {
System.out.println("我在减速");
}
public void stop() {
System.out.println("熄火了");
}
public static void main(String[] args) {
Car car = new Car();
car.speedUp();
}
}
class Car extends Auto {
private String airCondition;
@Override
public void speedUp() {
System.out.println("我在加速！！！");
}
}
十三、多态
多态就是指一个引用类型在不同情况下的多种状态。也可以理解成：
多态是指父类的类型可以存放子类的实例；
通过调用父类的方法自动调用子类实现了的或重写了的方法；
Person person = new Student();
这种转换时自动完成的，在调用 Person 对象的方法时自动调用 student 重写或实现的方法。
缺点：使用多态会使创建出来的对象丢失子类的方法。
优点：大多在设计模式中使用，使程序更加通用。
class MainTest {
public static void main(String[] args) {
Person person1 = new Student(1, "张三", "java2004");
Student person2 = new Student(1, "张三", "java2004");
Worker person3 = new Worker(1, "张三", "天狼科技");
changeName(person2, "历史");
}
private static void changeName(Person person, String name) {
person.setName(name);
}
}
十四、抽象类
当父类的一些方法不能确定时，可以用 abstract [ˈæbstrækt] 关键字来修饰该方法，这种方法叫做抽象方法（abstract method）。拥有抽象方法的类必须添加 abstract 关键字修饰，用 abstract 来修饰的类叫抽象类（abstract class）。
public abstract class Animal {
private String name;
abstract public void cry();
public void sx() {
System.out.println("实现方法");
}
public static void main(String[] args) {
Animal dog = new Dog();
dog.cry();
}
}
class Dog extends Animal {
@Override
public void cry() {
System.out.println("汪汪汪汪！！！！");
}
}
- 用 abstract 关键字来修饰一个类时，这个类就是抽象类，抽象类不能被实例化（new Animal()）
- 用 abstract 关键字来修饰一个方法时，这个方法就是抽象方法。
- 抽象方法是不允许在该抽象类中实现的（void cry() { }）也就是方法不能有方法体，一旦实现（有方法体）就编译报错。
- 抽象方法只能在子类中实现。
- 抽象类中可以拥有实现过的方法。
注意：
抽象类不一定要包含抽象方法。也就是说，抽象类可以没有抽象方法。一旦类包含了抽象方法，则这个类必须声明为抽象类。
练习：
创建一个 Vehicle 类并将它声明为抽象类。在 Vehicle 类中声明一个 getWheels 抽象方法使它输出轮子个数。创建两个类 Car 和 Motorbike 从 Vehicle 类继承并在这两个类中实现 getWheels 方法。在 Car 类中应当显示“四轮车”信息而在 Motorbike 类中应当显示“双轮车”信息。创建另一个带 main 方法的类在该类中创建 Car 和 Motorbike 的实例并在控制台中显示消息。
public class Demo{
public static void main(String[] dsa) {
Car c = new Car();
c.getWheels();
Motorbike m = new Motorbike();
m.getWheels();
}
}
abstract class Vehicle {
abstract public void getWheels();
}
class Car extends Vehicle {
public void getWheels() {
System.out.println("四轮车");
}
}
class Motorbike extends Vehicle {
public void getWheels() {
System.out.println("双轮车");
}
}
十五、接口
接口（interface [ˈɪntəfeɪs]）就是给出一些没有方法体的方法，封装到一起，到某个类要使用的时候，再根据具体情况把这些方法写出来。接口是更加抽象的抽象类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体。接口体现了程序设计的多态和高内聚低偶合的设计思想。接口和类之间一般使用 implements [ˈɪmplɪments]表示父子关系。
接口的建立语法：
interface 接口名{
方法;
}
实现类语法：
class 类名 implements 接口{
方法;
变量;
}
高内聚，低耦合：
每个模块之间相互联系的紧密程度，模块之间联系越紧密，则耦合性越高，模块的独立性就越差！反之同理；
一个模块中各个元素之间的联系的紧密程度，如果各个元素（语句、程序段）之间的联系程度越高，则内聚性越高，即高内聚！
如：一个项目中有 20 个方法调用良好，但是要修改了其中一个，另外的 19 个都要进行修改，这就是高耦合！独立性太差！
现在的软件结构设计，都会要求“高内聚，低耦合”，来保证软件的高质量！
public interface Person {
void say();
}
class PersonMain implements Person {
@Override
public void say() {
System.out.println("1212");
}
public static void main(String[] args) {
Person person = new PersonMain();
person.say();
}
}
注意：
- 接口不能被实例化（new Person()），接口中的方法默认都是 public 修饰的。
- 接口中所有的方法都不能有方法体（void aaa(){}），故接口可以看作更加抽象的抽象类。
- 一个类可以实现多个接口（class PersonMain implements Person, Serializable{}）。
- 接口中可以有变量，但变量不能用 private 和 protected 修饰。接口中的变量，本质上都是 static 的而且是 final （最终的）类型的，不管你加不加 static 修饰，通常称为常量。
- 一个接口不能继承其它的类，但是可以继承别的接口。
public interface Person {
int aa = 0;
void say();
}
interface PersonMain extends Person {
public void say1();
}
class Main implements PersonMain {
@Override
public void say() {
}
@Override
public void say1() {
}
}
案例：
public class Demo {
public static void main(String[] args) {
LittleMonkey li = new LittleMonkey();
li.setName("孙悟空");
li.swimming();
li.fly();
}
}
interface Fish {
void swimming();
}
interface Bird {
void fly();
}
class Monkey {
private String name;
public void setName(String name) {
this.name = name;
}
public void jump() {
System.out.println("猴子会跳!");
}
}
class LittleMonkey extends Monkey implements Fish, Bird {
public void swimming() {
System.out.println("学到了鱼的游泳!");
}
public void fly() {
System.out.println("学到了鸟飞翔!");
}
}
注意：
- 实现接口可以看作是对继承的一种补充。
- 实现接口可在不打破继承关系的前提下，对某个类功能扩展，非常灵活。
练习：
1.创建一个名称为 Vehicle 的接口在接口中添加两个方法 start() 和 stop()。在两个名称分别为 Bike 和 Bus 的类中实现 Vehicle 接口。创建一个名称为 InterfaceDemo 的类在 InterfaceDemo 的 main() 方法中创建 Bike 和 Bus 对象并访问 start() 和 stop() 方法。
参考代码：
public class InterfaceDemo {
public static void main(String[] dsa) {
Bike bike = new Bike();
bike.start();
bike.stop();
Bus bus = new Bus();
bus.start();
bus.stop();
}
}
class Bike implements Vehicle {
public void start() {
System.out.println("我是自行车，我启动了！！");
}
public void stop() {
System.out.println("我是自行车，我停止了！！");
}
}
class Bus implements Vehicle {
public void start() {
System.out.println("我是公共汽车，我启动了！！");
}
public void stop() {
System.out.println("我是公共汽车，我停止了！！");
}
}
public interface Vehicle {
void start();
void stop();
}
十六、new 运算符背后（自）
new 运算符，new 创建对象实例（new User(“aa”)），对象引用（s）指向对象实例。
对象实例在堆内存中， 对象引用存放在栈内存中。
一个对象引用可以指向 0 个或 1 个对象 （一根绳子可以不系气球，也可以系一个气球）;
一个对象可以有 n 个引用指向它（可以用 n 条绳子系住一个气球）。
String s = new String("aa");
String s1= s;
阶段练习：
-
1.编写 Java 程序模拟简单的计算器。 定义名为 Number 的类其中有两个整型数据成员 n1 和 n2 应声明为私有。编写构造方法赋予 n1 和 n2 初始值再为该类定义加 addition、减 subtraction、乘 multiplication、除 division 等公有成员方法分别对两个成员变量执行加、减、乘、除的运算。 在 main 方法中创建 Number 类的对象调用各个方法并显示计算结果。
-
2.定义一个网络用户类 User，要存储私有的信息有用户 id、用户密码 password、email 地址。在建立类的实例时把以上三个信息都作为构造函数的参数输入其中。用户 id 和用户密码是必须的，缺省 email 地址时用户 email 使用用户 id 加上字符串 @gameschool.com。
-
3.创建一个圆 Circle 类， 为该类提供一个变量 r 表示半径，一个常量 PI 表示圆周率； 同时为该类提供两个方法：方法一用于求圆的面积，方法二用于求圆的周长； 为该类提供一个有参的构造方法，用于初始化 r 的值。 在 main 方法中测试。
-
4.编写一个类 Triangle 并为该类创建一个三个整数参数的构造方法，在构造方法中判断是否能构成三角形，如果能构成三角形就提供两个方法计算该三角形的周长和面积。
-
海伦公式： 公式描述：
公式中 a，b，c 分别为三角形三边长，p 为半周长，S 为三角形的面积。
参考代码：
题1
class Number {
private int n1;
private int n2;
public Number(int n1, int n2) {
this.n1 = n1;
this.n2 = n2;
}
public int addition() {
return n1 + n2;
}
public int subtraction() {
return n1 - n2;
}
public int multiplication() {
return n1 * n2;
}
public int division() {
return n1 / n2;
}
public static void main(String[] args) {
Number number = new Number(3, 6);
System.out.println(number.addition());
System.out.println(number.subtraction());
System.out.println(number.multiplication());
System.out.println(number.division());
}
}
题2：
class User {
private int id;
private String password;
private String email;
public User(int id, String password) {
this.id = id;
this.password = password;
this.email = id + "@gameschool.com";
}
public User(int id, String password, String email) {
this.id = id;
this.password = password;
this.email = email;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", password='" + password + '\'' +
", email='" + email + '\'' +
'}';
}
public static void main(String[] args) {
User user1 = new User(1, "123");
User user2 = new User(1, "123", "123@qq.com");
System.out.println(user1);
System.out.println(user2);
}
}
题3：
class Circle {
private double r;
private static final double PI = 3.14159;
public Circle(double r) {
this.r = r;
}
public double perimeter() {
return 2 * PI * r;
}
public double area() {
return PI * r * r;
}
public static void main(String[] args) {
Circle circle = new Circle(5);
System.out.println(circle.area());
System.out.println(circle.perimeter());
}
}
题4：
class Triangle {
private int a;
private int b;
private int c;
public Triangle(int a, int b, int c) {
if (a + b < c || a + c < b || c + b < a) {
System.out.println("不能构成三角形");
return;
}
this.a = a;
this.b = b;
this.c = c;
}
public double perimeter() {
return a + b + c;
}
public double area() {
double p = perimeter()/2;
return Math.pow(p * (p - a) * (p - b) * (p - c), 0.5);
}
}
626
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
