标签：数据 class 不同 接口 static abstract ali 静态代码块 protected
是用于修饰 类、方法、局部变量、成员变量
public final class Person
特点：被final 修饰的类不能够被继承
格式：
修饰符 final 返回值类型 方法名(参数){
? 方法体
? 返回值
}
特点：被final修饰的方法不能够被重写
public class Animal{
public final void eat(){//被final 修饰的方法不能够被重写
system.out.println("动物要吃饭");
}
}
格式
final 数据类型 变量名=值
特点： 被final修饰的局部变量一旦被初始化，那么不能被二次赋值
格式
final 类名 对象名=new 类名();
特点：
被final修饰的对象名，地址值不能改变，但是对象中的属性可以改变
public class Var_Test02{
public static void main(String[] args){
Person p=new Person("岳"，36);//给p分配的是地址值
system.out.println(p);
p=new Person("涛"，28);//重新附地址值给对象
//final修饰对象
final Person p1=new Person("岳"，36);//给p1分配的是地址值
system.out.println(p1);
//p1=new Person("涛"，28);//此时不能给final 修饰的对象重新赋给地址值
//但是可以给final修饰的对象改变属性
p1.setName("涛");
}
}
格式：
final 数据类型 变量名
特点：被final修饰的成员变量不能被二次赋值
public>protected>default>private
| public | protected | default | private | |
|---|---|---|---|---|
| 同类 | Y | Y | Y | Y |
| 同包不同类 | Y | Y | Y | N |
| 不同包子类 | Y | Y | N | N |
| 不同包非子类 | Y | N | N | N |
1.被static 修饰的成员可以作为共享对象(根据这个static所在的类创建出来的对象，都可以共享这static的成员)
2.被static 的修饰的成员，属于类而不属于对象，所以我们在调用static 修饰的成员的时候，就不用new对象，直接类名调用
3.static 修饰的成员在进入内存的时候，会优先于对象
public class Student {
String name;
int age;
static String classRoom;
public Student() {
}
public Student(String name, int age, String classRoom) {
this.name = name;
this.age = age;
this.classRoom = classRoom;
}
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 getClassRoom() {
return classRoom;
}
public void setClassRoom(String classRoom) {
this.classRoom = classRoom;
}
}
/*
static:
1.被static修饰的成员属于类 ,不属于对象
2.被static修饰的成员优先于对象存在的
3.被static修饰的成员可以作为共享数据(根据static所在的类创建出来的对象都可以共享这个static的成员)
*/
public class Test {
public static void main(String[] args) {
Student.classRoom = "金燕龙202";//类名直接调用static修饰的成员
Student student = new Student();
student.setName("老顽童");
student.setAge(80);
/* student.setClassRoom("201教室");*/
System.out.println(student.getName());
System.out.println(student.getAge());
//System.out.println(Student.classRoom);
System.out.println(Student.classRoom);
Student student1 = new Student();
student1.setName("杨过");
student1.setAge(18);
//student1.setClassRoom("201教室");
System.out.println(student1.getName());
System.out.println(student1.getAge());
//System.out.println(Student.classRoom);
System.out.println(student1.getClassRoom());
}
}
方法方式：
1.new 对象后，对象调用
2.类名直接调用--->推荐使用
访问静态方法的特点:
1.静态的不能直接访问非静态的：静态的属于类，而非静态的属于方法，即静态的优先于对象的。如果要访问非静态的，要在静态方法中先创建对象在通过对象调用
2.静态能访问静态的：
同类中：可以直接调用静态方法；或者创建对象调用
非同类中：创建对象调用，或者类名直接调用
3.非静态的可以调用静态的：
只要是静态的访问非静态的就要new对象调用
只要是访问静态的：类名直接调用
static {
? 代码
}
注意：静态代码块优先于构造方法执行；且静态代码块只执行一次
使用场景：
当我们初始化变量的时候，只要求我们初始化一次来供后面使用时，可以使用静态代码块
类中有类
格式：
Class A{
? Class B{
? }
}
注意：内部类可以直接使用外部类的成员；但是外部类不可以直接使用内部类的成员
public class Person {
int num = 10;
//内部类
class Heart{
int i = 20;
public void method(){
System.out.println("我是内部类的method方法");
eat();
System.out.println(num);
}
}
public void eat(){
//System.out.println(i);
System.out.println("人要吃饭");
// method();外部类不可以直接使用内部类的成员
}
}
访问内部类：
1.先创建外部类的对象
2.根据外部类的对象去创建内部类的对象
3.调用内部类的成员
? 格式:
? 外部类名.内部类名 对象名 = new 外部类型().new 内部类型()
/*
1.先创建外部类的对象
2.根据外部类的对象去创建内部类的对象
3.调用内部类的成员
格式:
外部类名.内部类名 对象名 = new 外部类型().new 内部类型()
*/
public class Test {
public static void main(String[] args) {
/*Person person = new Person();
System.out.println(person.num);*/
Person.Heart heart = new Person().new Heart();
heart.method();
System.out.println(heart.i);
}
}
匿名内部类：
格式：
new 父类/接口(){
? 重写的方法
}.重写的方法
public abstract class Animal {
public abstract void eat();
}
public class Test {
public static void main(String[] args) {
new Animal(){
@Override
public void eat() {
System.out.println("人要吃饭");
}
}.eat();
System.out.println("---------------");
Animal animal = new Animal() {
@Override
public void eat() {
System.out.println("人吃肉");
}
};
animal.eat();
}
}
使用场景：如果一个抽象类或者一个接口中调用一次，我们就没有必要去单独创建子类，一般用于抽象类和接口
标签：数据 class 不同 接口 static abstract ali 静态代码块 protected
原文地址：https://www.cnblogs.com/dingxiang2020/p/13148746.html
