面向对象第二课

高手敏smart_sheep

已于 2023-03-08 20:25:36 修改

阅读量224

点赞数 1

分类专栏：面向对象文章标签： java jvm 开发语言

于 2022-12-13 00:38:46 首次发布

本文链接：https://blog.csdn.net/W2810741612/article/details/128054671

版权

面向对象专栏收录该内容

3 篇文章 0 订阅

订阅专栏

对象与引用

1.Java中，除基本类型外的变量类型都称之为引用类型；

2.Java中的对象是通过引用对其操作的；

3.以Car bm = new Car();为例：是以Car类为模板，在堆空间里创建一个Car类对象；左边的Car bm创建了一个Car类型的引用变量（以后可以用来指向Car对象的对象引用）“=”操作符使对象引用指向刚创建的那个Car对象；Car bm;bm=new Car;拆成两部分理解，一是对象引用变量，一是对象本身；

解释说明：

值传递与引用传递

值传递

值传递：基本类型作为参数；

public class TestValue {

    public  void test(int x){
           x = 20;//变量x值发生变化,与a没有任何关系
    }

    public static void main(String[] args) {
            TestValue t =  new TestValue();
            int a = 10;
            t.test(a);//传递的是基本类型,可是用a的值实际填充了x, 是两个不相干的变量
        System.out.println(a);//10
    }
}

引用传递

引用传递：本质上也是值传递，只是为了和基本类型区分，称为引用地址传递；

public class TestRef {

    public  void test(Person p){//p  = p1 = （地址） 指向的是同一个对象
           p.name = "李四";
    }

    public static void main(String[] args) {
        TestRef t =  new TestRef();
        Person p1  = new Person(); //p1=（地址）
               p1.name = "张三";
               p1.age = 20;
               t.test(p1);//对于引用类型,只是将对象的引用地址值传递
        System.out.println(p1.name);//李四
    }
}

this关键字

1.this关键字代表当前对象；

2.使用this关键字引用成员变量；

3.使用this关键字引用成员方法；

static关键字

1.static 静态，修饰类的属性，方法，代码块，内部类；

2.随着类的加载而加载；

3.优先于对象存在；

4.修饰的成员，被所有对象所共享；

5.可不创建对象，直接被类调用；

作用：优化内存空间；

修饰成员变量

被static修饰的成员变量，成员方法可以被类调用，属于类，只有一个；

/*
  中国人类
 */
public class Chinese {

     String name ;//姓名  每个人姓名都不一样, 没创建一个对象,对象中就会有一个name属性
    //所有对象都一样的成员变量,可以修饰为static,称为类变量,随着类的加载而加载
     static String country="中国";//国家, 每个对象中也都有一个country,就是一个静态变量(类变量)

  }

修饰成员方法

/*
  中国人类
 */
public class Chinese {

     String name ;//姓名  每个人姓名都不一样, 没创建一个对象,对象中就会有一个name属性
    //所有对象都一样的成员变量,可以修饰为static,称为类变量,随着类的加载而加载
     static String country="中国";//国家, 每个对象中也都有一个country,就是一个静态变量(类变量)

     /*
       static修饰的方法,也被称为类方法,通过类名访问,也是随着类的加载而加载.
       静态方法里面不能访问非静态,因为静态的先加载,非静态的随着对象创建而加载(初始化)
      */
     public static void showCountry(){
         System.out.println("国籍:"+country);
     }

     public void showInfo(){
         System.out.println("姓名"+name+"国籍"+country);
     }


}

public class TestChinese {

    public static void main(String[] args) {

         // Chinese.name; name是非静态的成员变量,属于对象,类不能直接访问,
          //country被static修饰了,所有属于类,内存中只有一份,随着类加载而被加载初始化,建议使用类名访问静态
            System.out.println(Chinese.country);

            Chinese c1 = new Chinese();
            System.out.println(c1.country);

            //c1.country= "中国人";
            Chinese.country = "中国人";
            Chinese c2 = new Chinese();
            System.out.println(c2.country);
            c2.name = "jim";
            c2.showInfo();



          //Chinese c3 = new  Chinese();
            //      c3.showCountry();

             Chinese.showCountry();

    }
}

静态的不能访问非静态的，非静态的可以访问非静态的；

代码块

代码块分为两种，在类中定义的代码块，没有名字；

实例代码块

没有被static修饰的代码块，在创建对象时会自动调用；

静态代码块

在类被加载时只调用一次；（默认认为一个类只被加载一次，一旦第一次加载后，就永远存在）

调用

满足条件后，自动调用；

public class Demo {

        /*
            代码块：两种，在类中定义的代码块，没有名字；
            实例代码块：没有被static修饰的代码块，在创建对象时会自动调用；
            静态代码块：在类被加载时只调用一次；（默认认为一个类只被加载一次，一旦第一次加载后，就永远存在）
            调用：满足条件后，自动调用；
         */
        {
            System.out.println("实例代码块1");
        }
        {
            System.out.println("实例代码块2");
        }
        static{
            System.out.println("静态代码块1");
        }
        static{
            System.out.println("静态代码块2");
        }
        public Demo(){
            System.out.println("无参构造");
            //实例代码块先于构造方法执行；
        }
        public static void test(){

        }

    public static void main(String[] args) {
//若把main方法写在Demo类里，静态代码块也会执行，因为Demo类被加载了；
    }
}

注：实例代码块先于构造方法执行；

若把main方法写在Demo类里，静态代码块也会执行，因为Demo类被加载了；

public class TextDemo {
    public static void main(String[] args) {
        //类只被加载一次，问：什么时候会发生加载动作；创建对象的时候；调用类中的静态成员；
  //      Demo.test();//静态代码块执行，未创建对象，实例代码块不执行；
        new Demo();//创建Demo类对象，先加载Demo类(加载静态成员),静态的先执行
//        new Demo();//静态代码块执行一次，实例代码块执行两次；
    }
}

类的加载与执行

类只被加载一次，什么时候会发生加载动作：创建对象的时候；调用类中的静态成员；

包

概念

为了更好的组织包装，Java提供了包机制，用于区别类名的命名空间,可以理解为一个文件夹；

类名 Car（简称）

类名==全类名==包名（类的地址）+类名；

作用

区分重名的类；

按照不同功能管理类；

控制访问权限；

命名规范

包名一般情况是小写，用“ . ”来区分包的等级；

第一级指该项目的类型，如com,org（开源组织）,gov（政府）等；

第二级指项目所开发或者运行的公司名称，如: oracle,sun,huawei等；

第三级指项目的名称，如:bcms,oa,erp,cms等第四级指项目模块的名称，如:bean,action,exception等。

包可以更好得管逻辑相关的类，可以控制不同包之间的访问权限;

导入外部包的类，关键字“import";

package com.wm.javaoop.test;

/*
    import 导入其他包中的类，在一个类中需要用到另一个包中的类时，需要先导入全类名；（导包）
    
 */
import com.wm.javaoop.day1.Demo;

public class Test{
    public static void main(String[] args) {
        new Demo();
        /*
            使用两个不同包里的类时，需要使用全类名；
         */
        new com.wm.javaoop.day2.Demo();
        /*
            java.lang包下的类在使用时不需导入就可以使用；
         */
        String s="abc";
    }
}

注：import 导入其他包中的类，在一个类中需要用到另一个包中的类时，需要先导入全类名；（导包）

使用两个不同包里的类时，需要使用全类名；

java.lang包下的类在使用时不需导入就可以使用；（String）

访问权限修饰符

访问权限修饰符可修饰：成员变量、成员方法、构造方法、内部类。

public

公共权限修饰类、属性、方法。可以被任意类访问；

protected

受保护的权限修饰属性、方法;可以被同包类访问，如果不是同包类，必须是该类的子类才可以访问；

默认

同包权限修饰类、属性、方法。只能被同包的类访问

private

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

package com.wm.javaoop.day1;

/*
    public 修饰类时，类名必须与文件名一致；
    一个.java文件中，只能有一个public 修饰的类；
 */
public class Demo {

    public int pub;//公共权限       修饰类、属性、方法；任意类访问
    protected int pro;//受保护权限  修饰属性、方法；同包类访问、不同包类的子类
    int num;//默认权限(同包权限)     修饰类、属性、方法；同包类
    private int pri;//私有权限     修饰属性、方法；只能在本类中访问

    public void putMethod(){

    }
    protected void proMethod(){

    }
    void Method(){

    }
    private void priMethod(){

    }
    public static void main(String[] args) {
        Demo demo=new Demo();
        demo.pub=10;
        demo.pro=20;
        demo.num=30;
        demo.pri=40;

    }

}

面向对象特征

三大特征

封装继承多态

封装

指的是通过权限修饰符，使得类中的信息是否对外可见（隐藏类中的信息）

类的内部信息对外隐藏，将成员设置私有权限，对外提供特定的get set方法进行访问。

实现封装

通过修饰符修饰，进行属性私有化，private是封装的一种思想体现，其他修饰符也可以进行修饰。
对外提供方法入口：私有化后，外界无法直接访问，需对外界提供一个访问方式。提供特定方法（get set方法）来获取值和改变值。

this关键字

this关键字指向的是当前类对象的引用
哪个对象调用this，this就指向哪个对象（就近原则）
用来区分成员变量和局部变量（重名问题）

设计模式：一系列解决问题的方案算法

23种；

单例设计模式：解决只让一个类在一个程序中创建一个唯一的对象；

public class Person {
    /*
        使用private这个权限限制修饰符对成员变量进行修饰，在其他类中访问不到了；
     */
    private String name;
    private int age;
    private static Person person=null;

    /*
        把构造方法设置私有权限；
     */
    private Person(){

    }
    public static Person creatPerson(){
        if(person==null){
            person=new Person();
        }
        return person;
    }

    //为封装起来的成员变量提供一个特定的公共权限的方法，用来为其赋值；
    //方便我们自己加入一些控制语句；
    public void setName(String name){
        if(name!=null||name.length()<10){
            this.name=name;
        }
    }
    //获取name属性值；
    public String getName(){
        return this.name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return this.age=age;
    }
}

public class TestPerson {
    public static void main(String[] args) {
        /*
            设计模式：一系列解决问题的方案  算法
            23种，
            单例设计模式：解决只让一个类在一个程序中创建一个唯一的对象；
         */
//        Person zs=new Person();
//        Person zs1=new Person();
        Person zs=Person.creatPerson();
        Person zs1=Person.creatPerson();
        System.out.println(zs);
        System.out.println(zs1);
    }
}

高手敏smart_sheep

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象第二课

1.Java中，除基本类型外的变量类型都称之为引用类型；2.Java中的对象是通过引用对其操作的；3.以Car bm = new Car();为例：是以Car类为模板，在堆空间里创建一个Car类对象；左边的Car bm创建了一个Car类型的引用变量（以后可以用来指向Car对象的对象引用）“=”操作符使对象引用指向刚创建的那个Car对象；Car bm;bm=new Car;拆成两部分理解，一是对象引用变量，一是对象本身；解释说明：值传递：基本类型作为参数；引用传递引用传递：本质上也是值传递，只是为
复制链接

扫一扫

专栏目录