this关键字
使用this使用的变量时属性，没有使用的是形参
this可以调用结构，成员变量，方法
this的理解，当前对象（在方法中调用时），或 当前正在创建的对象（在构造器中调用时）
针对方法内的使用情况
一般情况下，我们通过对想a调用方法，可以在方法内调用当前对象a的属性或其他的方法，此时，我们可以在属性和方法前使用this.表示当前属性或方法所属的对象a，但是一般情况下，我们为您都可以省略this.
代码如下:
public class personTest {
public static void main(String[] args) {
person p1 = new person("SDJ",'男');
p1.setage(18);
System.out.println(p1.age);
person p2 = new person(14,'男');
System.out.println(p2.age);
}
}
class person{
String name;
int age;
char gender;
public person(String name,char gender ) {
this.name = name;
this.gender = gender;
}
public person(int age,char gender) {
this.age = age;
this.gender = gender;
}
public void setage( int age) {
this.age = age;
}
public int getage() {
return this.age;//其中的this.可以省略不写
}
public void eat(){
System.out.println("吃饭");
this.sleep();//this调用方法
}
public void sleep(){
System.out.println("睡觉");
}
}this调用构造器
格式：this（形参列表）;
注意：必须声明在当前构造器的首行（所以在一个构造器中只能声明一个构造器）
代码如下;
public class UserTest {
public static void main(String[] args) {
User u1 = new User("name",10);//只创建了一个对象
}
}
class User {
String name;
int age;
public User() {
//模拟对象创建时，需要初始化50行代码
}
public User( String name) {
this();//调用前面的构造器
this.name = name;
}
public User( String name, int age) {
this(name);//调用前面的构造器
this.age = age;
}
}
继承性
继承的理解：
1.自上而下：定义一个类A，在定义另一个类B时，发现类B的功能与类A相似，考虑类B继承与类A
2.自上而下; 定义了类B，C , D有相似的属性和方法，可以考虑将相同的属性和方法进行抽取，封装到类A中，让类B , C , D继承与类A，同时，B , C , D中相似的功能就可以删除了。
继承性的格式
格式
class A{
//属性，方法
}
class B extends A{
}
继承性的基本概念
类A : 父类 , superClass , 超类，基类
类B：子类，subClass,派生类
方法的重写
1.为什么要需要方法的重写？
子类在继承父类以后，就获取了父类中声明的所有方法，但是父类中的方法可能不太适合与子类，换句话来说，子类需要对父类中继承过来的方法覆盖，覆写的操作。
2.何为方法的重写？
对子类继承过来的方法进行覆盖，覆写的操作，就成为方法的重写
举例：
class Account{//账户
double balance;、
//取钱
public void withdraw(double amt){
//判断balance余额是否够amt取钱的额度
}
}
class ChackAcount extends Account{
double protectedBy;//透支额度
public void withdraw(double amt){
//判断balance余额是否够amt取钱的额度
//如果不够，还可以考虑从prtectedBy额度里取钱
}
}
class AccountTest{
public ststic void main(String[] args){
CheckAccount acct = new CheckAccount
acct.withdraw();//执行的是子类重写父类的方法
}
}
具体规则
一.父类被重写的方法与子类重写的方法名和形参列表必须相同
二.子类重写的方法的权限修饰符不小于父类被重写的权限修饰符
>子类不能重写父类 中声明为private权限修饰的方法
三.关于返回值类型：
>父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型必须是void
>父类被重写的方法的返回值类型是基本数据类型，则子类重写的方法的返回值类型必须与被重 写的返回值类型相同
>父类被重写的方法的返回值类型是引用数据类型（如类），则子类重写的方法的返回值类型可以与被重写的方法相同，或是被重写方法的子类
super
代码如下：Person类
public class Person {
//父类构造器
public Person() {
System.out.println("Person constructor");
}
public Person(String name, int age) {
this.name = name;
this.age = age;
System.out.println(name+" "+age);
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//属性
String name = "beida";
private int age;
int id = 101;//身份证号
//方法
public void eat(){
System.out.println("人吃饭");
}
public void sleep(){
System.out.println("人睡觉");
}
public void doSport(){
System.out.println("人运动");
}
}
Student类：
public class Student extends Person {
//String name = "qinghua";
int id = 102;//学号
public void eat(){
System.out.println("学生要好好吃饭");
}
public void sleep(){
System.out.println("睡觉要好");
}
public void show(){
eat();
super.eat();
}
public void show1(){
doSport();
this.doSport();
super.doSport();
}
public void show2(){
System.out.println(id);//就近id为102,相当于this.
System.out.println(super.id);//101
}
public void show3(){
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
//子类构造器调用父类构造器
public Student(){
super();
System.out.println("Student constructor");
}
public Student(String name,int age){
//setAge(age);//这样也可以使用父类中的get，set方法进行给父类赋值
//super.name = name;
super(name,age);//直接用构造器给父类的属性赋值
}
}
StudentTest类：
public class StudentTest {
public static void main(String[] args) {
Student s1 = new Student();
s1.eat();
s1.sleep();
s1.show();
s1.show2();
s1.show3();
System.out.println(s1.name);//直接调用了服了的属性
//测试子类调用父类u构造器
Student s2 = new Student();
Student s3 = new Student("tom",23);
}
}子类实例化的全过程
1.从总结果的角度来看，体现为继承性
当我i们创建子类对象后，子类对象就获取了器父类中声明的所有属性和方法，在权限允许的情况下，可以直接调用
2.从过程角度来看
当我们通过子类的构造器创建对象时，子类的构造器一定会直接或间接的调用到其父类的构造器，而其父类的构造器同样会直接或间接的调用但其父类的构造器，.......直到调用了Odject类的构造器为止。
正因为我们调用过子类所有父类的构造器，所以我们就会将父类中声明的属性，方法加载到内存中，供子类对象使用。
在创建子类对象的过程中，一定会调用父类中的构造器
在创建子类对象的时候，内存中只有一个对象（因为只new了一个对象）
标签：Java,进阶,子类,age,面向对象,void,父类,public,name From： https://blog.csdn.net/2401_87232884/article/details/143465297