//大家可以关注一下我的博客 我的博客所有随笔都是我从基础开始学习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=; //属性
int love=;
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==){
Penguin sc=new Penguin(); //插入Penguin包
sc.name=name; //赋值（从输入录入的值） System.out.println("请选择性别1.Q女2.Q男");
int b=arr.nextInt();
if (b==) {
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==){
sc.sex="雄性";
sc.showOf();
}else {
sc.sex="雌性";
sc.showOf();
}
}
}
}
4种结果
有参构造
/*构造方法是一种特殊的方法，专门用于构造/实例化对象，
形式:[修饰符] 类名(){ }
构造方法根据是否有参数分为无参构造和有参构造*/
public class Dog {
String name;
int health=;
int love=;
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=;
/*静态变量归类所有，也叫类变量，访问方式
[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("黑狗",,,"雄");
dog1.showOf();
Dog dog2=new Dog("白狗",,,"雌");
dog2.showOf();
Dog dog3=new Dog("黑狗",,,"雄");
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+"\t");
System.out.print("健康值:"+this.health+"\t");
System.out.print("亲密度:"+this.love+"\t");
System.out.print("性别:"+this.sex+"\t");
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+"\t");
System.out.print("健康值:"+this.health+"\t");
System.out.print("亲密度:"+this.love+"\t");
System.out.print("性别:"+this.sex+"\t");
}
}
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();
}
}