Java筑基(三)
- 一、final概念
- 1、案例1:采用继承:
- 2、案例2:final修饰的类不可以被继承:
- 3、案例3:final修饰的类不能有子类,但是可以有父类
- 4、final修饰构造方法
- 5、final修饰普通方法
- 6、final修饰变量
- 6.1、一般成员变量
- 6.2、静态成员变量
- 6.3、形参
- 6.4、局部变量
- 二、访问权限修饰符
- 1、本类中都可以访问
- 2、同一个包中private不支持访问
- 3、同一个包中的子类private不支持访问
- 4、不同包子类
- 5、不同包无关类
- 三、静态变量static
- 四、静态方法static
一、final概念
类:不可以继承
方法:不可被子类覆盖
变量:不可被重新赋值
final修饰的类不可以被继承。
final修饰的类不能有子类,但是可以有父类。
1、案例1:采用继承:
父类
public class Animal {
public void sleep(){
System.out.println("Dog ... sleep方法");
}
}
子类
public class Dog extends Animal {
public void sleep(){
System.out.println("Dog...sleep方法");
}
}
实例化子类
public class FinalTest {
public static void main(String[] args) {
Dog d=new Dog();
d.sleep();
}
}
输出结果:
Dog...sleep方法
2、案例2:final修饰的类不可以被继承:
public final class Animal {
public void sleep(){
System.out.println("Dog ... sleep方法");
}
}
public class Dog extends Animal {
public void sleep(){
System.out.println("Dog...sleep方法");
}
}
package com.company.finalp;
public class FinalTest {
public static void main(String[] args) {
Dog d=new Dog();
d.sleep();
}
}
产生报错
3、案例3:final修饰的类不能有子类,但是可以有父类
子类
package com.company.finalp;
public final class Animal extends One {
public void sleep(){
System.out.println("Dog ... sleep方法");
}
}
父类
package com.company.finalp;
public class One {
public void eat(){
System.out.println("eat...");
}
}
public class FinalTest {
public static void main(String[] args) {
Animal a = new Animal();
a.eat();
}
}
执行结果:
eat...
4、final修饰构造方法
final修饰构造方法会直接报错
final不能修饰构造方法
5、final修饰普通方法
public class Animal extends One {
public void sleep(){
System.out.println("Dog ... sleep方法");
}
public final void play(){
System.out.println("animal play...");
}
}
public class Dog extends Animal {
public void sleep(){
System.out.println("Dog...sleep方法");
}
}
public class FinalTest {
public static void main(String[] args) {
Dog d=new Dog();
d.sleep();
d.play();
}
}
Dog...sleep方法
animal play...
方法不想被重新实现,写的时候什么样,最后不管谁继承都是什么样,那就final修饰。
6、final修饰变量
修饰的变量是一个常量,只能被赋值一次。
可修饰的变量:
- 一般成员变量
- 静态成员变量
- 形参
- 局部变量
6.1、一般成员变量
直接赋值显示初始化
构造方法赋值初始化
public /*final*/ class Animal extends One {
//一般成员变量
//方法1
private String name="kobe";
private int sex=1;
//方法2
public Animal(String name,int sex){
name="kobe";
sex=1;
}
6.2、静态成员变量
直接赋值显示初始化
在static代码块赋值进行初始化
package com.company.finalp;
public /*final*/ class Animal extends One {
static final int MAX_AGE = 60;
static final int MIN_AGE;
static {
MIN_AGE=1;
}
}
package com.company.finalp;
public class FinalTest {
public static void main(String[] args) {
System.out.println(Animal.MAX_AGE);
System.out.println(Animal.MIN_AGE);
}
}
输出结果
60
1
6.3、形参
调用方法时,给形参赋值
package com.company.finalp;
public /*final*/ class Animal extends One {
public void sleep(int time){
System.out.println("睡觉"+time+"小时");
}
}
package com.company.finalp;
public class FinalTest {
public static void main(String[] args) {
Animal a =new Animal();
a.sleep(6);
}
}
睡觉6小时
6.4、局部变量
直接赋值显示初始化
调用时赋值
二、访问权限修饰符
/**
* 本类 本包 同包子类 不同包子类 不同包无关类
* private y
* 默认 y y y
* protected y y y y
* public y y y y y
*/
1、本类中都可以访问
私有方法、默认方法、受保护的方法、公共方法都可以被访问
public class Father {
private void show1(){
System.out.println("private show1");
}
void show2(){
System.out.println("默认 show2");
}
protected void show3(){
System.out.println("protected show3");
}
public void show4(){
System.out.println("public show4");
}
public static void main(String[] args) {
Father f=new Father();
//私有化
f.show1();
f.show2();
f.show3();
f.show4();
}
}
2、同一个包中private不支持访问
3、同一个包中的子类private不支持访问
4、不同包子类
受保护的方法、公共方法可以被访问
5、不同包无关类
公共方法可以被访问
三、静态变量static
作用:
- java中的static可以修饰类的成员
- static既可以修饰对应类里面的成员变量,也可以修饰类里面的方法。
- 被修饰的内容就不再属于这个对象了。而是属于这个类
- static修饰的成员变量叫静态变量,也叫类变量。
- static修饰的方法叫静态方法,也叫类方法。
无论有多少个对象,对应静态变量的属性值在内存空间中只存在一份。
静态变量存放在方法区
调用方式:类名.静态变量名
特点:
- 让一个类的所有实例都共享数据。
- 变量值存储在一个公共的内存地址。
static修饰的静态变量,被所有的实例变量都共享
package com.company.staticp;
public class TestEnginer {
//属性名
//名字
private String name;
//工作内容
private String work;
//部门
// static修饰的静态变量,被所有的实例变量都共享
static String department;
public void selfsay(){
System.out.println("我是"+department+"部门"+getWork());
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getWork() {
return work;
}
public void setWork(String work) {
this.work = work;
}
}
静态变量 变量值存在一个公共地址:方法区内,同一个类的所有的实例都可以去访问
public class TestEngineDemo {
public static void main(String[] args) {
TestEnginer testenger= new TestEnginer();
testenger.setName("kobe");
testenger.setWork("java测开");
TestEnginer.department="测试";
//类名.变量名
//静态变量 变量值存在一个公共地址:方法区内,同一个类的所有的实例都可以去访问
TestEnginer testenger1= new TestEnginer();
testenger1.setName("curry");
testenger1.setWork("python测开");
testenger.selfsay();
testenger1.selfsay();
}
}
注意:
随意修改static修饰的属性有风险,一般为了避免风险:final和static配合使用,即把静态变量变为常量
final + static 常量;常量变量名全部大写
package com.company.staticp;
public class TestEnginer {
//属性名
//名字
private String name;
//工作内容
private String work;
//部门
// static修饰的静态变量,被所有的实例变量都共享
// public static String department = "质量高级控制";
// final + static 常量
// 常量变量名全部大写
public final static String DEPARTMENT = "质量高级控制";
public void selfsay(){
System.out.println("我是"+DEPARTMENT+"部门"+getWork());
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getWork() {
return work;
}
public void setWork(String work) {
this.work = work;
}
}
实例对象无法调用静态变量
public class TestEngineDemo {
public static void main(String[] args) {
TestEnginer testenger= new TestEnginer();
testenger.setName("kobe");
testenger.setWork("java测开");
//类名.变量名
//静态变量 变量值存在一个公共地址:方法区内,同一个类的所有的实例都可以去访问
TestEnginer testenger1= new TestEnginer();
testenger1.setName("curry");
testenger1.setWork("python测开");
testenger.selfsay();
testenger1.selfsay();
}
}
输出结果
我是质量高级控制部门java测开
我是质量高级控制部门python测开
四、静态方法static
调用方式:类名.静态方法名(参数)
特点:
- 类不能调实例方法或者访问实例变量,因为静态方法中没有this关键字。
- 类可以调用静态方法及访问静态变量。
package com.company.staticp;
public class ReverseList {
int num1=15;
static int num2=25;
public void show(){
System.out.println(num1);
System.out.println(num2);
}
public static void show1(){
System.out.println(num2);
}
}
package com.company.staticp;
public class ReverseListDemo {
public static void main(String[] args) {
ReverseList r=new ReverseList();
r.show();
//静态方法调用格式
ReverseList.show1();
System.out.println(ReverseList.num2);
}
}