//大家可以关注一下我的博客 我的博客所有随笔都是我从基础开始学习java的所有知识点
/*构造方法是一种特殊的方法，专门用于构造/实例化对象，
形式:[修饰符] 类名(){ }
构造方法根据是否有参数分为无参构造和有参构造*/
public class Dog { //创建Dog类
String name;
int health;
int love;
String sex;
/*
无参方法（一般没有构造方法，系统默认无参方法，
同时可以直接在上面属性声明后面赋值，如果没有赋值，系统自动输入默认值）
但是加有参方法时，建议一定要把无参加上
修饰符+类名（）{}*/
public Dog(){
health=90;
love=10;
}
public void showOf(){
System.out.println("我的名字叫"+name);
System.out.println("健康值:"+health);
System.out.println("亲密度:"+love);
System.out.println("性别:"+sex);
}
}
public class Penguin { //创建Penguin类 String name; int health=100; //属性 int love=0; String kind; public void pay(){ //方法 System.out.println("我的名字叫"+name); System.out.println("健康值"+health); System.out.println("亲密度"+love); System.out.println("品种"+kind); } }
import java.util.Scanner; public class Pet { public static void main(String [] ages){ Scanner arr=new Scanner(System.in); System.out.println("请输入宠物的名字"); String name=arr.next(); System.out.println("请选择宠物类型1.企鹅2.狗狗"); int a=arr.nextInt(); if (a==1){ Penguin sc=new Penguin(); //插入Penguin包 sc.name=name; //赋值（从输入录入的值） System.out.println("请选择性别1.Q女2.Q男"); int b=arr.nextInt(); if (b==1) { sc.kind="Q女"; //赋值 sc.pay(); }else { sc.kind="Q男"; sc.pay(); } }else { Dog sc=new Dog(); sc.name=name; System.out.println("请选择狗的种类1.土狗2.腊肠"); int b=arr.nextInt(); if (b==1){ sc.sex="雄性"; sc.showOf(); }else { sc.sex="雌性"; sc.showOf(); } } } }
4种结果
有参构造
/*构造方法是一种特殊的方法，专门用于构造/实例化对象， 形式:[修饰符] 类名(){ } 构造方法根据是否有参数分为无参构造和有参构造*/ public class Dog { String name; int health=10; int love=10; String sex; public Dog(){ } /*当构造一个对象时可以直接在构造方法中传递参数, 但是加有参方法时，建议一定要把无参加上 this 是一个关键字 表示对象本身，本质上是对象的地址，用来引用对象， this用于访问本对象属性，同时解决局部变量和成员变量同名的问题。 通过打印this中的引用，可以看出对象dog和this指向同一内存。 一般而言，dog(在下面提取Dog类可见)用于类的外部，this用于类的内部。 因为类的内部根本不知道dog变量名的存在。 修饰符 类名（是属于Pet的属性）{}
this可以调用属性也可以调用方法和本类的构造方法（再下面代码有讲调用方法）
*/ /* 如果没有赋值 public Dog(String name,int health,int love,String sex){ //在Pet赋值 this.name=name; //pet先赋值给括号里的属性 this.health=health;// this.Dog类的属性=括号内的属性 this.love=love; this.sex=sex; }*/ //如果已经赋值，可以这样写 public Dog(String name,String sex){ //在Pet赋值 this.name=name; //pet先赋值给括号里的属性 this.sex=sex;// this.Dog类的属性=括号内的属性 } public void showOf(){ System.out.println("我的名字叫:"+this.name); System.out.println("健康值:"+this.health); System.out.println("亲密度:"+this.love); System.out.println("性别:"+this.sex); } }
public class Pet { public static void main(String [] ages){ //如果没有赋值这样写 //Dog dog=new Dog("黑狗",50,50,"雄"); //如果已经赋值这样写 Dog dog=new Dog("黑狗","雄");//类是用new引入 System.out.println("dog:"+dog);//对象的地址 dog.showOf();//用Dog类的方法输出 } }
两种结果
对象初始化内存图
Car car = new Car(…);
当实例化一个对象时，jvm首先把Car.class加载到方法区
[1]读取Car.class 根据声明的成员变量计算申请内存需要的字节数
[2]读取Car.class 中的静态成员,给静态变量分配空间并初始化。
new Car 申请内存得到一个car对象，此时才有对象的空间。showInfo才可以通过car对象调用。
方法的调用内存图
被 static 修饰的静态方法可以访问实例，而实例不可以访问静态，因为静态在类中被先访问（因为在类中，静态优先访问）
如果类中所以都是静态的，那么可以在测试类中使用静态导入 import static ，这样在使用这个类时可以直接使用
/*需求：统计宠物店有几只狗 统计宠物店有几只狗的功能应该放在类功能上，不应该属于某个对象 声明一个变量用于统计个数，这个变量应该被类的实例共享。 被类的实例共享的区域在方法区(Car.class) 用static关键字声明这样的变量 static 关键字表示静态，可以修饰变量，也可以修饰方法。 静态变量 static 修饰的变量称为静态变量/静态属性，形式 ：static 类型 变量名称 [= 初始值] 被static修饰的变量称为静态变量，归类所有， 分配在方法区(共享区)中的静态区，可以被类的实例共享访问。 */ public class Dog { String name; int health; int love; String sex; static int count=0; /*静态变量归类所有，也叫类变量，访问方式 [1] 类名.静态变量(推荐) [2] 对象.静态变量*/ public Dog(){ Dog.count++; }//必须两种构造都写 public Dog(String name,int health,int love,String sex){ this.name=name; this.health=health; this.love=love; this.sex=sex; Dog.count++;//必须两种构造都写 } public void showOf(){ System.out.println("我的名字叫:"+this.name); System.out.println("健康值:"+this.health); System.out.println("亲密度:"+this.love); System.out.println("性别:"+this.sex); System.out.println("我是第"+Dog.count+"只狗"); }
//实例方法可以访问静态成员。
//静态方法不能访问非静态成员。
//[修饰符] static 返回值类型 方法名(arg…){}
//static 修饰的方法称为静态方法，形式
public static int jiaoDog(){
return Dog.count;
}
}
public class Pet { public static void main(String [] ages){ Dog dog1=new Dog("黑狗",50,50,"雄"); dog1.showOf(); Dog dog2=new Dog("白狗",60,20,"雌"); dog2.showOf(); Dog dog3=new Dog("黑狗",60,50,"雄"); dog3.showOf(); System.out.println(Dog.count); System.out.println(dog2.count); //类名.静态变量 对象.静态变量 都得到狗的总数 // 所以建议选 类名.静态 因为选对象容易误会成这是第几只狗 其实所以德对象都是一样的
//静态方法归类所有，调用形式
//[1] 类名.方法名() (推荐)
//[2] 对象.方法名()
//得出来结果同上
System.out.println(Dog.jiaoDog());
System.out.println(dog2.jiaoDog())；
}
}
代码块通过{}声明，根据其位置可以分为普通代码块、静态代码块、构造代码块、同步代码块(多线程讲解)
静态代码块
静态代码块位于类中，归类所有，用static修饰。在类加载时执行，在构建多个对象时只执行一次。
静态代码块一般用于初始化静态资源，构造代码块一般用于初始化实例成员。
普通代码块一般存在于方法或者类、方法等的定义中，普通代码块形成一个作用域
构造代码块位于类中。构造代码块在构造方法前执行。构造一个对象执行一次。
/*封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问， 而是通过该类提供的方法来实现对隐藏信息的操作和访问。 封装的步骤 [1]属性私有化 [2]提供公共的设置器和访问器 [3]在设置器和访问器中添加业务校验逻辑 private 私有的，对外不可见 */ public class Dog { private String name; //private 私有的，对外不可见 private int health; //private 私有的，对外不可见 private int love; //private 私有的，对外不可见 private String sex; //private 私有的，对外不可见 static int count=0; //提供公共的设置器（setter）(设置访问条件，不同条件有不同的应对)和访问器（getter） //设置器在下面被调用并赋值 public void setName(String name){ if(name.equals("")){ System.out.println("姓名不能为空"); }else { this.name=name; } } //用public修饰的成员变量和方法称为共有变量和共有方法： //因为上面已经私有化了，所以调用Dog类只能通过这个来返回值 public String getName(){ return this.name; } public void setHealth(int health){ if (health<0){ System.out.println("健康值不合法"); }else { this.health=health; } } public int getHealth(){ return this.health; } public void setLove(int love){ if (love<0){ System.out.println("亲密度不合法"); } else { this.love=love; } } public int getLove(){ return this.love; } public void setSex(String sex){ if (sex.equals("")){ System.out.println("性别不能为空"); } else{ this.sex=sex; } } public String getSex(){ return this.sex; } //无参构造 public Dog(){ Dog.count++; } //有参构造 public Dog(String name,int health,int love,String sex){ this.setName(name); this.setHealth(health)//this调用本类的构造方法 this（） this.setLove(love);
//this.showOf(); this调用方法
//注意:this调用其他构造方法必须写到构造方法的第一句。
this.setSex(sex); Dog.count++; } public void showOf(){ System.out.print("我的名字叫:"+this.name+" "); System.out.print("健康值:"+this.health+" "); System.out.print("亲密度:"+this.love+" "); System.out.print("性别:"+this.sex+" "); System.out.println("我是第"+Dog.count+"只狗"); }
public class Pet { public static void main(String [] ages){ Dog dog1=new Dog("黑狗",50,50,""); dog1.showOf(); Dog dog2=new Dog("",60,20,"雌"); dog2.showOf(); Dog dog3=new Dog("黑狗",-10,50,"雄"); dog3.showOf(); } }
1.1 静态常量
在程序运行过程中，如果一个量的值不会发生改变，可以把该量声明为静态常量，用static final修饰。
public class Dog { private String name; //private 私有的，对外不可见 private int health; private int love; private String sex; /*静态常量一般用于狗的数量过多，而性别就这么两个，为了方便更改而设立 假如我想把狗的性别雄改为（旺男），我只需要在静态常量这改，然后怎么总体都会改 不需要一个个的去改，适合版本升级*/ static final String SEX_MALE="雄";//常量名所有字母全部大写，链接单词时必须下划线 static final String SEX_FEMALE="雌"; public void setName(String name){ if(name.equals("")){ System.out.println("姓名不能为空"); }else { this.name=name; } } public String getName(){ return this.name; } public void setHealth(int health){ if (health<0){ System.out.println("健康值不合法"); }else { this.health=health; } } public int getHealth(){ return this.health; } public void setLove(int love){ if (love<0){ System.out.println("亲密度不合法"); } else { this.love=love; } } public int getLove(){ return this.love; } public void setSex(String sex){ this.sex=sex; } public String getSex(){ return this.sex; } //无参构造 public Dog(){ }/*public Dog(String name,int health,int love,String sex){ this.setName(name); this.setHealth(health); this.setLove(love); this.setSex(sex) */ //写法改变 但效果一样 public Dog(String name,String sex){ this.setName(name); this.setSex(sex); } public Dog(String name,int health,int love,String sex){ this(name,sex); //this调取方法 this.setHealth(health); this.setLove(love); } public void showOf(){ System.out.print("我的名字叫:"+this.name+" "); System.out.print("健康值:"+this.health+" "); System.out.print("亲密度:"+this.love+" "); System.out.print("性别:"+this.sex+" "); } }
public class Pet { public static void main(String [] ages){ Dog dog1=new Dog("黑狗",50,50,Dog.SEX_FEMALE);//静态常量的提取必须 类.常量名 dog1.showOf(); Dog dog2=new Dog("白狗",60,20,Dog.SEX_MALE); dog2.showOf(); Dog dog3=new Dog("黑狗",10,50,Dog.SEX_FEMALE); dog3.showOf(); } }