直到今天感觉号彷徨啊,感觉每天一直在看视频,然后练习也没有跟上,好好学吧,好纠结。
final关键字
- final关键字代表最终的,不可改变的
- 常见四种用法:
- 1.可以用来修饰一个类
- 2.可以用来修饰一个方法
- 3.还可以用来修饰一个局部变量
- 4.还可以用来修饰一个成员变量
public class Demo01Final {
public static void main(String[] args) {
int num1 = 10;
System.out.println(num1);
num1 = 20;
System.out.println(num1);
//一次赋值,终生不变
final int num2 = 200;
System.out.println(num2);
// num2=200;
// 只要保证有位移一次赋值
final int num3;
num3 = 30;
// 对于基本类型来说,不可变说的是变量当中的数值
// 对于引用类型来说,不可变的是变量当中的地址值
Student stu1 = new Student("赵丽颖");
System.out.println(stu1);
System.out.println(stu1.getName());
stu1 = new Student("霍建华");
System.out.println(stu1);
System.out.println(stu1.getName());
final Student stu2 = new Student("高圆圆");
stu2.setName("卢本伟");
System.out.println(stu2.getName());
Person person = new Person();
System.out.println(person.getName());
}
}
*当final关键字用来修饰一个方法的时候,这个方法就是最终方法,不能被覆盖重写
- 格式:
- 修饰符 final 返回值类型 方法名称(参数列表){
- //方法体
- }
*注意事项:
- 对于类,方法来说,abstract关键字和final关键字不能同时使用,因为矛盾
public class Fu {
public final void method() {
System.out.println("父类方法");
}
}
当final关键字用来修饰一个类的时候,格式:
- public final class 类名称{
- }
- 含义:当前这个类不能含有任何的子类。(太监类)
public class Myclass extends Object {
public void method() {
System.out.println("方法执行!");
}
}
对于成员变量来说,如果使用了final关键字修饰,那么这个变量也同样是不可变的
1.由于成员变量有默认值,所以final之后必须手动赋值,不会再给默认值了。
2.对于final的成员变量,要么使用直接赋值,要么通过构造方法赋值,二者选一。
3.必须保证类当中的所有重载方法,都会对final的成员变量进行赋值;
public class Person {
private final String name/*="鹿晗"*/;
public String getName() {
return name;
}
public Person() {
name = "关晓彤";
}
public Person(String name) {
this.name = name;
}
}
权限修饰符
*java中有四种权限修饰符
public >protected > (default) > private
- 同一个类 yes yes yes yes
- 同一个包 yes yes yes no
- 不同包子类 yes yes no no
- 不同包非子类 yes no no no
public class anotherMethod {
public void MyAnoyther() {
System.out.println(new MyClass().num);
}
}
public class MyClass {
public int num = 10;
public void method() {
System.out.println(num);
}
}
public class Myson extends MyClass {
public void methodSon(){
System.out.println(super.num);
}
}
public class Stranger {
public void method() {
System.out.println(new MyClass().num);
}
}
内部类
- 如果一个事物的内部包含另一个事物,那么就是着一个类内部包含另一个类
- 例如:身体和心脏。又如,汽车和发动机的关系。
- 分类:
- 1.成员内部类
- 2.局部内部类(包含匿名类)
- 成员内部类的定义格式
- 修饰符 class 外部类名称{
- 修饰符 class 内部类名称{
- //…
- }
- //…
- }
- 注意:内用外,随意访问
- 外用内,一定需要借助内部类对象
*==========================
- 如何使用成员内部类?两种方法
- 1.间接方式:在外部类的方法中,使用内部类,然后main只是调用外部类
- 2.直接方式:公式
- 类名称 对象名=new 类名称();
- 外部类名称.内部类名称 对象名=new 外部类名称().new 内部类名称();
public class Outer {
int num = 10;
public class Inner {
int num = 20;
public void methodInner() {
int num = 30;
System.out.println(num);
System.out.println(Outer.this.num); //外部类的成员变量
}
}
}
public class Body { //外部类
private String name;
public class Heart { //成员内部类
public void beat() {
System.out.println("心脏跳动,嘣嘣嘣!");
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Body(String name) {
this.name = name;
}
public Body() {
}
public void methodDody() {
System.out.println("外部类的方法");
new Heart().beat();
}
}
public class Demo01InerClass {
public static void main(String[] args) {
Body body = new Body();
//通过外部类的对象,调用外部类的方法,里面简洁实用Heart
body.methodDody();
Body.Heart heart = new Body().new Heart();
heart.beat();
}
}
public class Demo02InnerClass {
public static void main(String[] args) {
Outer.Inner obj = new Outer().new Inner();
obj.methodInner();
}
}
局部内部类:如果希望访问所在方法的局部变量,那么这个局部变量必须是有效final的
备注:从java 8+开始,只要局部变量事视不变,那么final关键字可以省略不写
原因:
1.new出来的东西在堆内存中。
2.局部变量是跟着方法走的,在栈内存中
3.方法运行结束后,立刻出栈,局部变量会消失
4.但是new出来的对象会持续存在,直到垃圾回收消失
*如果一个类是定义在 一个方法内部的,那么这就是一个局部内部类。
- 局部:只有当前所属的方法才能使用它,出了这个方法就不能用了
- 定义格式:
- 修饰符 class 外部类名称{
- 修饰符 class 外部类名称 外部类方法名称(参数列表){
-
class 局部内部类名称{
-
//...
-
}
- }
- }
- 小节以下类的权限修饰符:
- public> protected >(default) >private
- 定义一个类的时候,权限修饰符规则
- 1.public/(default):外部类
- 2.成员内部类 public/protected/(default)/private
- 3.局部内部类 什么都不能写
public class MyOuter {
public void methodOuter(){
int num=10; //局部变量
class MyInner{
public void methodInner(){
System.out.println(num);
}
}
}
}
class Outer {
public void methodOuter() {
class Inner { //局部内部类
int num = 10;
public void methodInner() {
System.out.println(num); //10
}
}
Inner inner = new Inner();
inner.methodInner();
}
}
public class DemoMain {
public static void main(String[] args) {
Outer obj = new Outer();
obj.methodOuter();
}
}
如果接口的实现类(或者是父类的子类)中需要使用唯一的一次:
那么这种情况下就可以省略掉该类的定义,而改用【匿名内部类】
匿名内部类的定义格式:
接口名称 对象名=new 接口名称(){
//覆盖重写
};
对格式进行解析:“new” 接口名称(){…}进行解析
1.new代表创建对象的动作。
2.接口类型就是匿名内部类需要实现的哪个接口
3.{…}这才是匿名内部类的内容
另外还需注意几点问题:
1.匿名内部类,在创建对象的时候,只能使用一次。
如果希望多次创建对象,而且类的内容一样的花,那么就必须要单独定义的重复类了
2.匿名对象,在调用方法的时候,只能调用唯一一次
如果希望同一个对象多次调用,必须有名字。
3.匿名内部类是省略了【实现类/子类名称】,但是匿名内部类省略了【对象名称】
强调:匿名内部类和匿名对象不是一回事!!!
public interface MyInterface {
void method1(); //抽象方法
void method2();
}
public class MyInterfaceImol implements MyInterface {
@Override
public void method1() {
System.out.println("实现重写了方法");
}
@Override
public void method2() {
System.out.println("实现重写了方法");
}
}
public class DemoMain {
public static void main(String[] args) {
// MyInterface impl=new MyInterfaceImol();
// impl.method();
//匿名内部类
MyInterface obj = new MyInterface() {
@Override
public void method2() {
System.out.println("匿名内部类实现2222");
}
@Override
public void method1() {
System.out.println("匿名内部类实现方法1111");
}
};
obj.method1();
obj.method2();
}
}
class作为成员变量
public class Hero {
private String name;
private Weapoon weapoon;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Weapoon getWeapoon() {
return weapoon;
}
public void setWeapoon(Weapoon weapoon) {
this.weapoon = weapoon;
}
public int getAge() {
return age;
}
public void attack() {
System.out.println("年龄为" + age + "的" + name + "用" + weapoon.getCode() + "攻击德玛西亚之力");
}
public void setAge(int age) {
this.age = age;
}
public Hero(String name, Weapoon weapoon, int age) {
this.name = name;
this.weapoon = weapoon;
this.age = age;
}
public Hero() {
}
}
public class Weapoon {
private String code;
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public Weapoon() {
}
public Weapoon(String code) {
this.code = code;
}
}
public class DemoMain {
public static void main(String[] args) {
Hero hero = new Hero();
hero.setName("压缩");
;
hero.setAge(20);
//创建武器对象
Weapoon weapoon = new Weapoon("AK-47");
//
hero.setWeapoon(weapoon);
hero.attack();
}
}
接口作为成员变量
public interface Skill {
void use(); //抽象方法
}
public class Skillimpl implements Skill {
@Override
public void use() {
System.out.println("Biu~biu~Biu~");
}
}
public class Hero {
private String name;
private Skill skill;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void attack() {
System.out.println("我叫" + name + "开始释放技能:");
skill.use();
System.out.println("技能释放完成");
}
public Skill getSkill() {
return skill;
}
public void setSkill(Skill skill) {
this.skill = skill;
}
public Hero(String name, Skill skill) {
this.name = name;
this.skill = skill;
}
public Hero() {
}
}
public class DemoInterface {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
List<String> result = addNames(list);
for (int i = 0; i < result.size(); i++) {
System.out.println(result.get(i));
}
}
public static List<String> addNames(List<String> list) {
list.add("迪丽热巴");
list.add("古力娜扎");
list.add("马儿扎哈");
list.add("沙扬娜拉");
return list;
}
}
public class DemoGame {
public static void main(String[] args) {
Hero hero = new Hero();
hero.setName("艾希");
//设置技能
/*Skill skill=*/
hero.setSkill(/*new Skillimpl()*/new Skill() {
@Override
public void use() {
System.out.println("pia~pia~pia~");
}
});
hero.attack();
}
}