面向对象二_foo f1 = new foo(); system.out.println("f1.i is " -CSDN博客

本文链接：https://blog.csdn.net/qiaohonglu/article/details/44263123

1.JavaBean规范

javaBean规范不是语法规范，是习惯性的编程规范，用这个规范些的类使用方便。
简化规范
- 必须有包（package）
- Java类，具有无参构造器
- 有用getXxx()和setXxx声明Bean属性
  - 如果：getName()和setName（String n）声明的Bean属性为：name；
  - boolean类型的get方法可以有两种形式：getMarried() 戒者 isMarried()；

2.static关键字

1) static 修饰的资源属于类级别，是全体对象实例共享的资源

2) 静态属性

n 使用 static 修饰的属性，属于类的全体类的实例共享的变量

n 静态属性是在类的加载期间初始化的

n 使用类名.属性访问，如：System.out

3) 实例变量

n 属于对象的属性

n 使用对象.属性访问，如：person.name

举例：

public class StaticDemo {
public static void main(String[] args) {
 Foo f1 = new Foo();
 Foo f2 = new Foo();
 Foo f3 = new Foo();
 System.out.println(
   f1.id +" " + f2.id + " "
   +f3.id + " " + Foo.i);
}
}
class Foo{
 int id;//实例变量
 static int i = 0;//静态类级别变量
 public Foo(){//构造器
  id = i++;
 }
}

//输出结果：0 1 2 3

注：

ü int id 实例变量

ü static int i=0 静态类级别变量，类的全体实例共同享有的变量。

上述代码程序执行过程的内存图如下：

第一步：加载类

Foo f1 = new Foo();

第二步：在内存堆中分配对象空间。属性默认自己初始化，为“0”值

class Foo{
 int id;//实例变量
 static int i = 0;//静态类级别变量
 public Foo(){//构造器
  id = i++;
 }
}

第三步：进行属性赋值
第四步：递归调用父类构造器
第五步：调用本类构造器

public Foo(){//构造器

第六步

f2、f3同上。输出结果是内存图如下：

3.static方法

使用 static 声明的方法，属于类的方法，一般用来表示工具方法。
在类加载以后就可以自己调用, 不需要创建任何类的实例对象。

案例如下图所示，这些方法都是属于类的方法（静态方法）：

public class StaticMethodDemo { 
 public static void main(String[] args) { 
  //当前时间 
  long now = System.currentTimeMillis(); 
  System.out.println("当前时间："+now); 
  //使用类名访问静态方法 
  int c = myAdd.add(2,3); 
  System.out.println("2+3="+c); 
 } 
} 
class myAdd{ 
 int c = 1;//对象属性，实例变量 
 //静态方法是属于类的方法，是公共工具方法 
 //静态方法不能访问属于对象的资源（对象的属性、对象的方法） 
 public static int add(int a,int b){ 
  return a+b; 
  //return a+b+this.a;//编译错误，使用方法时没有对象 
 } 
} 

}

4.抽象类abstruct calss

抽象方法，只有行为的概念，没有具体的行为实现

1) 使用：abstract 关键字修饰，并没有方法体

2) 包含抽象方法的类，就一定是抽象类

n 使用： abstract 关键字修饰，包含抽象方法

3) 抽象类不能直接创建实例。可以定义引用变量

Shape shape = new Shape() 错

Shape shape = new Circle() 对

4) 抽象类只能被继承，一个具体类继承一个抽象类，必须实现所有抽象方法

5) 抽象方法和抽象类是非常适合作为系统的分析和设计的工具

实例：

Shape抽象类

package Day01;
public abstract class Shape {
 //该抽象类中有2个抽象方法
 //图形可以用来计算面积
 //可以判定是否包含某个坐标
 public abstract double area();
 public abstract boolean contains(int x,int y);
}

Circle具体类

public class Circle extends Shape{
//圆形是具体类，继承图形就要实现图形中的所有抽象方法
//area() contains(x,y)
 private int r;
 public double area(){
  return Math.PI*r*r;
 }
 public boolean contains(int x,int y){
  System.out.println("测试方法");
  return false;
 }
   //circle的构造器
 public Circle(int r){
  this.r=r;
 }
}

测试类

package Day01;
public class ShapeDemo {
   public static void main(String[] args) {
 //Shape s = new Shape();//错误，不能直接创建抽象类的实例
 Shape s = new Circle(3);
 System.out.println(s.area());
}
}

5.接口

接口：全部的方法都是抽象方法，全部的属性都是常量。

1) 接口是特殊的抽象类

2) 接口用来表示纯抽象概念，没有任何具体的方法和属性

3) 接口不能实例化，可以定义变量

Shape s = new Shape(); 错

Shape s = new Circle(); 对

4) 接口变量可以引用具体实现类的实例

5) 接口只能被实现（继承），一个具体类实现接口，必须使用全部的抽象方法

6) 接口之间可以继承（implements）

7) 一个具体类可以实现多个接口，实现多继承现象

表示：一个概念即是 XXX 也是 XXX