java 对象能跨类吗,java

构造器

特殊的方法：构造器(构造方法)

1.这个方法名字 -- 必须和类名完全一样

2.没有返回值，连void也写

3.不能用static修饰

public class MethodDemo1 {

public MethodDemo1() { //无参

System.out.println(123);

}

public MethodDemo1(int i) { //有参

}

public static void main(String[] args) {

Random r = new Random();

}

}

全局变量

局部变量使用前必须赋值

全局变量有默认值

public class ClassDemo3Test {

public static void main(String[] args) {

String str;

// System.out.println(str);

ClassDemo3 cd = new ClassDemo3();

System.out.println(cd.name);

cd.name = "李四";

System.out.println(cd.name);

// 整型0，浮点型0.0，布尔false,字符型\u0000,引用数据类型null

cd.show();

System.out.println(cd.age);

ClassDemo3 cd1 = new ClassDemo3();

cd1.name = "王五";

cd1.show();

}

}

就近原则

找其最近的变量

public class ClassDemo4 {

String name;

// 就近原则

public void show(String name) {

System.out.println(name);

}

public void test() {

show("赵六");

System.out.println(name);

}

}

对相类数组

public class ClassDemo6 {

public static void main(String[] args) {

int num = 10;

int arr[] = {num};

Student s1 = new Student("zhangsan","man",22);

Student s2 = new Student("lishi","woman",32);

Student s3 = new Student("wanghu","man",66);

Student s[] = {s1,s2,s3};

遍历这个数组，打印出所有学员的详细信息

// for(int i = 0;i < s.length;i++) {

// Student stu = s[i];

// System.out.println(stu.name);

// }

for(Student stu : s) {

System.out.println(stu.name+","+stu.gender+","+stu.age);

}

}

}

匿名对象

匿名对象 : 没有引用指向的对象，它只能使用一次

public class Demo1 {

public void test1() {

System.out.println(123);

}

public void test2() {

System.out.println(456);

}

public static void main(String[] args) {

// Demo1 d = new Demo1();

// d.test1();

// d.test2();

new Demo1().test1();//匿名

new Demo1().test2();//匿名

}

}

垃圾自动回收机制(GC)

JVM会把堆中没有引用指向的对象视为垃圾对象，当这个对象执行完对应的工作，JVM虚拟机

会自动找到这些垃圾对象调用其finalize()回收内存

this关键字

this : 代表当前类对象

①this.属性名，this.方法()

②this() : 只能用在构造器中，调用其他构造器，在一个构造器中只能用一次，并且必须在第一行使用

public class Demo3 {

String name = "张三";

public Demo3() {

this("李四");

System.out.println(1);

}

public Demo3(String name) {

this.name=name;

System.out.println(123);

}

// public void show() {

// String name = "李四";

// System.out.println(name);

// System.out.println(this.name);

// test();

// }

// public void test() {

// System.out.println(123);

// }

public static void main(String[] args) {

Demo3 d = new Demo3();

d.name = "1";

Demo3 d1 = new Demo3();

d1.name = "1";

System.out.println(d.name);

}

}

封装(四个访问权限修饰符)

Java面相对象特性：继承，封装，多态，抽象

抽象(程序员将现实实物抽象为脑中概念模型)

封装 ：将一套功能组织成一个方法，将一套方法加一套属性组织到一个类，将一套类组织到一个包中

访问权限修饰符

/*

public : 公有，工程中可见

能修饰类，方法，属性(全局变量)

protected : 受保护的,当前包可见，跨包的“亲戚”可见，“非亲戚”不可见

能修饰方法和属性

【friendly,default】:默认的，跨包不可见

能修饰类，方法，属性(全局变量)

private : 私有的，只有当前类可见

能修饰方法和属性

*/

JavaBean(实体类) :

1.有无参构造器(必要)

2.属性全部私有

3.有公有的get(获取)和set(修改)方法

public class Student {

private String name;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

//单例模式：

保证一个类只能有一个实例(一个类只能创建一个对象)

/*

* 1.：如何解决多例(不能让其他类随意使用构造器)

* 构造器私有

private Singletion() {}

* 2.：如何解决提供一个实例

* 在当前位置创建一个实例

static Singletion singletion = new Singletion();

* 3.:不能随意修改

* 将创建的实例也私有

private static Singletion singletion = new Singletion();

* 4.:如何获取这个实例

* 提供一个public的方法将这个实例反出去

* */

懒汉模式(懒加载)，调用的时候就创建，不调用就不创建

private static Singletion singletion;

public static Singletion getSingletion() {

if(singletion == null) {

singletion=new Singletion();

}

return singletion;

}

饿汉模式

private static Singletion singletion = new Singletion();

public static Singletion getSingletion() {

return singletion;

}

生成一副扑克牌

public class Poker {

String suit;// 花色

String count;// 点数

public void giveMe() {

String hs[] = {"红桃","黑桃","方片","草花"};

String ds[] = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};

// 写一个循环，生成一副扑克

Poker pokers[] = new Poker[52];

int index = 0;

// 遍历数组，取到hs[]和ds[]的所有组合，给Poker对象赋值，然后存入pokers[]

for(int i = 0;i < hs.length;i++) {

for(int j = 0;j < ds.length;j++) {

pokers[index] = new Poker();

pokers[index].suit = hs[i];

pokers[index].count = ds[j];

index++;

}

}

for(Poker p : pokers) {

System.out.print(p.suit+p.count+" ");

System.out.println();

}

}

public static void main(String[] args) {

Poker p = new Poker();

p.giveMe();

}

}

控制台模拟植物大战僵尸

僵尸类：

public class Zoombie {

int hp = 500;

int dps = 30;

/**

* 攻击

* @param sf 向日葵对象

*/

public void attack(SunFlower sf) {

if(hp <= 0) {

System.out.println("对不起，僵尸没血，无法攻击");

}

else {

// 判断向日葵是否有血

if(sf.hp <= 0) {

System.out.println("向日葵没有血了，严禁鞭尸");

}

// 僵尸有hp，对方也有

else {

System.out.println("僵尸对向日葵造成了 "+dps+" 点伤害");

// 对方掉血

sf.hp = sf.hp - dps;

// 如果是负数，归0

if(sf.hp <= 0) {

sf.hp = 0;

System.out.println("向日葵已经死亡");

return;

}

System.out.println("向日葵还剩 "+sf.hp+" 点血量");

}

}

}

public void attack(BeanHunter bh) {

if(hp <= 0) {

System.out.println("对不起，僵尸没血，无法攻击");

}

else {

// 判断向日葵是否有血

if(bh.hp <= 0) {

System.out.println("豌豆射手没有血了，严禁鞭尸");

}

// 僵尸有hp，对方也有

else {

System.out.println("僵尸对豌豆射手造成了 "+dps+" 点伤害");

// 对方掉血

bh.hp = bh.hp - dps;

// 如果是负数，归0

if(bh.hp < 0) {

bh.hp = 0;

}

System.out.println("豌豆射手还剩 "+bh.hp+" 点血量");

}

}

}

}

向日葵类：

public class SunFlower {

int hp = 300;

/**

* 回血方法

*/

public void addBuff() {

hp = hp + 20;

if(hp > 300) {

hp = 300;

}

System.out.println("向日葵进行了光合作用，回复了20点血，目前血量 "+hp);

}

}

豌豆射手

public class BeanHunter {

int hp = 200;

int dps = 60;

public void attack(Zoombie z) {

if(hp <= 0) {

System.out.println("对不起，豌豆射手没血，无法攻击");

}

else {

if(z.hp <= 0) {

System.out.println("僵尸没有血了，严禁鞭尸");

}

else {

System.out.println("豌豆射手对僵尸造成了 "+dps+" 点伤害");

// 对方掉血

z.hp = z.hp - dps;

// 如果是负数，归0

if(z.hp < 0) {

z.hp = 0;

System.out.println("僵尸GG了");

return;

}

System.out.println("僵尸还剩 "+z.hp+" 点血量");

}

}

}

}

测试类：

public class Test {

public static void main(String[] args) {

Zoombie z = new Zoombie();

SunFlower sf = new SunFlower();

BeanHunter bh = new BeanHunter();

while(true) {

if(z.hp <= 0) {

System.out.println("植物胜利");

break;

}

if(sf.hp <= 0 && bh.hp <= 0) {

System.out.println("僵尸胜利");

break;

}

// 互相伤害

// 生成随机数

double random = Math.random();// [0,1)

if(random <= 0.3) {

z.attack(sf);

}else if(random <= 0.5) {

z.attack(bh);

}else if(random <= 0.8) {

bh.attack(z);

}else {

sf.addBuff();

}

try {

Thread.sleep(1000);// 休眠1000毫秒，即1秒

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

java 对象能跨类吗,java

构造器

特殊的方法：构造器(构造方法)

1.这个方法名字 -- 必须和类名完全一样

2.没有返回值，连void也写

3.不能用static修饰

public class MethodDemo1 {

public MethodDemo1() { //无参

System.out.println(123);

}

public MethodDemo1(int i) { //有参

}

public static void main(String[] args) {

Random r = new Random();

}

}

全局变量

局部变量使用前必须赋值

全局变量有默认值

public class ClassDemo3Test {

public static void main(String[] args) {

String str;

// System.out.println(str);

ClassDemo3 cd = new ClassDemo3();

System.out.println(cd.name);

cd.name = "李四";

System.out.println(cd.name);

// 整型0，浮点型0.0，布尔false,字符型\u0000,引用数据类型null

cd.show();

System.out.println(cd.age);

ClassDemo3 cd1 = new ClassDemo3();

cd1.name = "王五";

cd1.show();

}

}

就近原则

找其最近的变量

public class ClassDemo4 {

String name;

// 就近原则

public void show(String name) {

System.out.println(name);

}

public void test() {

show("赵六");

System.out.println(name);

}

}

对相类数组

public class ClassDemo6 {

public static void main(String[] args) {

int num = 10;

int arr[] = {num};

Student s1 = new Student("zhangsan","man",22);

Student s2 = new Student("lishi","woman",32);

Student s3 = new Student("wanghu","man",66);

Student s[] = {s1,s2,s3};

遍历这个数组，打印出所有学员的详细信息

// for(int i = 0;i < s.length;i++) {

// Student stu = s[i];

// System.out.println(stu.name);

// }

for(Student stu : s) {

System.out.println(stu.name+","+stu.gender+","+stu.age);

}

}

}

匿名对象

匿名对象 : 没有引用指向的对象，它只能使用一次

public class Demo1 {

public void test1() {

System.out.println(123);

}

public void test2() {

System.out.println(456);

}

public static void main(String[] args) {

// Demo1 d = new Demo1();

// d.test1();

// d.test2();

new Demo1().test1();//匿名

new Demo1().test2();//匿名

}

}

垃圾自动回收机制(GC)

JVM会把堆中没有引用指向的对象视为垃圾对象，当这个对象执行完对应的工作，JVM虚拟机

会自动找到这些垃圾对象调用其finalize()回收内存

this关键字

this : 代表当前类对象

①this.属性名，this.方法()

②this() : 只能用在构造器中，调用其他构造器，在一个构造器中只能用一次，并且必须在第一行使用

public class Demo3 {

String name = "张三";

public Demo3() {

this("李四");

System.out.println(1);

}

public Demo3(String name) {

this.name=name;

System.out.println(123);

}

// public void show() {

// String name = "李四";

// System.out.println(name);

// System.out.println(this.name);

// test();

// }

// public void test() {

// System.out.println(123);

// }

public static void main(String[] args) {

Demo3 d = new Demo3();

d.name = "1";

Demo3 d1 = new Demo3();

d1.name = "1";

System.out.println(d.name);

}

}

封装(四个访问权限修饰符)

Java面相对象特性：继承，封装，多态，抽象

抽象(程序员将现实实物抽象为脑中概念模型)

封装 ：将一套功能组织成一个方法，将一套方法加一套属性组织到一个类，将一套类组织到一个包中

访问权限修饰符

/*

public : 公有，工程中可见

能修饰类，方法，属性(全局变量)

protected : 受保护的,当前包可见，跨包的“亲戚”可见，“非亲戚”不可见

能修饰方法和属性

【friendly,default】:默认的，跨包不可见

能修饰类，方法，属性(全局变量)

private : 私有的，只有当前类可见

能修饰方法和属性

*/

JavaBean(实体类) :

1.有无参构造器(必要)

2.属性全部私有

3.有公有的get(获取)和set(修改)方法

public class Student {

private String name;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

//单例模式：

保证一个类只能有一个实例(一个类只能创建一个对象)

/*

* 1.：如何解决多例(不能让其他类随意使用构造器)

* 构造器私有

private Singletion() {}

* 2.：如何解决提供一个实例

* 在当前位置创建一个实例

static Singletion singletion = new Singletion();

* 3.:不能随意修改

* 将创建的实例也私有

private static Singletion singletion = new Singletion();

* 4.:如何获取这个实例

* 提供一个public的方法将这个实例反出去

* */

懒汉模式(懒加载)，调用的时候就创建，不调用就不创建

private static Singletion singletion;

public static Singletion getSingletion() {

if(singletion == null) {

singletion=new Singletion();

}

return singletion;

}

饿汉模式

private static Singletion singletion = new Singletion();

public static Singletion getSingletion() {

return singletion;

}

生成一副扑克牌

public class Poker {

String suit;// 花色

String count;// 点数

public void giveMe() {

String hs[] = {"红桃","黑桃","方片","草花"};

String ds[] = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};

// 写一个循环，生成一副扑克

Poker pokers[] = new Poker[52];

int index = 0;

// 遍历数组，取到hs[]和ds[]的所有组合，给Poker对象赋值，然后存入pokers[]

for(int i = 0;i < hs.length;i++) {

for(int j = 0;j < ds.length;j++) {

pokers[index] = new Poker();

pokers[index].suit = hs[i];

pokers[index].count = ds[j];

index++;

}

}

for(Poker p : pokers) {

System.out.print(p.suit+p.count+" ");

System.out.println();

}

}

public static void main(String[] args) {

Poker p = new Poker();

p.giveMe();

}

}

控制台模拟植物大战僵尸

僵尸类：

public class Zoombie {

int hp = 500;

int dps = 30;

/**

* 攻击

* @param sf 向日葵对象

*/

public void attack(SunFlower sf) {

if(hp <= 0) {

System.out.println("对不起，僵尸没血，无法攻击");

}

else {

// 判断向日葵是否有血

if(sf.hp <= 0) {

System.out.println("向日葵没有血了，严禁鞭尸");

}

// 僵尸有hp，对方也有

else {

System.out.println("僵尸对向日葵造成了 "+dps+" 点伤害");

// 对方掉血

sf.hp = sf.hp - dps;

// 如果是负数，归0

if(sf.hp <= 0) {

sf.hp = 0;

System.out.println("向日葵已经死亡");

return;

}

System.out.println("向日葵还剩 "+sf.hp+" 点血量");

}

}

}

public void attack(BeanHunter bh) {

if(hp <= 0) {

System.out.println("对不起，僵尸没血，无法攻击");

}

else {

// 判断向日葵是否有血

if(bh.hp <= 0) {

System.out.println("豌豆射手没有血了，严禁鞭尸");

}

// 僵尸有hp，对方也有

else {

System.out.println("僵尸对豌豆射手造成了 "+dps+" 点伤害");

// 对方掉血

bh.hp = bh.hp - dps;

// 如果是负数，归0

if(bh.hp < 0) {

bh.hp = 0;

}

System.out.println("豌豆射手还剩 "+bh.hp+" 点血量");

}

}

}

}

向日葵类：

public class SunFlower {

int hp = 300;

/**

* 回血方法

*/

public void addBuff() {

hp = hp + 20;

if(hp > 300) {

hp = 300;

}

System.out.println("向日葵进行了光合作用，回复了20点血，目前血量 "+hp);

}

}

豌豆射手

public class BeanHunter {

int hp = 200;

int dps = 60;

public void attack(Zoombie z) {

if(hp <= 0) {

System.out.println("对不起，豌豆射手没血，无法攻击");

}

else {

if(z.hp <= 0) {

System.out.println("僵尸没有血了，严禁鞭尸");

}

else {

System.out.println("豌豆射手对僵尸造成了 "+dps+" 点伤害");

// 对方掉血

z.hp = z.hp - dps;

// 如果是负数，归0

if(z.hp < 0) {

z.hp = 0;

System.out.println("僵尸GG了");

return;

}

System.out.println("僵尸还剩 "+z.hp+" 点血量");

}

}

}

}

测试类：

public class Test {

public static void main(String[] args) {

Zoombie z = new Zoombie();

SunFlower sf = new SunFlower();

BeanHunter bh = new BeanHunter();

while(true) {

if(z.hp <= 0) {

System.out.println("植物胜利");

break;

}

if(sf.hp <= 0 && bh.hp <= 0) {

System.out.println("僵尸胜利");

break;

}

// 互相伤害

// 生成随机数

double random = Math.random();// [0,1)

if(random <= 0.3) {

z.attack(sf);

}else if(random <= 0.5) {

z.attack(bh);

}else if(random <= 0.8) {

bh.attack(z);

}else {

sf.addBuff();

}

try {

Thread.sleep(1000);// 休眠1000毫秒，即1秒

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}