面向对象 4（封装）

最新推荐文章于 2024-09-09 14:40:58 发布

XXKongShan

最新推荐文章于 2024-09-09 14:40:58 发布

阅读量298

点赞数

分类专栏：学习笔记文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/m0_64115984/article/details/122375381

版权

学习同时被 2 个专栏收录

25 篇文章 0 订阅

订阅专栏

笔记

25 篇文章 0 订阅

订阅专栏

一、this的使用

（1-7）

this:表示当前对象，便是当前对象的引用

用途：

1、构造方法，当构造方法中的参数名跟类的成员变量一样的时候，可以用this代表当前对象。

注意：有了this之后，就可以将构造器方法的参数跟成员变量保持一直（符合命名规范）当构造方法中需要调用其他的构造方法时，可以使用this（参数列表）调用其他构造方法，但是必须位于方法体的第一行。

2、普通方法中：当多个普通方法之间需要相互调用的时候，可以使用this来进行调用，之的是当前对象的其他方法。

3、调用成员变量的时候如何使用：当方法中的参数名称跟成员变量保持一直的时候，使用this，变量名称表示的是对象的值，而使用变量名。

public class ThisDemo {
    //成员变量
    String name;
    int age;

    //构造方法
    public ThisDemo(){

    }
    public ThisDemo(String name){
        this.name=name;


    }

    public ThisDemo(String name ,int age){
        //this.name=name;
        this(name);
        this.age=age;
    }
    public void test1(){
        System.out.println("test1被执行");
      
    }
    public void test2(String name){
        System.out.println("test2被执行");
        System.out.println(name);

    }


    public static void main(String[] args) {
        ThisDemo td=new ThisDemo("张飞",20);
                        //张飞  20 赋值给name  age
        System.out.println(td.name);
        System.out.println(td.age)
        td.test2("赵云");
        //赵云赋值给test2中的name
        
    }
}
//输出
//张飞
//20
//test2被执行
//赵云

二、static的使用

static
修饰成员变量的时候，表示静态变量或者叫类变量
普通变量在使用的时候，必须要通过对象名进行调用
变量或者今天太变量可以使用对象名调用也可以使用类名进行调用
修饰方法的时候，表示静态方法或者叫类方法
普通方法在使用的时候，必须要通过对象名进行调用
类方法或者静态方法可以使用类名，也可以使用对象名
注意：
1、静态变量，在创建对象之前被初始化，或者说在类被载入之前进行初始化
2、静态变量被所有的对象共享，属于公共变量，对象和类都可以直接调用，但是推荐使用类来调用
3、成员变量放在堆中，而静态变量放在方法区中的静态区
4、静态变量不能定义在非静态方法中
5、静态方法可以在非静态静态放法中进行调用
6、静态方法中不能直接调用非静态方法,但是可以间接调用非静态方法
7、静态方法中不允许出现this调用
8、一般工具类中的定义为static

//4、静态变量不能定义在非静态方法中

//5、静态方法可以在非静态静态放法中进行调用

//6、静态方法中不能直接调用非静态方法,但是可以间接调用非静态方法

//7、静态方法中不允许出现this调用
public class StaticDemo {
    public void test1(){
        System.out.println("test1 non-static ");
       //静态方法不能定义在非静态方法中 static int a=10;（错误实例）
 }
    public static void test2(){
//this.test1  (错误)this不能出现在静态方法中
 // static int a=10;（错误实例）静态方法不能定义在静态方法中
  // test1();静态方法中不能直接调用非静态方法中的变量；但是可以间接调用
 new StaticDemo().test1();  
  //间接调用
    }
}

public class StaticDemo {
    //普通变量
    String name ="zhangfei";
    //普通的成员变量是归属于对象的，所以在用非static规定的成员变量的时候就必须先创建一个对象
   //在进行调用

    static int age=20;

    //public StaticDemo(String name,int age){
     //   this.name=name;
     //   this.age=age;
    //}
    //静态成员变量   存储在方法区中    如果用static  修饰的成员变量的话它就归属于类
    public void test1(){
        System.out.println("test1 non-static ");
        //static int a=10; 静态变量也不能定义在非静态方法中（错误实例）
        test2();
        //非静方法能调用静态方法中的变量
    }
    public static void test2(){
     //this.test1();  静态方法不能出现this调用
        System.out.println("test2 is a static method");
    //  静态方法不能定义在静态方法中 static int a=10;（错误实例）
    // test1();静态方法中不能直接调用非静态方法中的变量；但是可以间接调用
        new StaticDemo().test1();//间接调用
    }
     public static void main(String[] args) {
        StaticDemo sd =new StaticDemo();
        System.out.println(sd.name);
        System.out.println(sd.age);
         //statc 修饰的变量叫做类变量归属于类 

    }
}

三、代码块

1、普通代码块>直接在方法或语句中定义的代码块
2、构造代码块>直接写在类中的代码块
3、静态代码块>使用this声明的代码块
4、同步代码块>多线程的时候会学到
   普通代码块：定义在方法中，使用{}括起来的代码叫做普通代码块
   构造代码块：定义在类中的使用{}括起来的代码叫做构造代码块
   注意：每次代码运行的时候会将构造代码块中的代码添加到构造方法的面前构造代码块
   中的代码会添加到每一个构造方法中，当使用this（参数）的时候不会添加

   静态代码块：使用static{}括起来的代码叫做静态代码块，在程序载入的时候有限执行
   数据库链接等其他提前需要准备好的代码会放在static代码块

   //构造代码块会默认添加在构造方法中的第一行
public class CodBlockDemo {
    {
        System.out.println("构造代码块");
        //构造代码块会默认添加在构造方法中的第一行
    }
  public void test1(){
        System.out.println("test1方法被执行");
      { 
        System.out.println("heihei");
      }
    }
  public static void main(String[] args) {
        CodBlockDemo cbd=new CodBlockDemo();
        cbd.test1();
        {
            System.out.println("mian方法中的代码块");
        }
    }
}

构造代码块

//构造代码块中的代码会添加到每一个构造方法中，当使用this（参数）的时候不会添加
public class CodBlockDemo {
    int x;
    int y;
    {
        System.out.println("构造代码块");
        //构造代码块会默认添加在构造方法中的第一行
    }
    public CodBlockDemo(){

    }
    public CodBlockDemo(int x){
        System.out.println("CodBlockDemo(int x)被执行");
        this.x=x;
    }
    public CodBlockDemo(int x,int y){
        //构造代码块原要出现两次  只出现一次  明显在this调用时代码块不会添加
        this(x);
        System.out.println("CodBlockDemo(int x,int y)被执行");
       this.x=x;
       this.y=y;
    }
    public void test1(){
        System.out.println("test1方法被执行");
        {
            System.out.println("test1方法中的普通代码块");
        }
    }
    public static void main(String[] args) {
        CodBlockDemo cbd=new CodBlockDemo();
        cbd.test1();
        {
            System.out.println("mian方法中的代码块");
        }
        CodBlockDemo cbd2=new CodBlockDemo(1,2);
    }
}

静态初始化块

类第一次被在如诗先执行static代码块；类多次在如诗，static代码只执行一次；

static经常用来进行static变量的初始化

1、静态初始化块只执行一次静态初始快优先被执行

2、构造代码块只要new了代码块都会被执行一次

3、另外当有this调用时则不执行代码块

4、静态初始块中不能访问非静态成员

四、package

1、文件同名

2、为了方便管理类，将具体处理功能的代码放到同一个目录下

使用：

一般定义package会放置在Java文件的第一行

package 域名的倒写

比如：www.taobao.com

包名：com.taobao.

package com.tensent.项目名称

完全限定名：包名+类名

包名的命名规则：

企业性质.企业名称.项目名称.模块名称. 子模块名称...

企业性质：com org edu gov

企业名称：alibaba baidu huawei tensent

项目名称：oa erp hrms crm

模块名称：ums--userMangementSystem 用户管理系统

oms--oroduceMangementSystem 订单管理系统

pms--produceManagementSystem 产品管理系统

完整的限定名：包名+类名

JDK中常用的包：(后面细讲)

java.lang：不需要手动导入，自动加载

java.awt：包含了一些GUI图形界面常用的类（这个现在已经不用了，了解即可）

java.util：工具包

java.net：网络包

java.io:输入输出流包

package netclass01;
import java.util.Date;
import java.util.Scanner;
/*package
*通常是类的第一句非注释性语句
*包名：域名倒着写即可，再加上模块名，并不内部管理类
* 注意：
* 写项目时都要加包，不要使用默认包
* com.gao和com.gao.car这两个包没有包含关系，是两个完全独立的包。
* 只是逻辑上看起来后者是前者的一部分
* */
public class PackageDemo {
    public static void main(String[] args) {
    //    java.util.Date date=new java.util.Date();
   //     Scanner scanner=new Scanner(System.in);
    Date date=new Date();
        Scanner scanner=new Scanner(System.in);
    }
}

五、import

为什么需要import

如果不使用import我们如果用到其他包的类时，只能这么写：java.util.Date，代码量太大，不利于编写和维护。通过import可以导入其他包下面的类，从而可以在本类中直接通过类名来调用。

import怎么使用？

方法一：import java.util.Dater；

方法二：import java.util.*；

1.导入Math类的所有静态属性

2.导入该包下的所有的类，会降低编译速度，但不会降低运行速度

（不推荐使用，因为它不会影响运行速度，但是会影响编译的速度）

import static.Java.lang.Math.PI；

导入Math类的PI属性导入一个

System.out.println(PI);

注意要点：

java会默认导入java.lang包下所有的类，因此这些类我们可以直接使用

如果导入两个同名的类，只能用包名+类名来显示调用相关类：

java.util.Date date=new java.util.Date();

package netclass01;
import work.Person;
import java.util.Date;
import java.util.Scanner;
public class ImportDemo {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        //当需要引入非long包的其他java类的时候，需要使用import工具
        java.util.Arrays.sort(new int[]{1,2,5,6,4});
        //如果不使用import，每次在使用某个类的时候必须要将类的完全限定名都加上才可以使用，太过于繁琐
          //跨包使用
        Person person=new Person();
        Date date=new Date();
      
    }
}

静态导包

package netclass01;
import static java.lang.Math.*;
public class ImportDemo {
    public void abs(){
    }
    public static void main(String[] args) {
        //静态导包可以省略类名
        System.out.println(random());
        System.out.println(sqrt(4));
        System.out.println(Math.abs(-10));
        // System.out.println(abs(-10));
        //当有一个abs的方法与abs同名时必须加上Math.
        //  .*为通配符
    }
}

六、封装

面向对象三大特征之一 ——封装
—封装的概念
封装：将类的某些信息隐藏在类内部，不允许外部程序直接访
问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

封装的好处

隐藏类的实现细节
只能通过规定方法访问数据
方便加入控制语句
方便修改实现

package netclass01;
public class Dog {
    private String name;
    private int age;  //私有属性，只能在当前类使用
    private int weight;
    public Dog(){

    }
    public Dog(String name,int age,int weight){
        this.name=name;
        this.age=age;
        this.weight=weight;
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name=name;
    }
    public int  getWeight(){
        return weight;
    }
    public void setWeight(int weight){
        this.weight=weight;
    }
    //定义
    public void setAge(int age){
       if(age>0) {
           this.age = age;
       }else{
           System.out.println("您输入的年龄不合法");
       }
    }
    public int getAge(){
        return this.age;
        }
    }
}

//对上个代码进行调用  只能调用方法不能调用以private修饰的私有属性
package netclass01;
public class DogTest {
    public static void main(String[] args) {
        Dog dog=new Dog();
        dog.setName("旺财");
         dog.setAge(20);
         dog.setWeight(35);
        System.out.println(dog.getName());
        System.out.println(dog.getAge());
        System.out.println(dog.getWeight());
    }
}

七、修饰符的使用

在java中明确定义了访问权限：

限制访问，一下分类按照从大到小进行排序

1、public ：公共的，当前项目的所有类都可以访问

2、protected：受保护的，可以被当前类访问，可以被当前包访问，也可以被子类访问

3、defaylt（缺省）：私有权限，被当前类访问，与当前包中的访问。

4、private：只能访问当前类

缺省修饰符不能出现在代码中

注意：四种访问修饰符可以修饰属性和方法

类的访问修饰符只有两个 public default

修饰符的访问权限（下图）

public class Tiger {
   private  boolean isAnimal;
 public Tiger(){

    }
 public Tiger(boolean isAnimal){
}       //boolean get方法以is开头
 public boolean isAnimal(){
        return isAnimal;
    }
    public void setAnimal(boolean animal){
        this.isAnimal=animal;
    }
}

XXKongShan

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象 4（封装）

学习目录1、this 关键字的使用2、static 关键字的使用3、代码块4、package 的使用5、import6、封装一、this的使用this:表示当前对象，便是当前对象的引用用途：1、构造方法，当构造方法中的参数名跟类的成员变量一样的时候，可以用this代表当前对象。注意：有了this之后，就可以将构造器方法的参数跟成员变量保持一直（符合命名规范）当构造方法中需要调用其他的构造方法时，可以使用this（参数列表）调用其他构造方法，但是必须位于方法体的
复制链接

扫一扫