JavaSE-面向对象（2）

最新推荐文章于 2024-05-25 12:01:51 发布

发自己的光就好

最新推荐文章于 2024-05-25 12:01:51 发布

阅读量111

点赞数

分类专栏： Java面向对象文章标签： java

本文链接：https://blog.csdn.net/qq_53677566/article/details/116067164

版权

Java面向对象专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一.对象与引用

1.java中的数据类型

基本类型：byte short int long … 简单类型
引用类型: 除了基本类型都是引用, 用类作为类型,数组复杂类型复合类型 int [] a = {}，

比如类，接口数组等都是引用类型

为什么叫引用类型？

引用类型变量不是持有对象本身,只是拥有对象的地址,通过地址间接访问对象

例：
```
Car one=new Car();
 //one就相当于是引用类型，它指向的的是new Car();的地址，并不是new Car();本身
```

2.Java 语言中除基本类型之外的变量类型都称之为引用类型。

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

例子分析(引用类型的具体解释)：

public class Car {
    String color;
    String name;
    String model;
    
    Car car=new Car();
}

分析：Car car=new Car();

通常把这条语句的动作称之为创建一个对象，其实，它包含了三个动作:

(1）右边的“new Car()”，是以Car类为模板,调用Car类的构造函数,在堆空间里创建一个Car类对象

（2）左边的“Car car”创建了一个Car类型引用变量。所谓Car类的引用，就是以后可以用来指向Car

对象的对象引用，用car指向创建的对象的地址。

（3）”=”操作符使对象引用指向刚创建的那个Car对象。我们可以把这条语句拆成两部分：

一. Car car;

二. car= new Car();

这样写，就比较清楚了，有两个实体：一是对象引用变量，一是对象本身。

解释：

一：声明了一个对象的引用变量car

二：右面创建了一个Car的具体对象，用“=”将一.中声明的引用变量指向新创建的Car类对象

这个对象也可以有被多个引用变量指向，如下：

 Car car=new Car();
 Car car1;
  car1=car;
//这时引用变量car1和car都指向同一个对象

4.值传递与引用传递

值传递：(形参数类型是基本数据类型)：方法调用时，实际参数把它的值传递给

对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是

两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。

 /*
      int a=10;
      int b = a;  用a的值(10) 把b变量初始化
     */
    public static void main(String[] args) {
        int a = 10;
        Test1 t = new Test1();
              t.test(a);
        System.out.println("a:"+a);//10
    }
    //参数类型为基本类型,就是将变量的值本身传递赋给了另一个变量
    public  void  test(int b){
        System.out.println("b1:"+b);//10
        b=20;
        System.out.println("b2:"+b);//20
    }

引用传递：(形参数类型是引用数据类型参数)：也称为传地址。方法调用时，实

际参数是对象，这时实际参数与形式参数指向同一个地址，在方法执行中，对形

式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下

来，所以方法执行中形式参数的改变将会影响实际参数。

public static void main(String[] args) {
            Dog xh = new Dog();
                xh.name= "小黑";
           Test2 t = new Test2();
                 t.test(xh);
        System.out.println("xh"+xh.name);
    }

    //引用类型传递时并不是将对象本身传递,只是将对象引用地址传递,这样形参发生变化,实参也会发生改变,因为两个指向同一个对象
    public void test(Dog dog){
        System.out.println("dog1"+dog.name);
        dog.name="旺财";
        System.out.println("dog2"+dog.name);
    }

基本类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象本身

二.static关键字

1.概念和特性

static被称为静态，可以用来修饰类的属性,方法,代码块,内部类
随着类的加载而加载
优先于对象存在
修饰的成员，被所有对象所共享
可不创建对象，直接被类调用

2.属性

静态属性是类的所有对象共享的，即不管创建了多少个对象，静态属性在内存中只有一个。
$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qyXJjwn8-1619175569938)(C:\Users\封纪元\AppData\Roaming\Typora\typora-user-images\1619171845939.png)]$
static方法可以使用对象调用，也可以直接用类名调用，建议用类名直接调用
在static方法内部只能访问类的static属性，不能访问类的非static属性,static属

性先加载。

 String name;//非静态的是创建对象时加载
    static int  num = 10;

    /*
    static修饰的方法随着类的加载而加载,static方法属于类,但也可被对象调用,建议通过类名
    static方法中不能使用非静态变量, 因为静态的内容都是先加载
     */
    public static void test(){
        //System.out.println(name); 不能使用非静态
        System.out.println(num);
    }

    //非静态的成员方法中可以使用静态的成员变量,
    public void test1(){
        System.out.println(num);
    }


    public static void main(String[] args) {
        TestStaticMethod.test();
        TestStaticMethod t = new TestStaticMethod();
             t.test1();


    }

三：代码块

1.概念与代码

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

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

{

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

}

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

static {

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

}

public class Student {

       /*
         成员变量
        */
       int num;
       String name;
       static  String country = "中国";
       //代码块定义在类中,没有名称,分为实例代码块,静态代码块
       //代码块没有名字,怎么执行?
       //实例块在创建对象时调用,每创建一次对象执行一次
       //静态代码块在类被加载时被调用,只执行一次
       //类被加载时 第一次创建对象,使用类中的静态变量,静态方法
       {
              System.out.println("实例代码块1");
       }
       {
              System.out.println("实例代码块2");
       }
       static{
              System.out.println("静态代码块1");
       }
       static{
              System.out.println("静态代码块2");
       }

       public Student(){
              System.out.println("无参构造方法");
       }

       /*
         成员方法
        */
       public  void showInfo(){
           System.out.println("学号"+num+"\t姓名:"+name);
       }


}

四：类的加载执行

public class Student {

       /*
         成员变量
        */
       int num;
       String name;
       static  String country = "中国";
       //代码块定义在类中,没有名称,分为实例代码块,静态代码块
       //代码块没有名字,怎么执行?
       //实例块在创建对象时调用,每创建一次对象执行一次
       //静态代码块在类被加载时被调用,只执行一次
       //类被加载时 第一次创建对象,使用类中的静态变量,静态方法
       {
              System.out.println("实例代码块1");
       }
       {
              System.out.println("实例代码块2");
       }
       static{
              System.out.println("静态代码块1");
       }
       static{
              System.out.println("静态代码块2");
       }

       public Student(){
              System.out.println("无参构造方法");
       }

       /*
         成员方法
        */
       public  void showInfo(){
           System.out.println("学号"+num+"\t姓名:"+name);
       }
       public static void main(String[] args) {
        Student student1 = new Student();
      
     }

}

执行结果

在这里插入图片描述

类中元素的加载顺序

先加载静态的,静态的内容按照先后顺序加载.

实例代码块

构造方法

五：包

1.概念

就是文件夹

2.作用

避免类重名
按照不同功能管理类
控制访问权限

3.包（package）的命名规范

在包名中，可以使用.号来区分包的级别；包名一般情况下是小写

第一级指该项目的类型，如com,org,gov等，

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

等

第三级指项目的名称，如：bcms,oa,erp,cms等

第四级指项目模块的名称，如：bean,action,exception等

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

4.导入外包的关键字

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

六.访问权限修饰符

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

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

（2）protected：受保护的权限修饰属性、方法。

可以被同包类访问，如果不是同包类，必须是该类的子类才可以访问。

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

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

在这里插入图片描述

public class Demo {
    
           public String  pubName;
           protected  String proName;
                   String  delName;
           private String  priName;

    public static void main(String[] args) {
        Demo demo = new Demo();
        System.out.println(demo.pubName);
        System.out.println(demo.proName);
        System.out.println(demo.delName);
        System.out.println(demo.priName);//在本类访问
    }

}

在同一个包中

//与Demo在同一包中
public class Demo1 {

    public static void main(String[] args) {
        Demo demo = new Demo();
        System.out.println(demo.pubName);
        System.out.println(demo.proName);
        System.out.println(demo.delName);
        //System.out.println(demo.priName);//在本类访问
    }
}

不同包中并且有与Demo有继承关系

//不同包中并且有与Demo有继承关系
public class Test extends Demo {

       String name;

        public static void main(String[] args) {
            Demo demo = new Demo();
            System.out.println(demo.pubName);
            //System.out.println(demo.proName);
            //System.out.println(demo.delName);
            //System.out.println(demo.priName);//在本类访问

            Test t = new Test();
            System.out.println(t.proName); //在不同包的子类访问受保护权限
        }

}

七：封装

1.概念

封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，

而是通过该类提供的方法来实现对隐藏信息的操作和访问。

2.封装的好处

在这里插入图片描述

3.具体表现

–属性使用private权限

–方法使用public权限

public class Person {

    private  String name;
    private  int age;
    private static Person person=null;

    public void setName(String name){
        if(name!=null){
            //this表示当前正在操作的对象
            this.name = name;
        }
    }
    public String getName(){
        return name;
    }

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

}

以下是在外部访问Person类

//这是在外部访问上面的Person类
public class TestPerson {

    public static void main(String[] args) {

        Person p1 = new Person();
               p1.setName("ssdsa");
               p1.setAge(18);

        System.out.println(p1.getName());
        System.out.println(p1.getAge());

        Person p2 = new Person();
        p2.setName("aaa");
        p2.setAge(18);

    }
}

八.this关键字

this关键字代表自身类的对象
使用this关键字引用成员变量
使用this关键字引用成员方法

注意：this关键字必须放在非静态方法里面

在一个类的方法或构造方法内部，可以使用“this.成员变量名”这样的

格式来引用成员变量名，常常用来区分同名的成员变量和局部变量。

如：

public class Student {
    String name;
    int age;
    char gender;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;   //这里的this是区分成员变量和局部变量的
        this.age = age;
    }

    public Student(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
}

this后面指的是“操作谁就指的是谁”

各位看官能否留个赞再走~~~~~~~

发自己的光就好

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE-面向对象（2）

面向对象 2一.对象与引用1.java中的数据类型基本类型：byte short int long … 简单类型引用类型: 除了基本类型都是引用, 用类作为类型,数组复杂类型复合类型 int [] a = {}，比如类，接口数组等都是引用类型为什么叫引用类型？引用类型变量不是持有对象本身,只是拥有对象的地址,通过地址间接访问对象例：Car one=new Car(); //one就相当于是引用类型，它指向的的是new Car();的地址，并不是new Car()
复制链接

扫一扫