成员变量:随对象的存在而存在,随对象的消失而消失。其值存储在对象实例中
静态变量:随类存在而存在,随类消失而消失。存储在静态区,经过方法访问改变静态变量值时,其值在静态区的值会改变。
局部变量:随方法而存在,方法在变量在。
变量使用就近原则,哪个近用哪个
this是什么:是每个对象中,保存自身内存地址的一个引用类型变量
*
* this就表示当前{对象}
*
* 能做什么:
*
* 1、在成员方法或者构造方法中,区分同名的成员变量和局部变量
*
* this.xxx
*
* 2、用在构造方法中,重载调用当前类中其他构造方法但是必须写在构造方法第一行
*
* this.(xxx)
*
* 3、return this 返回当前的对象的内存地址
*
* this最简单理解,谁调用就是指向谁的堆地址
*
* this 不能出现在静态方法中
public class This_01 {
static int a = 2;
int year;
int month;
int day;
public This_01() {
this(1999, 12, 24);// 这样调用必须在第一行
}
// 有参构造方法的使用
public This_01(int year, int month, int day) {
super();
this.year = year;
this.month = month;
this.day = day;
m();
}
public void m() {
//接收赋值过后的参数
System.out.println(year + "年" + month + "月" + day + "日");
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public int getDay() {
return day;
}
public void setDay(int day) {
this.day = day;
}
int d = 2;// 成员变量
public void m1() {
// 成员变量可以和局部变量同名
// 局部变量优先级更高
// 可以使用this区分同名的变量和局部变量
int c = 2;
System.out.println(c);
System.out.println(d);
int d = 3;
System.out.println(d);
System.out.println(this.d);
}
public static void m2() {
int a = 3;
int b = 4;
// 静态变量可以和局部变量同名
// 局部变量优先级更高
// 可以使用类名区分同名的静态变量和局部变量
System.out.println(a);
System.out.println(This_01.a);
System.out.println(b);
}
public static void main(String[] args) {
This_01 Date = new This_01();
This_01 Date1 = new This_01(2022, 1, 1);
System.out.println(Date1);
System.out.println(Date);
}
}
public static void main(String[] args) {
This_02 t = new This_02();
t.m1();
t.m2();
// 链式调用
t.m1().m2();
}
public This_02 m1() {
System.out.println("m1");
return this;//返回调用m1这个方法的对象的地址,简单来说就是,返回该 对象
}
public void m2() {
System.out.println("m2");
}
Static
* 1.静态变量,静态方法修饰符所修饰的都是和类一起加载在静态区。main方法之前
*
* 2.static修饰静态语句块,等价于静态方法
*
* 静态变量和静态语句块同等优先级
实例语句块:
* 可以看做成员方法,没有static修饰的语句块就是成员语句块
*
* 等价于成员方法,在创建对象时立刻执行
* 继承:就是在已有的类中派生出新的类,新的类能吸收已有的类的属性和行为
*
* java 中只支持单继承,不支持多继承,可以传递
*
* 代码复用提高效率,如果父类满足不了子类,可以复写可以使用多态
*
* 如果一个类没有显示继承,默认继承java.lang.Object
*
* 语法结构:修饰符 子类 extend 父类{类体}
super:代表了父类的特征
* 1.用在成员方法和构造方法中 区分父子类之间的同名的方法和变量
*
* super.xxx 使用父类时的前缀
*
* 2.在子类的构造方法中,调用指定的父类的构造方法
*
* super();
*
* super()和this()都必须在第一行,所以不能重复出现
public void m2(){
// 子类
m1();
// 子类
System.out.println(age);
// 父类
System.out.println(name);
// 父类
super.m1();
// 父类
System.out.println(super.age);
}
package包机制:
* 1.主要解决了命名冲突问题,在类名前加命名空间
*
* 2.完整的类名是带有包名的,包名类名才是这个类的名字
*
* 3.package语句必须出现在java源文件的第一行
*
* 4.package语句是规定编译之后的class文件保存的位置,和源文件无关
*
* 5.一把采用公司域名倒序
*
* 6.不在同包下,要用包名.类名调用
*
* 7.导包,import 导入其他包中的其他类。在package之下,class之上
*
* 8.java.lang,*:该包下为系统核心类不需要导包。*表示该包下所有类
public class FengZhuang_04 {
public static void main(String[] args) {
Date date = new Date();// 回车自动添加包
System.out.println(date);
//调用user包中的类
User_ us = new User_();
us.m();
}
}
访问控制符 同一类中 同包中 同一子类中 其他
* private 是 否 否 否
*
* default 是 是 否 否 (不写权限控制修饰符)
*
* protected 是 是 是
*
* public 否 是 是 是
覆写:写一个和父类一样的方法,但是功能不一样 父类无法满足子类需求
*
* 1.方法名 返回值 参数列表 和父类一致
* ‘
* 2.不能比原方法更低的访问权限
*
* 3.不能比原方法有更多的异常
*
* 只有成员方法可以覆写
public class FuXie_07 {
public static void main(String[] args) {
Dog dog = new Dog();
dog.eat();
dog.move();
}
}
class Animal {
public void eat() {
System.out.println("吃东西");
}
public void move() {
System.out.println("自驾走");
}
}
class Dog extends Animal {
@Override
// 源码注解,编译时判断是否为覆写方法,会报错,降低错误率
public void eat() {
System.out.println("狗吃鱼");
}
}