java基础9 main函数、this、static、super、final、instanceof 关键字

class Demo1 {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}

class Student{
int id; //身份证 (成员变量)
String name;//名字 (成员变量)
//目前情况:存在同名的局部变量和成员变量,在方面内部默认使用的局部变量的.
public Student(int id,String name){//局部变量
this.name = name;//把局部变量name的数据传给成员变量name
this.id = id;
}
}
class Demo8 {
public static void main(String[] args) {
Student s=new Student(12580,"王麻子");
System.out.println(s.id+"\t"+s.name);
}
}

class Student{
int id;
String name;
//目前情况:存在同名的局部变量和成员变量,在方面内部默认使用的局部变量的.
public Student(int id,String name){//全参构造器
this(name);//调用的是:含有参数name的构造器
this.name = name;
this.id = id;
}
//无参构造器
public Student(){ }
//含一个参数的构造器
public Student(String name){
this.name=name;//把局部变量给了成员变量name
}
}
class Demo8 {
public static void main(String[] args) {
Student s=new Student(250,"王麻子");
System.out.println(s.id);
}
}

class Student{
String name;
static String country="中国";
//静态方法(函数)
public static void study(){
System.out.println(country+"努力学习");
}
//有参构造器
public Student(String name){
this.name=name;
}
//无参构造器
public Student(){
}
//普通方法(函数)
public void eat(){
System.out.println(country+name+"努力学习");
}
}class Demo9 {
public static void main(String[] args) {
Student s=new Student("铁蛋");
s.eat();//用对象名调用
Student.study();//用类名直接调用
s.study(); Student s1=new Student();
s1.name = "狗娃";//用对象名调用
Student.name = "狗蛋";//用类名直接调用;此处报错,原因:成员变量name不是静态变量,静态方法不能直接用类名调用,要用对象名调用
System.out.println(s1.name+"\t"+Student.country); //Student.country:不报错的原因:因为country是静态成员变量,所以可以用类名调用
}
}

//例子：super和this关键字
1 class Fu{
int x=10;
String name; public Fu(){
System.out.println("父类无参构造器....");
}
public Fu(String name){
this.name=name; //把局部变量name的数据传给成员变量name
}
public void eat(){
System.out.println("小头爸爸吃番薯......."+name);
}
} class Zi extends Fu {
int x=20;
int num;
public Zi(){
System.out.println("这是子类无参构造器...");
}
public Zi(String name,int num){
super(name); //指定调用父类的一个参数的构造器
super.eat();//调用父类中的eat() 方法 } public void eat(){
System.out.println("大头儿子吃龙虾...."+super.x+"\t"+name); //和this关键字的用法相似，这里（super.x）调用的是父类中的成员变量x，返回结果：10；去掉super关键字，返回结果：20 (就近原则)
}
}
class Demo7{
public static void main(String[] args) {
Zi z=new Zi("二狗子",2);
z.eat(); //这里调用的是子类的eat()方法
}
}

//需求,定义一个函数可以接收任意类型的动物对象,在函数的内部要调用到动物特有的方法
//instanceof
public static void print(Animal a){ //相当于：Animal a=new Fish();
if(a instanceof Fish){
Fish f=(Fish)a;
f.bubble();
}else if(a instanceof Mouse){
Mouse m=(Mouse)a;
m.dig();
}else{
System.out.println("输入错误");
}
}

//动物类
abstract class Animal{
String name;
public Animal(String name){
this.name=name;
} public abstract void run(); //抽象方法
}
//老鼠类
class Mouse extends Animal{
public Mouse(String name){
super(name);
}
public void run(){
System.out.println(name+"四条腿慢慢走");
} public void dig(){
System.out.println(name+"老打洞..."); }
}
//鱼类
class Fish extends Animal{
public Fish(String name){
super(name);
}
public void run(){
System.out.println(name+"摇着尾巴游啊游...");
}
public void bubble(){
System.out.println(name+"吹泡泡....");
}
} class Demo6 {
public static void main(String[] args) {
Animal a=new Mouse("米老鼠");//多态,父类的引用指向子类的对象
a.run();
//a.dig();报错
//调用
Mouse m=(Mouse)a;//强制类型转换
m.dig(); //如果直接用a.dig()的话，会报错，因为是多态(父类中没有dig()方法)，所以要强制转换类型 Animal a1=new Fish("金枪鱼");
Fish f=(Fish)a1;
print(f);
} //需求,定义一个函数可以接收任意类型的动物对象,在函数的内部要调用到动物特有的方法
//instanceof
public static void print(Animal a){ //相当于：Animal a=new Fish();
if(a instanceof Fish){
Fish f=(Fish)a;
f.bubble();
}else if(a instanceof Mouse){
Mouse m=(Mouse)a;
m.dig();
}else{
System.out.println("输入错误");
}
}
}