static关键字、块、包机制、封装、继承、final关键字
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); //0System.out.println(staticTest02.age); //0staticTest02.change(); //id=1 age=0 //id=1 staticTest02.age=1System.out.println(StaticTest02.id); //1System.out.println(staticTest02.id); //1System.out.println(staticTest02.age); //age=0staticTest02.change(); //2 0 //2 1System.out.println(id); //2System.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); //6System.out.println("6、"+a); //10System.out.println("7、无参构造方法执行a=" + a); //10}public BlockTest02(int n) { //n= 6System.out.println("4、"+n); //6System.out.println("5、"+a);//10} public static void main(String[] args) {System.out.println(" 2、main"); //mainBlockTest02 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;}//设置器 namepublic void setName(String name){this.name = name;}//获取器 namepublic 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中修饰的为引用数据类型的数据,可以修改对象内存空间中的成员,不可以修改地址。
static关键字、块、包机制、封装、继承、final关键字相关推荐
- static关键字和块和包机制和继承super
static关键字 static:关键字静态的 被static关键字修饰的内容为静态内容 成员是属于对象的跟随对象使用,应为成员在对象的堆内存空间中,static修饰的静态的内容是属于类,可以随类使用 ...
- JavaSE学习笔记(七)—— 继承final关键字
一.继承 1.1 引入 首先我来写两个代码: class Student {String name;int age;public Student(){}//getXxx()/setXxx()publi ...
- final关键字_深入分析Java中的final关键字
Java中被final修饰的变量与普通变量有何区别?被final修饰的变量不可更改.被final修饰的方法不可重写是怎样做到的?带着疑问我们一点点拨开云雾. 一.final的内存定义及规则 对于fin ...
- 黑马程序员——static和final关键字
---------------------- android培训.java培训.期待与您交流! ---------------------- 一丶Static关键字 1.static是一个修饰符,用于 ...
- 详解Java中static关键字和final关键字的功能
摘要:static关键字和final关键字是Java语言的核心,深入理解他们的功能非常重要. 本文分享自华为云社区<Java: static关键字与final关键字>,原文作者:唐里 . ...
- 随笔② Java中的关键字 --- final关键字
一:final关键字 ① final变量:凡是对成员变量或者本地变量(在方法中的或者代码块中的变量称为本地变量)声明为final的都叫作final变量.final变量经常和static关键字一起使用, ...
- java中final关键字的使用
final 中文翻译为 最终的,在java中也是较为常用的关键字之一. 在java 中 final 关键字可以修饰 类.方法.变量 final 修饰在类上,则表示该类不能被继承,如果里面的成员变量没 ...
- 浅谈Java中的final关键字
浅析Java中的final关键字 谈到final关键字,想必很多人都不陌生,在使用匿名内部类的时候可能会经常用到final关键字.另外,Java中的String类就是一个final类,那么今天我们就来 ...
- 浅析Java中的final关键字
浅析Java中的final关键字 谈到final关键字,想必很多人都不陌生,在使用匿名内部类的时候可能会经常用到final关键字.另外,Java中的String类就是一个final类,那么今天我们就来 ...
- 深入理解Java中的final关键字
深入理解Java中的final关键字 http://www.importnew.com/7553.html Java中的final关键字非常重要,它可以应用于类.方法以及变量.这篇文章中我将带你看看什 ...
最新文章
- 【CV】Numpy|Python中矩阵和数组乘法及向量相关问题
- “黄背心”运动持续进行 马克龙发长信呼吁沟通
- 这几部高分学科纪录片,助力孩子涨姿势拓视野~
- 远控免杀专题(21)-HERCULES免杀
- java 内部变量_java 中的内置数据类型
- comptia a+_我如何通过CompTIA Linux +考试
- mybatis分页数据重复
- 我的第一款 Drone 插件
- java stream groupingBy
- IPXX防护等级中关于防水实验的规定
- Solidworks与Matlab联合仿真SimMechnics下载及安装
- BUG的跟踪管理、定位BUG
- Flash闪存的有关术语
- 计算机科学美国大学专业,最新!2019年USNews美国大学计算机专业排名
- iOS中WKWebView清除cookies
- 【c语言】数字金字塔
- 《学会提问》读书笔记
- 服务器心跳信号,服务器心跳线设置
- 基于MATLAB APP Designer 和 Python 的音视频剪辑App_02
- 北京市社会保险个人权益记录(参保人员缴费信息)-社保定制