Java面向对象（2）

1.this关键字

在一个类的方法或构造方法内部，可以使用“this.成员变量名”这样的格式来引用成员变量名，常常用来区分同名的成员变量和局部变量。

package person;

public class person {
    String name;
    int age;
    float hight;

    public person(){

    }
    //this在类中用来表示当前正在访问的对象，this.成员变量名--显示的访问当前对象的成员变量
    public person(String name,int age,float hight){
             this.name=name;
             this.age=age;
             this.hight=hight;
    }
public void show(){
    System.out.println("名字："+this.name+"  年龄："+this.age+"  身高："+this.hight);
        this.work();
}
public void  work(){
    System.out.println("在工作");
}
}

测试代码

package person;

public class persontest {
    public static void main(String[] args) {
        person p1=new person();
        p1.name="zhu";
        p1.age=18;
        p1.hight=160;
        p1.show();
        person p2=new person("wan",19,178);
        p2.show();;
    }
}

 

 

2.static关键字

● static属性 静态属性是类的所有对象共享的，即不管创建了多少个对象，静态属性在内存中 只有一个。

• 静态变量的默认值规则和实例变量一样。

• 静态变量值是所有对象共享。

• 静态变量在本类中，可以在任意方法、代码块、构造器中直接使用。

• 可以通过类名.静态变量直接访问，也可以通过对象.静态变量的方式访问（但 是更推荐使用类名.静态变量的方式）。

package oop02;

public class game {
    String name;
    int price;
    static  int count =0;
     static  String midposition="中路";
     public game(){
         count=count+1;
     }
     public game(String name,int price){
         this.name=name;
         this.price=price;
     }

     public void work(){
         System.out.println("吃兵线");
     }
     public void show(){
         System.out.println("英雄："+this.name+" 价格："+this.price);
     }
}

package oop02;

public class gametest {
    public static void main(String[] args) {
        game player1=new game();
            player1.name="小乔";
            player1.price=13888;

        player1.show();
        System.out.println(game.midposition);
        player1.work();
            game player2=new game();
        player2.name="周瑜";
        player2.price=13888;
player2.show();
        System.out.println(game.midposition);
        System.out.println(game.count+"名玩家");
    }
}

 ● 用static修饰的成员方法就是静态方法。

● 静态方法在本类的任意方法、代码块、构造器中都可以直接被调用。

● 静态方法在其他类中可以通过类名.静态方法的方式调用。也可以通过对 象.静态方法的方式调用（但是更推荐使用类名.静态方法的方式）。

● 在static方法内部只能访问类的static修饰的属性或方法，不能访问类的 非static的成员。  

● 因为不需要实例就可以访问static方法，因此static方法内部不能有this， 也不能有super。

package oop02;

public class MyMath {
    public static int Max(int a,int b){

        return (a>b)?a:b;
    }

    public static void main(String[] args) {
        int max=MyMath.Max(12,8);
        System.out.println(max);
    }
}

package oop02;

public class statictestdemo {
    String name;
   static int count;
   public static void test(){
       System.out.println(count);
   }
   public static void test2(){
       System.out.println(name);//静态方法中只能用静态成员变量
   }
}

 

3. 代码块

● 代码块在类中声明，类似一个没有名称的方法体(代码块)，

代码分实例块和静态块

实例块：每次创建对象时自动调用

{ //任何符合语法的Java代码 }

静态块：类加载时自动调用，仅一次，与是否创建对象无关。

static { //任何符合语法的Java代码 }

package oop02;

public class demotest {
    static int a=10;
    {
        System.out.println("我是实例代码块，在创建对象时，不需要显式调用，我会自动执行1");
    }
    {
        System.out.println("我是实例代码块，在创建对象时，不需要显式调用，我会自动执行2");
    }
    static {
        System.out.println("我是静态代码块，在类加载时，会自动执行");
    }

    public static void main(String[] args) {

    }
}

package oop02;

public class testdemotest {
    public static void main(String[] args) {
       new demotest();
        new demotest();
        System.out.println(demotest.a);
    }
}

4.包

● 在编写 Java 程序时，随着程序架构越来越大，类的个数也越来越多，这时就会 发现管理程序中维护类名称也是一件很麻烦的事，尤其是一些同名问题的发生。 有时，开发人员还可能需要将处理同一方面的问题的类放在同一个目录下，以 便于管理。

● 为了解决上述问题，Java 引入了包（package）机制，提供了类的多层命名空 间，用于解决类的命名冲突、类文件管理等问题。

● 使用package关键字修饰包

● 每个类属于一个特定的包,所以java中一个类的完整名称等于包名+类名

● 包的作用： 按照不同功能管理类 避免类重名 控制访问权限

● 包（package）的命名规范： 在包名中，可以使用.号来区分包的级别；包名一般情况下是小写 第一级 指该项目的类型，如com,org,gov等， 第二级 指项目所开发或者运行的公司名称，如：oracle,sun,huawei等 第三级 指项目的名称，如：bcms,oa,erp,cms等 第四级 指项目模块的名称，如：bean,action,exception等

● 导入外部包的类，关键字“import” 当在一个类中使用其他包中的类时,需要先使用import关键字导入进来. 只有java.lang包中的类比较特殊,使用时不需要导入.

5.访问权限修饰符

●访问权限修饰符 public protected (default) private

● Java语言有四个权限访问修饰符，权限从大到小依次为：

1）public ：公共权限 修饰类、属性、方法。可以在任意类中访问

2）protected：受保护的权限 修饰属性、方法。可以在同包类访问，如果 不是同包类，必须是该类的子类才可以访问。

3）default：同包权限 修饰类、属性、方法。只能在同包的类访问

4）private：私有权限 修饰属性、方法。 只能在本类中访问

package com.ffyc.javaopp.day2.limitdemo1; 
public class Person {
 
    public int pubnum;//公共权限，在任何地方都可以访问
    protected  int pronum;//受保护权限，只能在本类，同包的其他类中使用，不同包的子类
               int defnum;//默认权限，只能在本类，同包的其他类中使用
    private int prinum;//私有权限，只能在本类中使用
 
    public void test(){
 
    }
 
    public static void main(String[] args) {
        Person p = new Person();
        System.out.println(p.pubnum);
        System.out.println(p.pronum);
        System.out.println(p.defnum);
        System.out.println(p.prinum);//私有权限在本类中都可以访问
    }
}

 

package com.ffyc.javaopp.day2.limitdemo1;
 
import com.ffyc.javaopp.day2.limitdemo1.Person;
 
public class TestPerson {
    public static void main(String[] args) {
        Person p = new Person();
        System.out.println(p.pubnum);
        System.out.println(p.pronum);
        System.out.println(p.defnum);
        //System.out.println(p.prinum);
    }
}