13-01 final关键字
- 继承的出现提高了代码的复用性，并方便开发。但随之也有问题，有些类在描述完之后，不想被继承，或者有些类中的部分方法功能是固定的，不想让子类重写。需要使用到一个关键字final，final的意思为最终，不可变。
- final是个修饰符，它可以用来修饰类，类的成员，以及局部变量。
- final类是最终类，不能有子类，不可以被继承，但是可以继承其他类，且使用方式没有变化，可以正常的创建对象，调用方法。
13-02 final修饰方法
- final修饰的方法不可以被覆盖,但父类中没有被final修饰方法，子类覆盖后可以加final。
13-03 final修饰局部变量
- 修饰基本数据类型变量：final修饰的变量称为常量，这些变量只能赋值一次
- 修饰引用数据类型：引用类型的变量值为对象地址值，地址值不能更改，但是地址内的对象属性值可以修改
- 如：
final Person p = new Person();
Person p2 = new Person();
p = p2; //final修饰的变量p，所记录的地址值不能改变
p.name = “小明”;//可以更改p对象中name属性值，p不能为别的对象，而p对象中的name或age属性值可更改。
13-04 final修饰成员变量
- 修饰成员变量，需要在创建对象前赋值，否则报错。
- 当没有显式赋值时，多个构造方法的均需要为其赋值。
13-05 static的概念
-
当在调用对象的某个方法时，这个方法没有访问到对象的特有数据时，方法创建这个对象有些多余。可是不创建对象，方法又调用不了，这时我们可以通过static关键字来实现，不创建对象，就可以调用方法呢？
-
static它是静态修饰符，一般用来修饰类中的成员。
-
static的共享数据
-
被static修饰的成员变量属于类，不属于这个类的某个对象。也就是说，多个对象在访问或修改static修饰的成员变量时，其中一个对象将static成员变量值进行了修改，其他对象中的static成员变量值跟着改变，即多个对象共享同一个static成员变量
-
非static修饰的数据为对象的特有数据, 调用者只能是 new 对象，有static修饰的数据为对象的共享数据调用者可以是new 对象,可以是类名
13-06 static的内存图
13-07 static注意事项
- 在静态中不能调用非静态，因为生命周期问题，静态优先于非静态存在于内存中
- 静态不能写this,不能写super理由同上
13-08 static的使用场景
- 定义事物的时候,多个事物之间是否有共性的数据，若有，将共性的数据定义为静态的成员变量
- 如果方法,没有调用过非静态成员,将方法定义为静态
- 若方法中的语句用到的全部都是静态成员，则将方法定义为静态
- 例子
public class Student {
private static String name;
private static int age ;
private char sex;
public static void function(){
System.out.println(name+age);
}
public static int getSum(int a,int b,int c){
return a+b+c;
}
}
13-09 对象中的静态调用
- 在多态中，非静态编译看父类，运行看子类，父类没有编译失败。
- 但多态中的静态方法,编译看父类,运行仍然看父类。因为静态和对象没有关系，属于静态绑定。
13-10 定义静态常量
- 开发中，我们想在类中定义一个静态常量，通常使用public static final修饰的变量来完成定义。此时变量名用全部大写，多个单词使用下划线连接。
- 定义格式：
public static final 数据类型 变量名 = 值; - 如： public static final String COMPANY_NAME = “传智播客”;
- 当我们想使用类的静态成员时，不需要创建对象，直接使用类名来访问即可。
- 接口中的每个成员变量都默认使用public static final修饰。所有接口中的成员变量已是静态常量，由于接口没有构造方法，所以必须显示赋值。可以直接用接口名访问。
13-11 匿名对象
- 匿名对象是指创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。
- 例子：创建一个普通对象：Person p = new Person();
创建一个匿名对象：new Person(); - 匿名对象的特点：
a:创建匿名对象直接使用，没有变量名。
new Person().eat() //eat方法被一个没有名字的Person对象调用了。
b:匿名对象在没有指定其引用变量时，只能使用一次。
new Person().eat(); 创建一个匿名对象，调用eat方法
new Person().eat(); 想再次调用eat方法，重新创建了一个匿名对象
c:匿名对象可以作为方法接收的参数、方法返回值使用
public class Test {
public static void main(String[] args) {
method(new Person());
}
public static Person method(){
//匿名对象作为方法返回值
return new Person();
}
//调用方法method,传递Person类型对象
public static void method(Person p){
p.eat();
}
}
13-12 内部类
- 将类写在其他类的内部，可以写在其他类的成员位置和局部位置，这时写在其他类内部的类就称为内部类。其他类也称为外部类。
- 在描述事物时，若一个事物内部还包含其他可能包含的事物，比如在描述汽车时，汽车中还包含这发动机，
这时发动机就可以使用内部类来描述。
class 汽车 { //外部类
class 发动机 { //内部类
}
} - 成员内部类的调用格式：成员内部类，定义在外部类中的成员位置。与类中的成员变量相似，可通过外部类对象进行访问
- 定义格式
class 外部类 {
修饰符 class 内部类 {
//其他代码
}
}
public class Outer {
private int a = 1;
//外部类成员位置,定义内部类
class Inner{
public void inner(){
System.out.println("内部类方法inner "+a);
}
}
}
- 访问方式
外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
public class Test {
public static void main(String[] args) {
/*
* 调用外部类中的内部类的方法inner()
* 依靠外部类对象,找到内部类,通过内部类对象,调用内部类的方法
*/
Outer.Inner in = new Outer().new Inner();
in.inner();
}
}
13-13 成员内部类的同名变量调用
public class Outer {
int i = 1;
class Inner{
int i = 2;
public void inner(){
int i = 3;
System.out.println(i);//1
System.out.println(this.i);//2
System.out.println(Outer.this.i);//3
}
}
}
public class Test {
public static void main(String[] args) {
Outer.Inner in = new Outer().new Inner();
in.inner();
}
}
13-14 局部内部类
- 局部内部类，定义在外部类方法中的局部位置。与访问方法中的局部变量相似，可通过调用方法进行访问.
- 格式
class 外部类 {
修饰符 返回值类型 方法名(参数) {
class 内部类 {
//其他代码
}
}
}
//局部内部类
//将一个类,定义在方法中
public class Outer {
public void out(){
class Inner {
public void inner(){
System.out.println("局部内部类方法");
}
}
Inner in = new Inner();
in.inner();
}
}
public class Test {
public static void main(String[] args) {
//调用局部内部类的方法inner
new Outer().out();
}
}
13-15 匿名内部类
- 最常用到的内部类就是匿名内部类，它是局部内部类的一种。
- 定义的匿名内部类有两个含义：
临时定义某一指定类型的子类
定义后即刻创建刚刚定义的这个子类的对象 - 本质: 匿名内部类的本质是一个实现了接口或继承了某个类的子类匿名对象.
- 匿名内部类,定义实现类,重写方法,创建实现类对象,合为一步完成
- 格式:
new 接口或者父类(){
重写抽象方法
}; - 例子：
public interface Smoking {
public abstract void smoking();
public abstract void seelp();
}
//一般情况，实现类,实现接口 重写接口抽象方法
public class XXX implements Smoking {
public void smoking() {
System.out.println("在吸烟");
}
public void seelp() {
System.out.println("在睡觉");
}
}
public class Test {
public static void main(String[] args) {
//使用匿名内部类
Smoking a =new Smoking(){
public void smoking() {
System.out.println("人在吸烟");
}
public void seelp() {
System.out.println("人在睡觉");
}
};
a.smoking();
a.seelp();
//一般情况,创建实现类对象
XXX x =new XXX();
x.smoking();
x.seelp();
Smoking s = new XXX();
s.smoking();
s.seelp();
}
}
13-16 包
- java的包，其实就是我们电脑系统中的文件夹，包里存放的是类文件。
- 当类文件很多的时候，通常我们会采用多个包进行存放管理他们，这种方式称为分包管理。
- 在项目中，我们将相同功能的类放到一个包中，方便管理。并且日常项目的分工也是以包作为边界。
4.声明格式：通常使用公司网址反写，可以有多层包，包名采用全部小写字母，多层包之间用”.”连接 - 声明包的语句，必须写在程序有效代码的第一行（注释不算）
- 在访问类时，为了能够找到该类，必须使用含有包名的类全名（包名.包名.、、、.类名）。
- 导包的格式：
import 包名.类名;
13-17 权限修饰符
public protected default private
同一类中 √ √ √ √
同一包中(子类与无关类) √ √ √
不同包的子类 √ √
不同包中的无关类 √
- 要想仅能在本类中访问使用private修饰；
要想本包中的类都可以访问不加修饰符即可；
要想本包中的类与其他包中的子类可以访问使用protected修饰
要想所有包中的所有类都可以访问使用public修饰。 - 如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。
13-18 代码块
- 概述: 程序中用大括号括起来的代码叫代码块
- 分类: 局部代码块 构造代码块 静态代码块 同步代码块
- 局部代码块: 局部代码块是定义在方法或语句中,以”{}”划定的代码区域，可以限定变量的声明周期.
class Demo{
public static void main(String[] args) {
{
int x = 1;
System.out.println("普通代码块" + x);
}
int x = 99;
System.out.println("代码块之外" + x);
}
}
- 构造代码块: 构造代码块是定义在类中成员位置的代码块,优先于构造方法执行，构造代码块用于执行所有对象均需要的初始化动作,每创建一个对象均会执行一次构造代码块。
- 静态代码块: 静态代码块是定义在成员位置，使用static修饰的代码块。优先于主方法、构造代码块执行，当以任意形式第一次使用到该类时执行。该类不管创建多少对象，静态代码块只执行一次。
/*
* 静态代码块, 只执行一次
* 构造代码块,new一次,就执行一次,优先于构造方法
* 构造方法, new 一次,就执行一次
*/
public class Person {
private String name;
private int age;
public Person(String name,int age){
this.age = age;
this.name = name;
System.out.println("我是构造方法");
}
//构造代码块
{
System.out.println("我是构造代码块");
}
//静态代码块
static{
System.out.println("我是静态代码块");
}
}
public class Test {
public static void main(String[] args) {
new Person("张三",20);
new Person("张三2",220);
}
}
我是静态代码块
我是构造代码块
我是构造方法
我是构造代码块
我是构造方法
6.同步代码块(多线程学习)
801
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
