java SE（三）：面向对象②

标签：java name 访问静态面向对象 static public SE String

一、this关键字

1、概念

this关键字代表当前对象

①使用this关键字引用成员变量

②使用this关键字引用成员方法或构造方法。

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

public class Demo{

int name;

public Demo(int name){

this.name = name;

}

}

public class Person {
    String name;
    int age;
    String gender;

    public Person(){

    }
    public Person(String name,int age,String gender){
    this.name = name;
    this.age = age;
    this.gender = gender;
    }
    public void showInfo(){
        System.out.println("姓名:"+name+"年龄:"+age+"性别:"+gender);
        this.work();
    }
    public void work(){
        System.out.println("人工作");
    }

public class TestPerson {
    public static void main(String[] args) {
        Person p1 = new Person();
           p1.name = "kk";
           p1.age = 13;
           p1.gender = "女";
           p1.work();

        Person p2 = new Person("张三",13,"女");
           p2.showInfo();

        Person p3 = new Person("李四",20,"男");
           p3.showInfo();
    }
}

输出结果：

人工作
姓名:张三年龄:13性别:女
人工作
姓名:李四年龄:20性别:男
人工作

二、static关键字

1、概念

①static被称为静态，可以用来修饰类的成员变量,成员方法,代码块,内部类。

②静态成员不依赖于类的实例，被类的所有实例共享，就是说 static 修饰的方法或者变量不需要依赖于对象来进行访问，只要这个类被加载，静态成员就会被加载创建。

特点:

• 随着类的加载而加载

• 优先于对象存在

• 修饰的成员，被所有对象所共享

• 可不创建对象，直接使用类名调用

2、static属性

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

• 静态变量在类被加载时由系统默认初始化。

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

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

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

public class Chinese{

String name ;//姓名

static String country=”中国”;//国家

｝

public class Chinese {
    String name;//中国人每个名字都不一样，需要在每一个对象中都有一个name属性
    static String country = "中国";//中国人国籍都是中国，此时应该用static修饰，静态属性在内存中只有一份，所有对象共享，减少内存占用。
    static int count = 0;

    public Chinese(){
        count = count+1;
    }

    public static void main(String[] args) {
        // 静态成员随着类的加载而加载，只要类加载了，静态成员就可以直接使用了（没有创建对象之前，就可以使用静态成员）
        System.out.println(Chinese.country);

        Chinese c1 = new Chinese();
            c1.name = "赵丽";
            System.out.println(Chinese.country);
        Chinese c2 = new Chinese();
            c2.name = "赵六";
            System.out.println(Chinese.country);
        System.out.println("----------------------------------");
        System.out.println(c1.country);
        System.out.println(c2.country);
        System.out.println(Chinese.count);//建议使用类名访问静态成员
    }
}

输出结果：

中国
----------------------------------
中国
中国
----------------------------------
中国
中国
2

3、static方法

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

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

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

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

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

public class StaticMethodDemo {
    String name;
    static int count = 0;

    public static void test(){
        System.out.println(count);//静态的方法中只能使用静态的成员变量，因为他们都是随着类的加载而加载的
    }
    //一旦方法中使用了非静态的成员变量，那么此方法就不能被定义为静态的
    public void eat(){
        System.out.println(name+"吃饭");
        System.out.println(count);//非静态的方法中可以使用静态的成员变量
    }

    public static void main(String[] args) {
        StaticMethodDemo.test();//静态方法可以直接调用类名使用
    }
}

三、代码块

● 代码块在类中声明，类似一个没有名称的方法体(代码块)，代码分实例块和静态块

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

{

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

}

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

static {

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

}

public class Demo {
    static int a = 0;
    {
        System.out.println("我是实例代码块，在创建对象时，不需要显式的调用，我会自动执行1");
    }
    {
        System.out.println("我是实例代码块，在创建对象时，不需要显式的调用，我会自动执行2");
    }
    static{
        System.out.println("我是静态代码块，在类被加载时，会自动执行");
    }
//运行类中的main方法时，类会被加载，会输出静态代码块
    public static void main(String[] args) {

    }//输出：静态代码块
}

public class TestDemo {
    public static void main(String[] args) {
        //创建类的对象，类会被加载，会输出静态代码块
        new Demo();
        new Demo();
        //访问类中的静成员变量，静成员方法，类会被加载，会输出静态代码块
        System.out.println(Demo.a);
        System.out.println(Demo.a);
    }
}

输出结果：

我是静态代码块，在类被加载时，会自动执行
我是实例代码块，在创建对象时，不需要显式的调用，我会自动执行1
我是实例代码块，在创建对象时，不需要显式的调用，我会自动执行2
我是实例代码块，在创建对象时，不需要显式的调用，我会自动执行1
我是实例代码块，在创建对象时，不需要显式的调用，我会自动执行2
0
0

注意！！!

静态块在类被加载时，自动执行

类什么时候会被加载：

//运行类中的main方法时，类会被加载，会输出静态代码块

//创建类的对象，类会被加载，会输出静态代码块

//访问类中的静成员变量，静成员方法，类会被加载，会输出静态代码块

四、包

● 问题

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

●解决问题

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

注意：

● 使用package关键字修饰包

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

包的作用：按照不同功能管理类

避免类重名

控制访问权限, 在不同的包中,对不同权限的成员进行访问限制

● 包（package）的命名规范

①在包名中，可以使用.号来区分包的级别；

②包名一般情况下是小写，包目前至少3级

第一级项目类型 com org gov edu

第二级公司名字 baidu sun huawei

第三级项目名字 oa cms erp

第四级功能模块 web service dao config

● 类的调用

导入外部包的类：

关键字“import” 当在一个类中使用其他包中的类时,需要先使用import关键字导入进来

不需要导入的类：

特殊：

①只有java.lang包中的类比较特殊,使用时不需要导入.

②或者访问同一个包中的类时不需要导入

在这就比如：Person和TestCar都属于包com.ffyc.javaoop.day2中的类，故不需要导入就可以使用

package com.ffyc.javaoop.day2;
//当在一个类中使用了另一个包中的类，使用前必须使用import关键字导入
import com.ffyc.javaoop.day2.demo2.Car;
//java中每一个类都会属于一个包，所以使用时是通过类的全地址使用的
//全类名：com.ffyc.javaoop.day2.demo2.Car
public class TestCar {
    public static void main(String[] args) {
        new Car();
        new com.ffyc.javaoop.day2.demo1.Car();//需用到两个同名的类，必须一个导入全类名，另一个用全类名来表示
        String s = "";//使用java.lang包中的类不需要导入
        new Person();//使用同一个包中的类不需要导入
    }
}

五、访问权限修饰符

访问权限修饰可以修饰类,成员变量,成员方法, 内部类.

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

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

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

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

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

访问权限修饰的目的：

访问权限修饰类,成员变量,成员方法等,就是为了控制在其他地方是否可以使用类中的某些成员

（同类）

package com.ffyc.javaoop.day2.demo1;

public class Animal {
     public String pubname;//公共权限修饰的成员，在任何地方都可以访问到（本类中，同一个包中的其它类中，不同包中的其它类，其他包的子类）
     protected String proname;//受保护权限，在其他包中的类中不能访问，在本类中或同一个包中的其它类中可以访问,还可以在其他包的子类中访问到
               String name;//默认权限，在其他包中的类中不能访问，在本类中或同一个包中的其它类中可以访问
     private String priname;//私有权限，只能在本类中访问到
     public void pubtest(){
       //公共权限修饰的方法，在任何地方都可以访问到（本类中，同一个包中的其它类中，不同包中的其它类）
     }

     public static void main(String[] args) {
          Animal animal = new Animal();
          animal.pubname = "";
          animal.pubtest();
          animal.proname = "";
          animal.name  = "";
          animal.priname = "";
     }
}

（同包）在上面package com.ffyc.javaoop.day2.demo1包中的其他类中：

package com.ffyc.javaoop.day2.demo1;

public class TestAnimal {
    public static void main(String[] args) {
        Animal animal = new Animal();
            animal.pubname = "";
            animal.pubtest();
            animal.proname = "";
            animal.name  = "";
           // animal.priname

    }
}

（不同包的其它类）在其他包的其它类中：

package com.ffyc.javaoop.day2.demo2;

import com.ffyc.javaoop.day2.demo1.Animal;

public class TestAnimalOut {
    public static void main(String[] args) {
        Animal animal = new Animal();
            animal.pubname = "";
            animal.pubtest();
           // animal.proname = "";
           //animal.name  = "";
    }
}

（不同包的子类）区分受保护权限和默认权限：

package com.ffyc.javaoop.day2.demo2;

import com.ffyc.javaoop.day2.demo1.Animal;

public class Dog extends Animal {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.pubname = "";
        dog.proname = "";//受保护权限可以在不同包的子类中访问到
    }

}

六、面向对象特征--封装

面向对象语言的三大特征：

封装继承多态

● 封装的概念

一般意义的封装：例如将重复出现的代码抽取了一个函数, 称为代码的封装(包装)

面向对象语言中的封装:将类中的某些信息,使用不同的访问权限修饰符隐藏起来,不让外界直接访问操作，而是通过类中向外提供的特定的方法去访问操作. 方便加入控制语句,主动权就在我们类自己手中

● 封装的好处

①隐藏类的信息

②通过特定的方法访问

③方便加入控制语句

④方便修改实现

● 具体表现

使用不同的访问权限

public class Demo{

private String name; //将类的成员变量访问权限设置为私有

public void setName(String name){

this.name = name;

}

public String getName (){

return name;

}

}

public class Person {
    private String name;
    private int age;

    public void setName(String name){
        if(name.length()>2&&name.length()<6){
            this.name = name;
        }
    }
    public String getName(){
        return this.name;
    }

    public void setAge(int age){
        if(age>=0&&age<=200){
            this.age = age;
        }
    }
    public int getAge(){
        return this.age;
    }
}

public class TestPerson {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.setName("周壮壮");
        p1.setAge(28);
        System.out.println(p1.getName());
        System.out.println(p1.getAge());
    }
}

输出结果：

周壮壮
28

标签：java,name,访问,静态,面向对象,static,public,SE,String
From： https://blog.csdn.net/m0_70830675/article/details/136963710

java SE（三）：面向对象②

一、this关键字

1、概念

二、static关键字

1、概念

2、static属性

3、static方法

三、代码块

四、包

● 问题

●解决问题

● 包（package）的命名规范

● 类的调用

五、访问权限修饰符

六、面向对象特征--封装

● 封装的概念

● 封装的好处

● 具体表现

相关文章

赞助商

阅读排行