Socket网络编程进阶与实战（更新至第九章）2018（最全）

1、
构造方法没有返回类型，类方法有。
2、
类方法 static 所有对象
3、
继承：extends

引用
/*
*如代码，问题:
h4所指向的对象和h2所指向的对象，是否是同一个对象？
*/
package basis;

public class Hero
{
   public String name;
   protected float hp;

   public static void main(String[]args)
   {//创建对象并使用一个“引用”来指向这个对象。
       Hero h1 = new Hero();
       Hero h2 = new Hero();

       Hero h3 = h1;//h3指向h1所指的对象
       Hero h4 = h3;
       //h1,h3,h4 3个引用都指向同一个对象。

       h1.name = "garen";
       h2.name = "teemo";//对象实例化
       System.out.println(h4.name);
       System.out.println(h2.name);
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
继承
extends
在LOL中，武器是物品的一种，也是有名称和价格的
所以在设计类的时候，可以让武器继承物品，从而继承名称和价格属性

/*
*设计一个类Armor护甲
继承Item类，并且额外提供一个属性ac: 护甲等级 int类型

实例化出两件护甲
名称价格护甲等级
布甲 300 15
锁子甲 500 40
*/
package basis;

//在第一个公共类里面写主类，新的类写下面。方法写里面
public class Hero {
   public static void main(String[]args) {
       Armor cloth = new Armor();//类名
       cloth.name = "布甲";
       cloth.price = 300;
       cloth.ac = 15;

       //chain束缚，链条，mail邮寄，mailed 有甲壳的
       Armor chainMail = new Armor();
       chainMail.name = "锁子甲";
       chainMail.price =500;
       chainMail.ac = 40;

       System.out.println(cloth.name + " " +cloth.price + " " + cloth.ac);
       System.out.println(chainMail.name + " " +chainMail.price + " " + chainMail.ac);
   }
}

//把新写的类放在下面
class Item1{
   String name;
   int price;
}
class Armor extends Item1{
   int ac;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
方法重载
方法名是一样的，但是参数类型不一样
在调用方法attack的时候，会根据传递的参数类型以及数量，自动调用对应的

/*
*设计一个类Support (辅助英雄)继承Hero，提供一个heal(治疗)方法
对Support的heal方法进行重载
heal()
heal(Hero h) //为指定的英雄加血
heal(Hero h, int hp) //为指定的英雄加了hp的血
*/
//辅助英雄Support继承Hero
class Support extends Hero{
   //方法重载
   public void heal() {
       System.out.println(name + "被一个不知名是好心人救了");
   }

   public void heal(Hero h1) {
       System.out.println(name + "为" +h1.name +"加血");
   }

   public void heal(Hero h1,int hp) {
       System.out.println(name + "为" +h1.name +"加了" +hp +"的血量");
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
构造方法
通过一个类创建一个对象，这个过程叫做实例化
实例化是通过调用构造方法(又叫做构造器)实现的
构造方法没有返回类型

/*
*为Hero设计4个参数的构造方法
这四个参数分别是
String heroName
float heroHP
float heroArmor
int heroMoveSpeed
*/
package basis;

public class heroTest {
   String name;
   float hp;
   float armor;
   int moveSpeed;
   //构造方法
   //和方法差不多，但是无返回值。
   public heroTest(String heroname,float heroHP,float heroArmor,int heroMoveSpeed) {
       name = heroname;
       hp = heroHP;
       armor = heroArmor;
       moveSpeed = heroMoveSpeed;
   }
   public static void main(String[] args) {
       heroTest garen = new heroTest("盖伦",330,30,100);
       System.out.println(garen.name);
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
类属性(static)
1、当一个属性被static修饰的时候，就叫做类属性，又叫做静态属性
当一个属性被声明成类属性，那么所有的对象，都共享一个值
2、比如盖伦的hp 和提莫的hp 是不一样的。
但是所有对象的类属性的值，都是一样的
3、Hero.copyright;

扫描二维码关注公众号，回复： 4735291 查看本文章

/*
* 通过garen.copyright修改其值
garen.copyright = "Blizzard Entertainment Enterprise";
然后打印teemo.copyright，观察是否有变化
*/
public class heroTest {
   public String name;
   float hp;
   static String copyright;//类属性，静态属性

   public static void main(String[]args) {
       heroTest garen = new heroTest();
       //会有警告说，应该是Hero.copyright
       garen.copyright = "人民文学出版社版权所有";

       heroTest teemo = new heroTest();
       System.out.println(teemo.copyright);
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
类方法
访问一个对象方法，必须建立在有一个对象的前提的基础上
访问类方法，不需要对象的存在，直接就访问
Math.random（）；

Q：什么时候设计对象方法，什么时候设计类方法
name属性是对象属性，只有存在一个具体对象的时候，name才有意义。如果方法里访问了对象属性，那么这个方法，就必须设计为对象方法
功能性

public static void printGameDuration(){
System.out.println("已经玩了10分50秒");
}
1
2
3
package basis;
/*
* 在一个类方法中，直接调用一个对象方法，
比如在battleWin中调用die()
能否直接调用？为什么？
*/

public class Hero {
   public String name;
   //类方法是有返回值的
   public static void battleWin(){
       System.out.println("我赢了！！！");
       //不能直接调用，对象方法要有对象！
       //实例化一个对象，貌似就可以调用了
       Hero garen = new Hero();
       garen.die();
   }

   public void die(){
       System.out.println("我死了。");
   }

   public static void main(String[] args) {
       // TODO Auto-generated method stub
       Hero.battleWin();
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
属性初始化
先后执行：
声明> 块 > 构造函数

package basis;
/*
*对象属性的初始化有三种方式
故意把初始化块，放在构造方法下面，问题：

这三种方式，谁先执行？谁后执行？
*/

public class Hero {
   //1、声明该属性时初始化
   public float hp= 110;
   //2、构造方法中初始化
   public Hero(){
   hp = 220;
   }
   //3、块初始化
   {
   hp = 330;
   }
   public static void main(String[]args){
       Hero garen = new Hero();
       System.out.println(garen.hp);
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
访问修饰符
属性通常使用private封装起来（见private专题）
方法一般使用public用于被调用
会被子类继承的方法，通常使用protected
4.简单说, 能用private就用private，不行就放大一级==，用package,再不行就用protected，最后用public。这样就能把数据尽量的封装起来，没有必要露出来的，就不用露出来了

---------------------
作者：urnotbear
来源：CSDN
原文：https://blog.csdn.net/conan2017/article/details/85094842
版权声明：本文为博主原创文章，转载请附上博文链接！

Socket网络编程进阶与实战（更新至第九章）2018（最全）

猜你喜欢