文章目录
- 1.方法
- 1.说明
- 2.代码
- 3.解释
- 1.方法规范
- 2.方法重载
- 2.类与对象
- 1.说明
- 2.代码
- 3.解释
- 1.类的规范
- 2.this的使用
- 3.调用类定义对象
- 3.构造方法
- 1.说明
- 2.代码
- 3.解释
- 1.构造函数规范
- 2.构造方法重载
- 3.static用法
- 4.构造器
1.方法
1.说明
我们可以使用方法来完成某一个功能,用的时候直接调用方法。
2.代码
public class fangFa {
/**
* 方法使用
* 定义了一个方法“fang”
* 只是定义了一个方法,并没有进行调用
*/
public static void fang(){
System.out.println("abc");
System.out.println("def");
System.out.println("lmn");
}
/**
* 写一个数数的方法
*/
public static void coutn(){
for(int i=0;i<10;i++){
System.out.print(i+" ");
}
System.out.println("\n完成");
}
/**
* 方法返回值
* 方法返回值的时候要在函数名前面声明
* 需要写出返回值的类型
*/
public static String buy1(){
System.out.println("买一包烟");
return "中华香烟";
}
/**
*方法传参
* 在函数名后面括号里写入参数
*/
public static void buy2(String goods,int price){
System.out.println("需要买:"+goods+" 价格:"+price);
}
/**
*方法的重载
* 可以省去起名字的烦恼
* 可以传入不同的参数
* 参数不同时他会自动寻找对应的函数
*/
public static void add(int a,int b){
System.out.print("int计算:");
System.out.println(a+b);
}
public static void add(double a,double b){
System.out.print("double计算:");
System.out.println(a+b);
}
public static void add(double a,double b,int c,int d){
System.out.print("四个数计算:");
System.out.println("a+b="+(a+b)+" c+d="+(c+d));
}
//主函数,程序的入口
public static void main(String[] args) {
//调用方法
fang();//调用“fang”这个方法
coutn();
String bu=buy1();//进行接受返回值
System.out.println(bu);
buy2("肉",50);
add(3,4);
add(1.5,4.2);
add(1.2,2.5,3,4);
}
}
3.解释
1.方法规范
public static 返回值类型 方法名(参数类型 参数){
语句
return 返回值
}
返回值与返回类型要匹配,当不返回值时可以将返回值类型写为void,不写return。
当不传参数时括号里面不写,当传入多个参数时可用逗号分开。
2.方法重载
public static void add(int a,int b){
System.out.print("int计算:");
System.out.println(a+b);
}
public static void add(double a,double b){
System.out.print("double计算:");
System.out.println(a+b);
}
方法的重载
当传入的参数类型不同或个数不同时,我们可以使用方法的重载,这样可以减少命名带来的烦恼。
当我们调用方法传入参数时,会自动寻找对应的方法。
2.类与对象
1.说明
我们可以对某一个功能进行封装,进行打包,定义出一个类。
当我们使用这个类的时候可以调用这个类定义出一个对象,然后通过这个对象来实现对应的功能。
2.代码
class carDx{
String yanse;//颜色
int sudu;//速度
int zuowei;//座位
//成员方法
public void run(){
//this相当于carDxs方法中的对象c
System.out.println("run方法中:\n\t车速度:"+this.sudu);
System.out.println("\t车正常,可以上路");
}
public void fly(){
System.out.println("fly方法中:\n"+"\t车颜色:"+this.yanse);
System.out.println("\t经过改造,车可以飞");
}
/**
* this用法
* 在调用方法时,默认讲参数传给方法,在方法中可以使用this接受参数
*在查找变量的时候先看自己方法里面有没有,如果没有再在类中查找
*/
public void swim(String yanse){
System.out.println("swim方法中:");
System.out.println("\t在"+yanse+"的海里面");
System.out.println("\t车颜色:"+this.yanse);
System.out.println("\t车座位:"+zuowei);
}
}
public class LeiyuDuixiang{
public static void carDxs(){
//创建对象,这种变量称为引用
carDx c =new carDx();//carDx中的属性就是类中定义好的成员变量
c.yanse="白色";
c.sudu=120;
c.zuowei=5;
c.run();//在调用方法时,默认讲参数传给方法,在方法中可以使用this接受参数
c.fly();
c.swim("蓝色");
System.out.println("carDxs方法中:\n\t车座位:"+c.zuowei);
System.out.println("\t"+c.yanse+" "+c.sudu+" "+c.zuowei);
}
public static void main(String[] args) {
carDxs();
}
}
3.解释
1.类的规范
class carDx{
成员变量类型 成员变量名
public 返回值类型 成员方法名(参数类型 参数){
语句
return 返回值。
}
}
类中由成员变量和成员方法构成。
2.this的使用
public void swim(String yanse){
System.out.println("swim方法中:");
System.out.println("\t在"+yanse+"的海里面");
System.out.println("\t车颜色:"+this.yanse);
System.out.println("\t车座位:"+zuowei);
}
一个类可以定义多个对象,当我们要在类中使用某个对象的成员变量,我们可以使用this。
在调用方法时,默认讲参数传给方法,在方法中可以使用this接受参数
在查找变量的时候先看自己方法里面有没有,如果没有再在类中查找
3.调用类定义对象
carDx c =new carDx()
c.yanse="白色";
c.swim("蓝色")
第一行:通过carDx定义出一个对象c
第二行:对成员变量进行赋值
第三行:调用成员方法
3.构造方法
1.说明
当我们在定义对象时就需要往类中传入参数,我们可以使用构造方法来为类传入参数。
2.代码
class carGz{
/**
* 构造方法
* 在定义对象的时候这个类就会自动调用构造方法
* 当我们不写构造方法时java会给出一个无参数的构造方法
* 当我们定义了构造方法后系统就不会给我们默认的构造方法
* 在静态方法和静态块中不能使用this
*/
String yanse;
int sudu;
int zuowei=5;
public carGz(String yanse, int sudu) {
this.yanse=yanse;
this.sudu=sudu;
}
public void run(){
System.out.println("车正常,可以跑");
}
}
class daxiaGz{
/**
* 构造方法重载
* 构造方法也是方法,可以进行重载
* 当传入不同的参数时,java会自动寻找对应的构造方法
*/
String name;
String waihao;
int age;
String bangpai;
public daxiaGz(String name,int age,String bangpai){
this.name=name;
this.age=age;
this.bangpai=bangpai;
}
public daxiaGz(String name,String waihao,int age,String bangpai){
// 方法一
// this.name=name;
// this.waihao=waihao;
// this.bangpai=bangpai;
// this.age=age;
// 方法二
this(name,age,bangpai);//使用this可以调用当前类中其他的构造方法
this.waihao=waihao;
}
public void information(){
System.out.println("姓名:"+this.name+"\t外号:"+this.waihao+"\t年龄:"+this.age+"\t帮派:"+this.bangpai);
}
}
class personGz{
/**
* static用法
* 静态的内容在内存中保留一份
* 在各个对象中进行共享
* 属于类而不属于对象
* 静态优先于对象产生
*/
String name;
static String country="大清";
String address;
public personGz(String name,String address){
this.name=name;
this.address=address;
}
public void inform(){
System.out.println("姓名:"+this.name+"\t国籍:"+ country+"" + "\t地址:"+this.address);
}
}
class youxianGz{
{
System.out.println("通用构造器");
}
static {
System.out.println("静态构造器");
}
/**
* 当定义对象时
* 先执行静态构造器
* 然后执行通用构造器
* 最后执行构造函数
*/
public youxianGz(){
System.out.println("构造函数");
}
}
public class GouzaoFangfa {
public static void carGzs(){
carGz c1=new carGz("白色",150);
System.out.println(c1.zuowei);
c1.run();
carGz c2=new carGz("黑色",120);
System.out.println(c2.zuowei);
c2.run();
}
public static void daxiaGzs(){
daxiaGz zhangsan=new daxiaGz("张三",21,"三帮");
zhangsan.information();
daxiaGz lisi=new daxiaGz("李四","小四",23,"四帮");
lisi.information();
}
public static void personGzs(){
personGz p1=new personGz("张三","八大胡同");
p1.inform();
personGz p2=new personGz("李四","朝阳门");
p2.inform();
personGz.country ="民国";//通过类调用静态变量
p1.inform();
p2.inform();
}
public static void youxianGzs(){
new youxianGz();
}
public static void main(String[] args) {
System.out.println("---------------------------------------------------");
carGzs();
System.out.println("---------------------------------------------------");
daxiaGzs();
System.out.println("---------------------------------------------------");
personGzs();
System.out.println("---------------------------------------------------");
youxianGzs();
}
}
3.解释
1.构造函数规范
public carGz(String yanse, int sudu) {
this.yanse=yanse;
this.sudu=sudu;
}
public 类名(参数类型 参数){
this.成员变量 = 参数
}
当我们调用类时,系统会自动调用构造方法,当我们没有定义构造方法时系统会自动生成一个空的构造方法,当我们定义了构造方法时,系统就不会再定义构造方法
2.构造方法重载
public 类名(参数1,参数2,参数3) {
语句
}
public 类名(参数4,参数5,参数6,参数7) {
语句
this(参数1,参数2,参数3)
}
构造方法也是一种方法,也可以进行重载,当传入不同的参数时,java会自动寻找对应的构造方法。
当使用this时,系统会调用当前类中其他的构造方法。
3.static用法
static 静态
静态内容属于类而不属于对象。静态的东西可以在各个类中进行共享,静态优先于对象产生。
4.构造器
class 类名{
System.out.println("通用构造器");
}
static {
System.out.println("静态构造器");
}
public 类名(){
System.out.println("构造函数");
}
}
当定义对象时,先执行静态构造器,然后执行通用构造器,最后执行构造函数