static关键字、块、包机制、封装、继承、final关键字

最新推荐文章于 2024-05-21 22:13:42 发布

鸽了一路

最新推荐文章于 2024-05-21 22:13:42 发布

阅读量106

点赞数

文章标签： java 封装类

本文链接：https://blog.csdn.net/weixin_45575912/article/details/115464441

版权

1.srtatic关键字

被static 关键字修饰的的内容为静态的内容。static不可以修饰局部变量，只能修饰成员变量。

1.1静态变量

static 成员变量——>静态变量|类变量

成员是属于对象的，跟随对象使用，因为成员在对象的堆内存中，而static修饰的静态的内容是属于类的，可以跟随类使用。
静态变量都是独一份的，不在对象的堆内存中，在静态区中,在类第一次加载完成之后就会初始化静态内容。

1.2静态方法

static 方法——>静态方法|类方法

静态内容是当前这个类型所有对象共享的,共享在静态区中独一份静态内容。
在静态的内容中可以直接使用静态内容,但是不能直接使用成员内容,需要跟随对象使用成员。
在成员内容中可以直接使用静态,也可以直接使用成员。

1.3使用方法

被static关键字修饰的变量与方法的使用方式：

类名.静态变量名
类名.静态方法名
对象的引用.静态变量名
对象的引用.静态方法名()

public class StaticDemo01 {
    //成员位置 : 类中方法外部
    //成员变量
    int a = 10;

    //静态变量
    static String str = "哈哈";

    public static void main(String[] args) {
        //局部
        //static int i = 1; static不能修饰局部,只能修饰成员

        //测试静态内容的使用方式
        System.out.println(str);//当前类中类名可以省略
        System.out.println(StaticDemo01.str);
        StaticDemo01 sd = new StaticDemo01(); //当前类型对象
        System.out.println(sd.a);
        System.out.println(sd.str);

        System.out.println(Math.random());
        System.out.println(Math.PI);
    }

    /*
        成员方法 : 需要被对象调用,在成员方法中的成员变量,默认指代当前调用成员方法的对象的成员
     */
    public void test(){
        System.out.println(this.str);
        System.out.println(this.a);
    }
}

静态方法练习：

public class StaticTest02 {
	public static int id;
	public int age;
	public static void main(String[] args) {
			StaticTest02 staticTest02 = new StaticTest02();
//		testStatic.age=10;
		System.out.println(StaticTest02.id);   //0
		System.out.println(staticTest02.age);   //0
		
		staticTest02.change(); //id=1   age=0    //id=1 staticTest02.age=1
		System.out.println(StaticTest02.id); //1
		System.out.println(staticTest02.id);  //1
		System.out.println(staticTest02.age);  //age=0
		staticTest02.change();  //2 0       //2 1
		System.out.println(id);  //2
		System.out.println(staticTest02.age);  //0
		
		   
	}
	public void change() {
		StaticTest02 staticTest02 = new StaticTest02();
		staticTest02.age++;  //
		StaticTest02.id++;  //
		System.out.println("In Change(): id = " + id + " age = " + age);  //id=2   age=0  //
		System.out.println("In Change(): id = " + id + " staticTest02.age = " + staticTest02.age);
		//id=2 staticTest02.age=1
	}
}

2.块

{}所包含的范围即为块，其自成作用域。

2.1普通语句块

{}：位于方法中。

执行时机：跟随方法调用。

应用场景：代表一个作用域，可以把具有相同作用的代码放在一个{}中，具有语义化特点，也代表一个作用域。

2.2构造块

{}：位于类中方法外。

执行时机：创建对象new的时候就会调用。

注意：先于构造器代码之前执行，当存在多个构造块从上到下依次执行；

构造块代码在编译时会被编译到即将要执行的具体构造器代码的上方。

应用场景：成员变量的初始化。

public class BlockTest02 {
	public static int a = 0;
	{
		a = 10;
		System.out.println(" 3 、非静态代码块执行a=" + a); //10
	}	
	static {
		a = 6;
		System.out.println("1 、静态代码块执行a=" + a); //6
	}
	public BlockTest02() {
		this(a); //6
		System.out.println("6、"+a);  //10
		System.out.println("7、无参构造方法执行a=" + a); //10
	}
	public BlockTest02(int n) {  //n= 6
		System.out.println("4、"+n); //6
		System.out.println("5、"+a);//10
	}	
	public static void main(String[] args) {
		System.out.println(" 2、main"); //main
		BlockTest02 tsc = new BlockTest02();
	}
}

2.3静态块

static{}：类中方法外，在构造块的前面增加了static关键字。

执行时机：类第一次加载之后初始化执行。

注意：多个静态块依次执行。

应用场景：内容的初始化，类加载后静态块只执行一次，为静态变量内容初始化。

以上各类型的块执行顺序：静态块——main——构造块——构造器

public class BlockDemo01 {
    //类中方法外
    static int i ;
    int x = 15;

    //构造器
    public BlockDemo01(){
        System.out.println("空构造");
    }

    //构造块
    {
        System.out.println("我是构造块1哈哈哈哈");
    }
    {
        System.out.println("我是构造块2哈哈哈哈");
        //System.out.println(this.x);
    }
    {
        System.out.println("我是构造块3哈哈哈哈");
    }

    //静态块
    static{
        i = 10;
        System.out.println("静态块1");
    }
    static{
        System.out.println("静态块2");
        //System.out.println(new BlockDemo01().x);
    }


    public static void main(String[] args) {
        System.out.println("main");
        //局部
        int i =1;

        // 局部代码块|普通语句块W
        {
            i =5;
            System.out.println(i);
        }
        System.out.println(i);
        System.out.println(BlockDemo01.i);

        new BlockDemo01();
        new BlockDemo01();
    }

}

3.debug

debug作用：

追踪程序的执行流程；
观察执行过程中的变量变化情况；
定位程序执行过程中的异常；

步骤：

打断点，便于调试程序执行到断点位置时，变量的变化情况；
debug模式运行；
观察执行流程，变量的变化进行调试。

按钮：

step over（f8）：下一步，如果是方法调用则不进入
step into （f7）：下一步，如果是方法调用，进入方法内部，进行下一步执行，不会进入java源码
force step into（Alt+shift+f7）：进入方法内部，如果是java源码也会进入
step out（shift+f8）：回到上一层，结束方法的调用

4.包机制

包机制是为了管理众多的java文件，便于维护。

包名称位置：出现在当前java文件得第一行。

package、import、class出现的顺序一般为：1.package 2.import 3.class

导包即指明使用的java类的位置，有些类不需要导包：1.同包下的类 2.java.lang包下的内容。

导包的方式：

1.使用类型的时候指定类型的权限定名包名.类名
只在当前这一次有效
2.import 包名.类名;
定义在类的上面导入一次,当前类中都可以使用
3.模糊匹配 *
降低编译效率
4.静态导入
import static 包名.类名.静态内容;

package com.xxxx.package03;

import java.util.*;

//导入静态内容
import static java.lang.Math.PI;
//导入静态方法不要添加(),因为方法名()这叫方法的调用,执行方法中的代码
import static java.lang.Math.random;
public class ImportDemo01 {
    public static void main(String[] args) {
        //包名.类名: 权限定名
        java.util.Scanner sc = new java.util.Scanner(System.in);

        Scanner sc2 = new Scanner(System.in);

        List ls = new ArrayList();

        //静态变量
        System.out.println(PI);
        System.out.println(PI);
        System.out.println(PI);
        System.out.println(PI);
        System.out.println(PI);

        //静态方法
        System.out.println(random());
        System.out.println(random());
        System.out.println(random());
        System.out.println(random());
        System.out.println(random());
    }
}

包命名：

公司域名倒着写+功能名字|模块名字
全部小写，层级之间使用.进行连接

值得注意的是：不可以与jdk定义相同名字的包名与类名。

5.封装

封装的功能是：隐藏内部的实现细节，对外提供公共的访问方式。

5.1属性的私有化

private 私有的：表名属性只能在当前类中使用，外部类中无法使用。

私有的属性配合一套公共的访问方式一起使用：

设置器：为私有的属性进行赋值 setter

获取器：获取私有属性的值 getter

public class Person {
    private String name;
    private int age;
    private char gender;
    //空构造器
    public Person(){

    }
    //有参构造
    public Person(String name,int age,char gender){
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    //设置器   name
    public void setName(String name){
        this.name = name;
    }
    //获取器   name
    public String getName(){
        return name;
    }
    //age设置器
    public void setAge(int age){
        this.age = age;
    }
    //age获取器
    public int getAge(){
        return age;
    }
    //gender设置器
    public void setGender(char gender){
        this.gender = gender;
    }
    //gender获取器
    public char getGender(){
        return gender;
    }
    //成员方法
    public void live(){
        System.out.println(name+",年龄"+age+"性别"+gender);
    }
}
//学生方法调用Person类
public class Student {
    public static void main(String[] args) {
        Person st = new Person();

        Person st2 = new Person("韩梅梅",19,'女');
        st.setName("李雷雷");
        System.out.println(st.getName());
        st.setAge(18);
        System.out.println(st.getAge());
        st.setGender('男');
        System.out.println(st.getGender());
        st.live();
        st2.live();
    }
}

5.2javabean

javabean泛指一系列的类模板类。

标准的javabean规范：

类是公共的；
至少存在一个空构造；
属性私有化；
公共访问方式 setter getter；

6.继承

6.1目的

继承的目的是为了提高代码的复用性；

子类|派生类：继承父亲的类

父类|基类|超类：被继承的类

类：抽取对象的共性

父类：抽取子类的共性定义在父类中

6.2继承的实现

子类 extends 父类

特点：

子类一旦继承父类,就有权使用父类中的成员
子类中定义子类独有的内容
extends 孩子是夫妇的延续,也是扩展
一个父类可以存在多个子类
单继承机制,一个子类只能存在一个父类

单继承优点：简单；

单继承缺点：不够灵活，不便于程序的后期维护

面向对象设计原则之一：对修改关闭，对扩展开放

//父类
public class Animal {
    public String type;
    public int age;
    public char gender;

    private String name;
    public Animal(){}
    public Animal(String name){
        this.name = name;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }

    public void sleep(String name){
        System.out.println(name+"需要休息");
    }
}
//子类
public class Cat extends Animal {
    public String color;
    public void catchMouse(){
        System.out.println("猫会捉老鼠");
    }

}
//子类
public class Dog extends Animal{
    public String kind;

    public void bark(){
        System.out.println("狗拿耗子多管闲事");
    }
}
//测试类
public class AnimalTest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.type = "猫";
        cat.age= 2;
        cat.color="orange";
        cat.sleep("猫猫");
        cat.catchMouse();
        cat.setName("橘猫");
        System.out.println(cat.getName());

        System.out.println("=========");
        Dog dog = new Dog();
        dog.type = "狗";
        dog.age = 3;
        dog.gender = '公';
        dog.bark();
    }
}

6.3super关键字

super关键字和this关键字的区别：

this：

this指代对象，当前对象new；
构造器首行调用当前类中的其他构造器；
区分局部变量和成员变量；

super：

指代父类对象（子类内存中的父类对象）
在子类构造器首行调用父类构造器 super（实参）
如果没有显示调用父类的指定构造器，默认在子类构造器的首行调用父类的空构造 super()

需要注意的是：this()与super()在构造器的首行调用其他构造器时候不能同时存在。

super在区分子父类同名成员时：

默认就近原则；
指代父类的成员，需要通过父类对象调用父类成员 super；
如果不存在同名问题，当成员变量|方法找到父类成员，默认省略super,如果找到子类成员，默认省略this。

存在子父类继承的前提下：

创建子类对象：先父类后子类
先创建父类对象，再创建子类对象

//父类
public class Fath {
    String name = "fath";
    int age;

    public Fath(){
        age=20;
    }

    public Fath(int age){
        this.age = age;
        System.out.println("年龄"+this.age);
    }
}
//子类
public class Son extends Fath{
    String hobby;
    String name = "son";

    public Son(){
        super(10);
    }

    public Son(int age){

        super.age = age;
        System.out.println("引用父类的age"+super.age);
    }
}
//测试
public class Test {
    public static void main(String[] args) {
        Fath fath = new Son();
        System.out.println(fath.name);
        Fath fath2 = new Fath();
        System.out.println(fath2.name);
    }
}

7.final关键字

final可以修饰成员也可以修饰局部。

被final修饰的变量为常量
被final修饰的方法不能被重写
被final修饰的类不能被继承

值得注意的是：当final中修饰的为引用数据类型的数据，可以修改对象内存空间中的成员，不可以修改地址。

鸽了一路

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
static关键字、块、包机制、封装、继承、final关键字

1.srtatic关键字被static 关键字修饰的的内容为静态的内容。static不可以修饰局部变量，只能修饰成员变量。1.1静态变量static 成员变量——>静态变量|类变量成员是属于对象的，跟随对象使用，因为成员在对象的堆内存中，而static修饰的静态的内容是属于类的，可以跟随类使用。静态变量都是独一份的，不在对象的堆内存中，在静态区中,在类第一次加载完成之后就会初始化静态内容。1.2静态方法static 方法——>静态方法|类方法静态内容是当前这个类型所有
复制链接

扫一扫