华清远见嵌入式学习day42——Java多态性-CSDN博客

本文链接：https://blog.csdn.net/UemTuBXuR/article/details/90740158

回顾：
1：继承
关键字： extends
格式：
class 子类名 extends 父类名{}
eg：
class Animal{
String name；
int age；
public void eat(){
System.out.print("eat")
}
}
//在创建对象的时候
可以创建一个Animal类
Animal a = new Animal()
因为Animal不应该能被实例化
应该是一个抽象的所以我就想把Animal
定义成抽象类
因为每个动物吃的东西也不一样，那我就
不想再Animal类里来写出吃的具体实现
把eat()写成抽象方法，未来具体的类
继承Animal后该吃什么吃什么
9：20代码及笔记：
----------------------------------
package com.hqyj.demo;
/**
* 抽象的动物类
* 格式
* public abstract class Animal{}
* 抽象方法格式：没有方法体也没有{}
* public abstract void sleep() ;
* 暂时只写成员变量和成员方法
* 抽象类里可以有非抽象方法和抽象方法
* 有抽象方法的类必须定义成抽象类
* @author zj
*
*/
public abstract class Animal {
   String name ;
   int age;

   public void eat() {
       System.out.println("eat");
   }
   //抽象方法
   public abstract void sleep() ;

}
---------------------------------------
9：20后到下课时间的代码
----------------------------------
抽象的Animal 类
package com.hqyj.demo;
/**
* 抽象的动物类
* 格式
* public abstract class Animal{}
* 抽象方法格式：没有方法体也没有{}
* public abstract void sleep() ;
* 暂时只写成员变量和成员方法
* 抽象类里可以有非抽象方法和抽象方法
* 有抽象方法的类必须定义成抽象类
* @author zj
*
*/
public abstract class Animal {
   String name ;
   int age;
   public void eat() {
       System.out.println("eat");
   }
   //抽象方法
   public abstract void sleep() ;

}
//练习到 9：40的时候
//放demo出来
//9：45
--------------------------------------
Animal的子类 Cat
--------------------------------------
package com.hqyj.demo;
/**
* 继承抽象Animal的具体类
* 抽象类里的抽象方法是要求子类必须重写的方法
* @author zj
*
*/
public class Cat extends Animal{
   public void sleep() {
       System.out.println("cat 趴着睡");
   }
   public void play() {
       System.out.println("cat 玩老鼠");
   }

}
--------------------------------------------
测试类
-----------------------------------
package com.hqyj.demo;
/**
* 测试类
* @author zj
*
*/
public class Demo {

   public static void main(String[] args) {
       //创建抽象的Animal对象
   //   Animal a = new Animal();//直接给创想类创建对象这个时候会报错
       //只能通过多态创建Animal对象
       Animal a = new Cat();
       a.name="小猫";
       a.eat();
       a.sleep();
       //a.play(); 不能访问子类特有方法
       //直接创建子类对象
       Cat c = new Cat();
       c.play();
       c.sleep();
       c.eat();
       //向下转型
       Cat cc = (Cat) a;
       cc.play();
   }

}
--------------------------------------
第二节课开始 10：00
小结一下抽象类
1：抽象类的关键字：abstract
2：抽象类里可以有抽象方法
   也可以有非抽象方法
3：有抽象方法的类必须定义成抽象方法
4:抽象方法定义：没有方法体的方法
eg： public abstract void eat();

5:抽象方法的使用：
1：不能直接创建对象(实例化)
   2：只能通过多态来创建对象
       注意：多态创建的对象不能
       访问子类特有功能

--------------------------------------
动物园马戏团：狗跳高，猴子骑自行车
不是天生就有的功能我们它定义在Animal
里不合适定义再Dog也不合适；这种东西都是
通过后天培训出来的，这种培训出来的东西
java提供了接口来定义，未来谁想要拥有
这种特长就需要自己去实现接口，
------------------------------------
10：30
------------------------------------
package com.hqyj.demo2;
/**
* 跳高接口
* 接口是一个特殊的抽象类
* 格式：
* 访问修饰符 interface 接口名{}
*
* 接口的成员：
* 1: jdk8以前只能是抽象方法
* 默认访问修饰符： public abstract
*     public abstract void show();
*     jdk 8以后接口中可以定义静态方法
*     还可以：
       public default void show2() {
               System.out.println("show2");
               //i++;
               System.out.println(i);
           }
*
* 2:接口中只能定义静态常量
* 默认修饰符：public final static
* @author zj //练习到10：34
*/
public interface InterJump {
   public final static int i =10;
   public abstract void show();
   //jdk8以后的新特性
   public default void show1() {
       System.out.println("show2");
       //i++;
       System.out.println(i);
   }
   public static void show2() {
       System.out.println("show2");
       //i++;
       System.out.println(i);
   }

}
--------------------------------------
11:10代码讲解
----------------------------------------
package com.hqyj.demo2;
/**
* 跳高接口
* 接口和类的关系是实现
* @author zj
*
*/
public interface Jump {
//抽象的跳高方法
public abstract void jumpping();
}
-----------------------------------
具体类实现接口代码
----------------------------------
package com.hqyj.demo2;
/**
* 接口是一个特殊的抽象类
* 实现跳高接口
* 关键字：implements
* 格式： public class Dog implements Jump{

       }
抽象类和具体类都可以实现接口
但是：具体类要求必须重写接口中的抽象方法
        抽象类就没这个要求
        eg：
        abstract class Dog1 implements Jump{}
* @author zj
*
*/
public class Dog implements Jump{
   //重写接口里的抽象方法
   @Override
   public void jumpping() {
       System.out.println("jump dog");
   }
}
//
//abstract class Dog1 implements Jump{
//}
//练习到下下课
-------------------------------------
测试类
---------------------------------------
package com.hqyj.demo2;
/**
* 接口测试类
* @author zj
*/
public class Demo {
   public static void main(String[] args) {
       //接口不能直接创建对象
       //Jump j = new Jump() ;//抽象类
       //多态来创建接口对象父类的引用指向子类
       Jump j = new Dog();
       j.jumpping();
       //j能不能调用 dog里特有的方法

   }
}
-------------------------------------------
11：20看接口其他特点
类和类之间的关系：
   继承关系：单继承多层继承
接口和接口之间的关系：
继承：多继承
类和接口之间的关系
   实现关系：实现多个接口

-----------------------------------
接口和接口之间的关系：
继承：多继承代码下下面
---------------------------------
package com.hqyj.demo3;
/**
* 接口和接口的关系：
* 多继承格式： interface InterDemo extends A,B
* @author zj
*
*/
public interface InterDemo extends A,B {

}
//接口
interface A{}
interface B{}
--------------------------------------
接口和类的关系：实现
--------------------------------------
package com.hqyj.demo3;
/**
* 类和接口关系：实现实现多个接口
*
* 继承
* 还可以继承一个类再实现多个接口
* @author zj
*/
public class InterDemo2 extends
           Object
           implements A1,B1 {
}
//接口
interface A1{}
interface B1{}
--------------------------------------
从现在开始前面基础好坏先放一下
----------------------------------
内部类：
----------------------------------------
package com.hqyj.demo4;
/**
* 内部类：
* 把一个类定义在另一个类的内部
*
* 内部类的分类：
* 1：成员内部类
* 2：局部内部类
* @author zj
*
*/
public class Outer {
   class Inner{}

}
----------------------------------------
分类两大类：
1：成员内部类
2：局部内部类
-------------------------------------------
package com.hqyj.demo4;
/**
* 内部类的分类：
* 1：成员内部类：
* 内部类定义在外部类成员的位置
* 2：局部内部类：
*        内部类定义在外部类局部的位置
* @author zj
*
*/
public class Outer2 {
   //成员内部类
   class Inner2{}
   //方法
   public void show() {
       //局部内部类
       class Inner3{}
   }

}
--------------------------------------
成员内部的访问特点：
成员内部类访问特点:
* 1:内部类可以直接访问外部类的成员包括私有的
* 2：外部类访问内部类必须创建对象
---------------------------------------
package com.hqyj.demo4;
/**
* 内部类的分类：
* 1：成员内部类：
* 内部类定义在外部类成员的位置
* 2：局部内部类：
*        内部类定义在外部类局部的位置
*
* 成员内部类访问特点:
* 1:内部类可以直接访问外部类的成员包括私有的
* 2：外部类访问内部类？
* @author zj
*/
public class Outer3 {
   private int num = 10;
   //成员内部类
   class Inner2{
       //方法
       public void show() {
           System.out.println(num);
           method();
       }
   } //停留到58 然后再看下面内容
   //外部类的成员方法
   private void method() {
       // syso+Alt+/
       System.out.println("method");
       //创建内部类对象在调用
       Inner2 in = new Inner2();
       in.show();
   }
}
-----------------------------------------

下午：
成员内部类的访问
=======================================
成员内部类
-----------------------------------
package com.hqyj.demo4;
/**
* 内部类的分类：
* 1：成员内部类：
* 内部类定义在外部类成员的位置
* 2：局部内部类：
*        内部类定义在外部类局部的位置
*
* 成员内部类访问特点:
* 1:内部类可以直接访问外部类的成员包括私有的
* 2：外部类访问内部类？
* @author zj
*/
public class Outer3 {
   private int num = 10;
   //成员内部类
   class Inner2{
       //方法
       public void show() {
           System.out.println(num);
           method();
       }
   }
   //外部类的成员方法
   public void method() {
       System.out.println("method");

   }
}
------------------------------------
测试类：在这里创建内部类的对象
格式：
外部类.内部类对象名 =
   new 外部类().new 内部类()
-------------------------------------
package com.hqyj.demo4;
/**
* 对外部类Outer3创建对象调用方法
* 创建内部类格式：
* 外部类名.内部类名对象名 = 外部类对象.内部类对象;

* @author zj
*
*/
//测试
public class Demo {

   public static void main(String[] args) {
       //对外部类Outer3创建对象调用方法
       Outer3 outer =new Outer3();
       outer.method();
       //创建内部类对象调用内部类里的show方法
       //外部类名.内部类名对象名 = 外部类对象.内部类对象;
       Outer3.Inner2 in = new Outer3().new Inner2();
       in.show();
       //练习到13：50

}

}
-------------------------------------
静态内部类：
就是成员内部类加上static
-----------------------------------------
package com.hqyj.demo5;
/**
* 成员内部类
* 静态内部类：就是成员内部类加static
* 注意：静态的只能访问静态的
*     静态内部类只能访问外部类的静态成员
* @author zj
*
*/
public class Outer {
   int num = 10;
   static int num2 = 10;
   //静态内部类
   public static class Inner{
       public void show() {
       //   System.out.println(num);
           System.out.println(num2);
       }
       public static void show2() {
           //   System.out.println(num);
               System.out.println(num2);
           }

   }

}
------------------------------------------------
测试类：
访问静态内部类的方法
1:非静态的 :创建对象在调用
2：静态的 :可以外部类.内部类.方法名()
创建对象格式：
格式：
外部类.内部类对象名 =
new 外部类.内部类();
-------------------------------------------------
package com.hqyj.demo5;
/**
* 创建静态内部类对象并访问静态方法和成员方法
* 外部类名.内部类名对象名 = new 外部类名.内部类名();
* 可以把：外部类名.内部类名当作一个整体

* @author zj
*写一下代码：写到14：20
*/
public class Demo {
   public static void main(String[] args) {
       //创建静态内部类对象并访问静态方法和成员方法
       Outer.Inner oi = new Outer.Inner();
       oi.show();
       oi.show2();
       //静态方法可以类名.方法名()
       Outer.Inner.show2();
   }
}
----------------------------------------------------
14:30
匿名内部类
就是局部内部类的简化写法。
前提：存在一个类或者接口
这里的类可以是具体类也可以是抽象类。
格式：
new 类名或者接口名() {重写方法;}

匿名内部类隐式地继承了一个父类或者实现了一个接口。

匿名内部类使用得比较多，通常是作为一个方法参数。

---------------------------------------------

package com.hqyj.demo7;
/**
* 匿名内部类：是一个局部内部类
* 格式：
* new 类名/接口名(){
* 重写接口里的方法
* }
*
* 前提：接口
* 实质上是：
* 一个实现了接口的具体类的对象
*
* 想调用谁的方法就需要创建谁的对象.方法()
* @author zj
*/
//接口
interface inter{
   public abstract void show();
}
//外部类写到15：10
public class Outer {

public void method() {
   new inter() {
           public void show() {
               System.out.println("show");
           }
       }.show();
   //你匿名内部类 //一个实现了接口的具体类的对象 .show(); }
}
}
------------------------------------------
测试类：
---------------------------------------------
package com.hqyj.demo7;

public class Demo {
   public static void main(String[] args) {
       Outer outer = new Outer();
       outer.method();
   }
}
-------------------------------------------------
异常：
1：运行时期异常
   int a = 10 int b =0
   a/b
   运行的时候报错；

   这种异常是因为自己代码写的不规范、
   导致的，这种异常需要自己改代码
   不需要去处理

2：非运行时期异常：编译时期异常

3：error：错误不需要处理
异常处理方式：
1：捕获
2:抛出 4：20练习的
--------------------------------------
package com.hqyj.demo8;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

/**
* 异常：
*
* @author zj
*/
public class Demo {
   public static void main(String[] args) {
       //文件流的操作自己捕获异常
           try {
               FileInputStream fis = new FileInputStream("a.txt");
           } catch (FileNotFoundException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
           }

           //调用method
           try {
               method();
           } catch (FileNotFoundException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
           }
   }

   //方法我不想处理谁调用谁处理抛出
   public static void method() throws FileNotFoundException {
       FileInputStream fis = new FileInputStream("a.txt");
       //
   }//异常练习到16：20
}
----------------------------------------
常用类：
Math类 String
Math类里的方法全是static的所以使用的
时候，直接通过类名.就可以
----------------------------------------
package com.hqyj.demo8;
/**
* Math 类
* @author zj
*
*/
public class MathDemo {
   public static void main(String[] args) {
       //绝对值
       System.out.println(Math.abs(-12));
       System.out.println(Math.max(10, 20));
       // 0.0~1.0 无限接近1
       System.out.println(Math.random());
       // 1~10的随机数 //0.0 ~10.0 无限接近10
       System.out.println(Math.random()*10);
       // 0~9
       System.out.println((int)(Math.random()*10));
       // 1~10
       System.out.println((int)(Math.random()*10+1));


   }

}
-------------------------------------------
String类：不可改变的字符序列
---------------------------------------------
package com.hqyj.demo8;
/**
* String 一组不可改变的字符序列
* "hello" 会在常量池
* "java" 会在常量池
* "hellojava"
* @author zj
*
*/
public class StringDemo {
   public static void main(String[] args) {
       String str1 = "helLO";//hello
       String str2 = "java";//java
       System.out.println(str1+str2);//hellojava
       System.out.println(str1.charAt(1));
       System.out.println(str1.toLowerCase());
   }
}