JAVA基础--JAVA SE(知识点总结 Ⅳ )

前面内容请见:
JAVA基础–JAVA SE(知识点总结 Ⅰ )
JAVA基础–JAVA SE(知识点总结 Ⅱ )
JAVA基础–JAVA SE(知识点总结 Ⅲ )
以下是我们今天的内容:

在这里插入图片描述

面向对象

1.局部变量和成员变量的区别
  • 书写位置不同:

    •         成员变量:在类中,方法外
      
    •         局部变量:在方法定义中,或者方法声明上
      
  • 内置中的位置不同

    •         成员变量:堆内存中,和对象有关系
      
    •         局部变量:栈内存中,和方法有关系
      
  • 生命周期不同:

    •         成员变量:随着对象的创建而存在,随着对象的创建完毕后,等待jvm的垃圾回收器(GC)空闲的时候回收而消失
      
    •         局部变量:随着方法的调用而存在,随着方法调用结束而消失
      
  • 初始化值不同:

    •         成员变量:是可以不初始化的,需要通过对象名来赋值,存在默认初始化
      
    •         局部变量:必须在使用之前初始化,否则报错;
      
  • 什么时候把一个变量定义为成员变量?

    •         如果一个类能够描述这个事物的属性,必须为定义成员变量
      
    •         否则,都定义为局部变量
      
//定义一个类 Demo
class Demo{

    //成员变量:类中方法外
    public int num  ;

    public void show(String a){ 
        //局部变量
        int x = 5 ; //必须使用之前初始化,否则编译会报错--报错信息Variable 'x' might not have been initialized
        System.out.println(a+x);
    }
}

//测试类
public class VariableDemo {
    public static void main(String[] args) {

        //要去访问Demo类中num变量
        Demo d = new Demo() ;
        System.out.println(d.num); //对象名.成员变量名;
        d.show("胡歌");
    }
}

2.this关键字
  • 代表当前类对象的地址值引用

    •                              目的:就是为了区分局部变量隐藏了成员变量,加入this可以区分
      
  • 格式

    • this.成员变量名 = 局部变量名 ;
/*手机有品牌(brand),价格,颜色,内存等属性,手机可以打电话,发短信,打游戏等行为,
请使用面向对象的方式描述手机并且进行测试*/
public class Phone {
    private String brand;
    private double price;
    private String color;
    private String memory;

    public void setBrand(String brand){
        this.brand = brand;
    }
    public void setPrice(double price){
        this.price = price;
    }
    public void setColor(String color){
        this.color = color;
    }
    public void setMemory(String memory){
        this.memory = memory;
    }

    public String getBrand(){
        return brand;
    }
    public double getPrice(){
        return price;
    }
    public String getColor(){
        return color;
    }
    public String getMemory(){
        return memory;
    }

    public void callPhone(String toName){
        System.out.println("在用" + brand + "," +  "给" + toName + "打电话");
    }
    public void sendMsg(String toName){
        System.out.println("在用" + brand + "," + "给" + toName + "发短信");
    }
    public void playGame(String toGame){
        System.out.println("在用" + brand + "," + "玩" + toGame);
    }
}
3.匿名对象
  • 匿名对象:毋庸置疑,没有名字的对象;

  • 匿名对象的格式

    • new 类名();
  • 优点

    • 直接在堆内存开辟空间,创建完毕之后,没有栈内存指向,所以使用完毕,立即被GC(垃圾回收器回收)
      • 一般情况:匿名对象使用一次即可,这样不需要过多的去开辟堆内存空间,直接被回收
    • 匿名对象可以作为参数传递
  • 注意

    • 方法的形式参数如果是基本类型,调用该方法的时候,实际参数只需要传递对应的数据值即可
    • 方法的形式参数如果是引用类型:数组,类,接口,实际参数在进行传递时需要传递,当前数组对象 /类的对象/接口的对象

方法形式参数如果是一个类(引用类型),当调用该方法时,实际参数应当如何传递

  • 如果方法的形式参数是类,实际参数传递时,需要传递的是当前类的具体类对象

    • 参数名.study(): ----参数名一定要是空间地址值,则需要创建具体的学生对象
    //定义一个类Demo
    class Demo{
        //成员方法
        public int add(int a,int b){ //方法的形式参数是基本类型
            return  a+ b ;
        }
    }
    //定义一个学生类
    class Student{
        public void study(){
            System.out.println("好好学习,天天向上!");
        }
    }
    //定义一个StudentDemo类对象
    class StudentDemo{
        //成员方法method                  
        public void method(Student student){ //引用类型:数组,类或者接口    方法形式参数类型:Student类型
                                  //参数名.study():  ---参数名一定要是空间地址值,则需要创建具体的学生对象
            student.study() ;
        }
    }
    //测试类
    public class StudentTest {
        public static void main(String[] args) {
            //1.方法的形式参数是基本类型: 
            Demo d = new Demo() ;
            int result = d.add(15,15) ;
            System.out.println("结果为:"+result);
    
            System.out.println("----------------------------------------------") ;
    
            //2.要访问StudentDemo类中的method方法?
            //创建StudentDemo类的对象
            //类名 对象名 = new 类名() ;
            StudentDemo sd = new StudentDemo() ;
    
            //创建Student类具体对象
            Student student = new Student() ;
            sd.method(student) ;//方法的形式参数Student类型,所有需要将Student具体对象创建出来才能调用
    
            //链式编程,匿名对象作为参数(一般不推荐)
            new StudentDemo().method(new Student());
        }
    }
    
4.类的构造方法
  • 什么是类的构造方法 ----> 一个比较特殊的方法

    • 方法名和类名相同
    • 没有void
    • 构造方法可以重载
  • 分类

    • 无参构造方法(构造器)

      public 方法名(){
          
      }
      

      注意:

      • 方法名与类名一致

      • 没写构造方法是,系统默认为无参构造方法, 但是当如果提供有参构造方法时,系统就不会在提供无参构造方法

    • 有参构造方法(构造器)

      public 方法名(参数类型 参数名,...){
          
      }
      

      注意:

      • 方法名与类名一致
  • 构造方法的目的

    • 为了类的成员相关的数据,进行初始化
      • 系统默认初始化
      • 显示初始化
  • 一个标准类(JavaBean)的写法:

    •              成员变量私有化
      
    •              提供对外的公共访问方法,setXXX()/getXXX()
      
    •              提供无参构造/ 有参构造方法 (根据需求进行判断)
      
/*学生有姓名,年龄,性别属性,行为有学习,睡觉以及玩游戏的行为,

睡觉的行为,没有返回值类型; 玩游戏的行为:有一个字符串String类型的参数 gameName

请使用面向对象方式书写学生类并且进行测试(使用标准类完成并进行测试)*/
public class Student {
    String name;
    int age;
    String sex;

    //无参构造方法
    public Student() {
    }

    //有参构造方法
    public Student(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public void study(){
        System.out.println(name + "正在学习中......");
    }
    public void sleep(){
        System.out.println(name + "正在睡觉......");
    }
    //玩游戏的行为:有一个字符串String类型的参数 gameName
    public void game(String gameName){
        System.out.println(gameName + "正在玩游戏......");
    }
}
//测试类
public class StudentTest {
    public static void main(String[] args) {
        //无参构造方法
        Student student = new Student();
        student.setName("天天");
        student.setAge(25);
        student.setSex("女");

        System.out.println("姓名:" + student.getName() + "\n" + "年龄:" + student.getAge() + "\n"  +"性别:" +
                student.getSex());
        student.study();
        student.sleep();
        student.game("DOTA");

        System.out.println("---------------------------------------------");
        //有参构造方法
        Student student1 = new Student("向向",25,"男");

        System.out.println("姓名:" + student1.getName() + "\n" + "年龄:" + student1.getAge() + "\n"  +"性别:" +
                student1.getSex());
        student1.study();
        student1.sleep();
        student1.game("DOTA");

    }
}

5.static关键字
  • 特点
    • 被静态修饰的,随着类的加载而加载,优先于对象存在
    • 不能和this共存
    • 本身含义就是共享,共用,可以多个对象共享共用
    • 被静态修饰的成员变量或者成员方法,叫做静态变量或者静态方法
public class Person {
    //属性:姓名,年龄和国籍,先不用私有
    String name ; //姓名
    int age ; //年龄
    static String country ;// 国籍

    //永远给出无参构造方法
    public Person(){}
    //给出有参构造方法  ---带两个参数
    public Person(String name,int age){
        this.name = name ;
        this.age = age ;
    }

    //带三个参的构造方法
    public Person(String name,int age,String country){
        this.name = name ;
        this.age = age ;
        this.country = country ;
    }

    //show方法,展示这个人具体信息
    public void show(){
        System.out.println("这个人姓名是:"+name+",年龄是:"+age+",所在的国籍是:"+country);
    }
}
//测试类
public class PersonTest {
    public static void main(String[] args) {
        //测试
        //描述 古代四大美女
        Person p1 = new Person("貂蝉",25,"中国") ;
        p1.show();

        Person p2 = new Person("王昭君",21);
        p2.show();
        
        Person p3 = new Person("西施",22);
        p3.show();
        
        Person p4 = new Person("杨玉环",27);		//只有第一个输入"中国",但后面3个同样输出"中国"
        p4.show();
    }
}
  • 访问的方式:

    •  可以使用对象名来访问,但是,对于系统来说(jvm)对静态的东西:变量/方法,都是通过类名直接访问
       *      类名.变量名;
       *      类名.方法名(); 
      
  • 静态的使用场景适用于范围:

    •              简单记忆:静态只能用于访问静态
                   *                  静态方法中只能访问静态变量
                   *                  静态方法只能调用静态方法
                   *                  非静态方法皆可以访问静态的东西也可以访问非静态的东西
      
public class ArrayTool {
    //提供一个私有的构造方法,为了外界不能直接new
    private ArrayTool(){}

    public static void printArray(int[] arr){ //形式参数---引用类型,数组类型,需要传递这个数组的对象
        System.out.print("[");
        for(int x = 0 ; x <arr.length ; x ++){
            //如果x角标取到最大索引值
            if(x==arr.length-1){
                System.out.println(arr[x]+"]");
            }else{
                System.out.print(arr[x]+", ");
            }
        }
    }
}
//测试类
public class ArrayTest {
    public static void main(String[] args) { //静态只能访问静态

        //数组,静态初始化了
        int[] arr = {65,13,24,97,78} ;

        //新的访问:使用工具类名.静态方法名()
        //遍历
        ArrayTool.printArray(arr) ;
    }
}
6.javadoc注释文档(补充)
  • 对ArrayTool.java文件产生一个文档说明书 ----> 类似于API(Application Programming Interface:应用程序接口文档)
    •  使用jdk安装目录里面的bin里面: javadoc.exe 指令,产生文档说书的指令
      
    •  将ArrayTool这个java文件代码复制到本地某个磁盘上,类名和文件名称一致(先不要把package复制上去)
      
    •  打开dos窗口,进入到这个java文件的路径下(保证访问权限足够大:public)
      
    •  用javadoc  -d 目录名称 -author -version ArrayTool.java(java源文件带后缀)  产生文档说明书
      
/**
 *ArrayTool类是针对数组操作的工具类,里面包含了数组的遍历功能,求数组最值问题,
 * 获取数组的元素第一次出现索引值,冒泡排序等提供很多功能;
 * @author In-Deep
 * @version V8.0
 */
public class ArrayTool {
    private ArrayTool(){}
    /**
     * 这个方法是针对数组的遍历功能,将数组按照指定格式输出,输出格式如下:
     * [元素1, 元素2, 元素3, 元素4,....元素n]
     * @param arr 要传递的真实数组(要遍历的数组对象)
     */
    public static void printArray(int[] arr){ 
        System.out.print("[");
        for(int x = 0; x <arr.length; x++){
            //如果x角标取到最大索引值
            if(x==arr.length-1){
                System.out.println(arr[x]+"]");
            }else{
                System.out.print(arr[x]+", ");
            }
        }
    }

    /**
     * 这个方法是获取数组中的最大值;
     * @param arr 要传递数组对象,在这里面查询最大值
     * @return 返回数组中的最大值
     */
    public static int getMax(int[] arr){
        int max = arr[0];
        for(int x =1; x <arr.length; x++){
            if(arr[x]>max){
                max = arr[x];
            }
        }
        return  max;
    }

    /**
     * 这个方法是获取数组中第一次出现索引值
     * @param arr 要查询的数组
     * @param key 要查找在数组中的指定的元素
     * @return 返回的就是数组的元素第一次出现的索引值,否则,返回-1
     */
    public static int getIndex(int[] arr,int key){
        int index = -1;
        for(int i = 0; i <arr.length; i++){
            if(key == arr[i]){
                index = i;
                break;
            }
        }
        return index;
    }
    /**
     * 这个方法是对数组进行冒泡排序
     * @param arr 要将数组进行排序
     */
    public static void bubleSort(int[] arr){
        for(int x = 0; x < arr.length -1; x++){
            for(int y = 0; y < arr.length-1-x; y++){
                if(arr[y] >arr[y+1]){
                    int temp = arr[y];
                    arr[y]  = arr[y+1];
                    arr[y+1] = temp;
                }
            }
        }
    }
}
7.代码块
  • 代码块 ----> 使用{}括起来的内容

  • 分类:

    • 局部代码块,就是在方法定义中使用{}

      •      {},作用:就是限定局部变量的生命周期;
        
    • 构造代码块:—在类的成员位置定义的{}

      •      特点:在执行构造方法之前,如果类中有构造代码块,则优先执行构造代码块
             *          作用:也可以给类的成员的数据进行初始化
        
      •      只要执行构造方法,如果存在构代码块,它必须优先执行,然后才是构造方法...
        
    • 静态代码块:

      • 类就加载一次,静态代码块也就执行一次

      • 格式 ----> 跟静态相关的都和类有关系,随着类的加载而加载

        static{ 
        
        		//里面书写代码 
        
        }
        
    • 优先级:

      • 静态代码块 > 构造代码块> 构造方法,并且每次执行构造方法之前,优先执行所有的构造代码块
    //测试类
    public class CodeDemo {
        public static void main(String[] args) {
             //局部代码块
            {
                int y = 20 ;
                System.out.println(y);
            }
            
            System.out.println("----------------------------------------------") ;
            
            Code code = new Code();
            Code code1 = new Code("华为");
        }
    }
    
    class Code{
        {
            int x = 100;
            System.out.println(x);
        }
        //无参
        public Code(){
            System.out.println("code");
        }
        {
            int y = 1000;
            System.out.println(y);
        }
        //静态代码块
        static {
            int z = 10000;
            System.out.println(z);
        }
        //有参
        public Code(String brand){
            System.out.println("brand:" + brand);
        }
    }
    
  • 1
    点赞
  • 0
    收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:游动-白 设计师:我叫白小胖 返回首页
评论

打赏作者

In-Deep

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值