1 构造方法
构造方法是一种特殊的方法，只有在创建对象的时候才被调用，用来执行初始化的操作，比如给属性赋值...
1) 构造方法名字跟类名一致，没有返回值也就没有返回值类型
2) 格式：
类名(参数列表){
方法体
}
3) 创建对象的标准格式：
类名 对象名 = new 构造方法
案例：Demo1
public class Demo11 {
public static void main(String[] args) {
Math2 math = new Math2();
math.sub(100, 50);
math.sub(100.1, 2.3);
math.sub(2.99, 1);
math.sub(100.1, 100);
}
}
class Math2{
void sub(int num1,int num2){
int result = num1 - num2;
System.out.println("result = "+result);
}
void sub(double num1,int num2){
double result = num1 - num2;
System.out.println("result = "+result);
}
void sub(int num1,double num2){
double result = num1 - num2;
System.out.println("result = "+result);
}
void sub(double num1,double num2){
double result = num1 - num2;
System.out.println("result = "+result);
}
}
public class Demo2 {
public static void main(String[] args) {
User user1 =
new User("刘备",42,"abc","成都",
"bei@126.com");
user1.show();
User user2 =
new User("黄忠",56,"123456","襄阳",
"zhong@163.com");
user2.show();
}
}
class User{
//属性
String name;
int age;
String password;
String address;
String email;
//构造方法
User(String name1,int age1,
String password1,String address1,
String email1){
name = name1;
age = age1;
password = password1;
address = address1;
email = email1;
}
//方法
void show(){
System.out.println(name+","+age+","
+password+","+address+","+
email);
}
}
4) 如果该类中不编写构造方法，则系统默认提供一个空参的构造方法；反之如果编写了构造方法，则会覆盖系统默认提供的空参的构造方法。
案例：Demo3
public class Demo3 {
public static void main(String[] args) {
//类名 对象名 = new 构造方法
Foo foo = new Foo();
}
}
//如果该类中没有编写构造方法，则系统默认提供一个空参
//构造方法；如果该类中编写了构造方法，则会覆盖系统
//默认提供的空参的构造方法。
class Foo{
//Foo(){系统默认提供空参（没有参数）的构造方法
//}
}
public class Demo4 {
public static void main(String[] args) {
// Koo koo = new Koo();//默认空参构造方法
//报错，在Koo的内部又编写一个带两个参数的构造方法，
//会覆盖系统提供的空参的构造方法。在Koo内部只有编写
//的带两个参数的构造方法。
Koo koo2 = new Koo("张三",21);
}
}
class Koo{
String name;
int age;
Koo(String name1,int age1){
name = name1;
age = age1;
}
}
public class Demo5 {
public static void main(String[] args) {
Box1 box = new Box1(100,20,90);
box.show();
box.showTiji();
Box1 box2 = new Box1(200,100,150);
box2.show();
box2.showTiji();
}
}
class Box1{
//属性
int length;
int width;
int height;
//构造方法
Box1(int length1,int width1,int height1){
length = length1;
width = width1;
height = height1;
}
//方法
void show(){
System.out.println(length+","+width
+","+height);
}
void showTiji(){
int result = length * width * height;
System.out.println("体积是"+result);
}
}
5) 在企业中建议，构造方法中参数的名字跟要赋值的属性名最好一致，这样对应关系更加的清楚。
this.属性名：指代当前的属性
class Person{
//属性
String name;
int age;
double salary;
String address;
//构造方法
Person(String name,int age,double salary,
String address){
this.name = name;
// 属性 参数
this.age = age;
this.salary = salary;
this.address = address;
}
}
案例：Demo6
public class Demo6 {
public static void main(String[] args) {
Person2 p =
new Person2("李白",31,20000.1);
p.show();
}
}
class Person2{
//属性：
String name;
int age;
double salary;
//构造方法：
Person2(String name,int age,
double salary){
this.name = name;
this.age = age;
this.salary = salary;
// 属性 参数
}
//方法：void show():输出每一个属性值
void show(){
System.out.println(name+","+age+","
+salary);
}
}
public class Demo7 {
public static void main(String[] args) {
User2 user =
new User2("张三丰","abc",
99,"道士","13555555555");
user.showAll();
}
}
class User2{
//属性
String name;
String password;
int age;
String job;
String phone;
//构造方法
User2(String name,String password,
int age,String job,String phone){
this.name = name;
this.password = password;
this.age = age;
this.job = job;
this.phone = phone;
}
//方法
void showAll(){
System.out.println(name+","+password
+","+age+","+job+","+phone);
}
}
public class Demo8 {
public static void main(String[] args) {
Manager manager =
new Manager("张居正",32,
2000000.1,1000000.1,"北京");
manager.show();
manager.showYearSal();
}
}
class Manager{
//属性
String name;
int age;
double salary;
double comm;
String address;
//构造方法
Manager(String name,int age,
double salary,double comm,
String address){
this.name = name;
this.age = age;
this.salary = salary;
this.comm = comm;
this.address = address;
}
//方法
void show(){
System.out.println(name+","+age+","
+salary+","+comm+","+address);
}
void showYearSal(){
double result = salary*12+comm;
System.out.println(name+"的年薪是"+
result);
}
}
public class Demo9 {
public static void main(String[] args) {
Car car =
new Car("哥的奥迪","666666","内敛奢华",
"黑色",2000000000.1);
car.show();
car.start();
car.run();
car.stop();
}
}
class Car{
//属性
String name;
String no;
String type;
String color;
double price;
int speed=0;
//构造方法
Car(String name,String no,String type,
String color,double price){
this.name = name;
this.no = no;
this.type = type;
this.color = color;
this.price = price;
}
//方法
void show(){
System.out.println(name+","+no+","+
type+","+color+","+price+
","+speed);
}
void start(){
speed = 100;
System.out.println(name+"启动了");
}
void run(){
System.out.println(name+"在行驶，" +
"当前的速度是"+speed);
}
void stop(){
speed = 0;
System.out.println(name+"刹车了，" +
"当前的速度是"+speed);
}
}
总结：构造方法是一种特殊的方法，只有在创建对象的时候才被调用，用来执行初始化的操作，比如给属性赋值...构造方法的名字跟类名一致，没有返回值类型。
2 方法重载
在一个类的内部，方法名相同，参数不同的多个方法。
案例：Demo10
public class Demo10 {
public static void main(String[] args) {
/*
Math1 math = new Math1();
math.add3(1.1, 200);
math.add4(2.2,5.3);
math.add1(300, 500);
math.add2(1000, 2.2);
*/
Math1 math = new Math1();
math.add(100, 100);
math.add(200, 1.66);
math.add(10.1, 1000);
math.add(2.6, 3.3);
}
}
class Math1{
void add(int num1,int num2){
int sum = num1 + num2;
System.out.println(sum);
}
void add(int num1,double num2){
double sum = num1 + num2;
System.out.println(sum);
}
void add(double num1,int num2){
double sum = num1 + num2;
System.out.println(sum);
}
void add(double num1,double num2){
double sum = num1 + num2;
System.out.println(sum);
}
}
public class Demo11 {
public static void main(String[] args) {
Math2 math = new Math2();
math.sub(100, 50);
math.sub(100.1, 2.3);
math.sub(2.99, 1);
math.sub(100.1, 100);
}
}
class Math2{
void sub(int num1,int num2){
int result = num1 - num2;
System.out.println("result = "+result);
}
void sub(double num1,int num2){
double result = num1 - num2;
System.out.println("result = "+result);
}
void sub(int num1,double num2){
double result = num1 - num2;
System.out.println("result = "+result);
}
void sub(double num1,double num2){
double result = num1 - num2;
System.out.println("result = "+result);
}
}
1）编写类的方法时候，可以把功能相似的方法起同一个名字，参数要不同，通过参数区分开每一个方法，用户只需要记住一个名字，就可以调用相似功能的多个方法。
2）参数不同：参数类型或者个数必须有一个不同，跟形参的名字无关。
3）方法重载的好处：方法重载并没有简化代码的编写，但是用户只需要记住一个名字，就可以调用相似功能的多个方法，简少用户的记忆量，方便用户调用方法。
4）方法重载属于多态的一种。
多态：多态是面向对象的编程思想之一，事物在不同的情况下有不同的表现。
eg：花朵，花生，花心，花钱
5）Sun公司编写的工具类，经常使用到方法重载，方便用户来访问这些方法，用户只要记住一个名字，就可以调用相似功能的多个方法。
System.out.println(100);
System.out.println(1.66);
System.out.println(false);
System.out.println('中');
System.out.println("今天风很大");
案例：Demo12
public class Demo12 {
public static void main(String[] args) {
Kongtiao kt =
new Kongtiao("美的","柜式",
20000.1,"白色",25);
kt.show();
kt.cool();
kt.cool(5);
kt.hot();
kt.hot(3);
}
}
class Kongtiao{
//属性
String name;
String type;
double price;
String color;
int degree;
//构造方法
Kongtiao(String name,String type,
double price,String color,
int degree){
this.name = name;
this.type = type;
this.price = price;
this.color = color;
this.degree = degree;
}
//方法
void show(){
System.out.println(name+","+type+","
+price+","+color+","+degree);
}
void hot(){
degree++;
System.out.println(name+"升高1度以后，"
+"当前的温度是"+degree);
}
void hot(int degree){
this.degree = this.degree + degree;
System.out.println(name+"升高"+degree
+"度以后，当前的温度"+this.degree);
}
void cool(){
degree--;
System.out.println(name+"降低1度以后，"
+"当前的温度是"+degree);
}
void cool(int degree){
this.degree = this.degree - degree;
System.out.println(name+"降低"+degree
+"度以后，当前的温度是"+this.degree);
}
}
public class Demo13 {
public static void main(String[] args) {
Zoo1 zoo = new Zoo1();
zoo.f1();
zoo.f2(10);
}
}
//如果一个方法中的参数名字跟属性一致，在该方法中，
//必须使用this.属性名，来指代当前的属性，如果不加
//this关键字，就是参数
class Zoo1{
//属性
int num1 = 100;
//方法
void f1(){
System.out.println("属性num1的值是"
+num1);
}
void f2(int num1){
num1 = 1000;//参数
System.out.println("参数num1的值是"
+num1);
//this.属性名：指代当前的属性
System.out.println("属性num1的值是"
+this.num1);
}
}