一? 类的结构
面向对象思想实现的规则
- 创建类，设计类的成员
- 创建类的对象
- 通过对象.属性 或 对象.方法调用对象的结构
?
对象的创建与对象的内存解析
Person p1 = new Person();Person p2 = new Person();Person p3 = p1;//没有新创建一个对象，共用一个堆空间中的对象实体。/*说明：*如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）*意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。*/
?
匿名对象:
我们创建的对象，没显式的赋给一个变量名。即为匿名对象
特点：匿名对象只能调用一次
?
new Phone().sendEmail();
new Phone().playGame();
new Phone().price = 1999;
new Phone().showPrice();//0.0
?
PhoneMall mall = new PhoneMall();
//匿名对象的使用
mall.show(new Phone());
其中，
class PhoneMall{
public void show(Phone phone){
phone.sendEmail();
phone.playGame();
}
}类的结构之一：属性
- 属性：直接定义在类的一对{}内
- 局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量。
?
?
?
类的结构之二：方法
自定义的方法：
?
public void eat(){
System.out.printly("我要吃饭！！！");
}
public String getNation(String nation){
System.out.printly("当前地点为" + nation);
}方法的声明：
权限修饰符 返回值类型 方法名(形参列表){方法体
}
?
重载的概念
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
// 举例一：Arrays类中重载的sort() / binarySearch()；PrintStream中的println()
// 举例二：
// 如下的4个方法构成了重载
public void getSum(int i,int j){
System.out.println("1");
}
public void getSum(double d1,double d2){
System.out.println("2");
}
public void getSum(String s ,int i){
System.out.println("3");
}
public void getSum(int i,String s){
System.out.println("4");
}内存解析：
内存解析画法要点：
- 内存结构：栈（局部变量）、堆（new出来的结构：对象（非static成员变量）、数组
- 变量：成员变量 vs 局部变量（方法内、方法形参、构造器内、构造器形参、代码块内）
?
方法的重写
什么是方法的重写(override 或 overwrite)？
子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作.
// 父类
class Circle{
public double findArea(){}//求面积
}
// 子类
class Cylinder extends Circle{
public double findArea(){}//求表面积
}
**********************************************
// 父类
class Account{
public boolean withdraw(double amt){}
}
// 子类
class CheckAccount extends Account{
public boolean withdraw(double amt){}
}类的结构之三：构造器
- 如果没显式的定义类的构造器的话，则系统默认提供一个空参的构造器
- 定义构造器的格式：权限修饰符 类名(形参列表){ }
- 一个类中定义的多个构造器，彼此构成重载
- 一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
- 一个类中，至少会有一个构造器。
?
?首先创建一个Weapon类
public class Weapon {
private String code; //武器的代号
public Weapon() {
} //无参构造器
public Weapon(String code) {
this.code = code;
} //有参构造器
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
}
再创建一个Hero类
public class Hero {
private String name; //英雄名字
private int age; //英雄的年龄
private Weapon weapon; //英雄的武器
public Hero() {
}
public Hero(String name, int age, Weapon weapon) {
this.name = name;
this.age = age;
this.weapon = weapon;
}
public void attack() {
System.out.println("年龄为" + age + "的" + name + "用" + weapon.getCode() + "攻击敌方。");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Weapon getWeapon() {
return weapon;
}
public void setWeapon(Weapon weapon) {
this.weapon = weapon;
}
}
最后DemoMain类
public class DemoMain {
public static void main(String[] args) {
//创建一个英雄角色
Hero hero = new Hero();
//为英雄起一个名字
hero.setName("盖伦");
hero.setAge(20);
//创建一个武器对象
Weapon weapon = new Weapon("多兰剑");
hero.setWeapon(weapon);
hero.attack();
//年龄为20的盖伦用多兰剑攻击敌方。
}
}
JAVA中成员变量和局部变量
public class Outer {
int num =10; //外部类的成员变量
public class Inner {
int num = 20;//内部类的成员变量
public void methodInner() {
int num = 30; //内部类方法的局部变量
System.out.println(num); //局部变量,就近原则30
System.out.println(this.num);//内部类成员变量20
System.out.println(Outer.this.num); //外部类的成员变量
}
}
}