Super：
1.调用父类里的构造函数
2.调用父类里的普通方法（非私有）
如 ：super（a，h）
super.eat（）
昨天的代码有涉及

多态：
1.方法重载 ：相同的函数名不同的形参（个数、类型，顺序）
2.方法的重写： 子类和父类具有相同的函数名，形参也一样返回值类型也一样
3.类型转换： 向下转型（强制转化），向上转型
4.动态绑定： 调用实参时对应类型的类下面的方法

方法重载
package text2;
public class text1 {
int num;
public static void main(String[] args){
new text1();
}
void fun(){
num = 0;
System.out.println(num);
}
void fun(int a){
num = a;
System.out.println(num);
}
void fun(int a,double b){
num = (int)(a * b);
System.out.println(num);
}
void fun(double a,int b){
num = (int)(a * b);
System.out.println(num);
}
public text1(){
fun();
fun(1);
fun(1,2.0);
fun(3.0,2);
}
}

方法重写
package text2;
public class text2 {
public static void main(){
//把子类复制给父类 对的
People p;
Student s = new Student();
p = s;
//把父类复制给子类 错误的
/*People p1 = new People();
Student s1;
s1 = p1;*/
//可以把p1强制转化为student类
People p1 = new People();
Student s1;
s1 = (Student)p1;
}
}
class People{
int age;
public void eat(){
System.out.println("吃吃吃....");
}
}
class Student extends People{
public void eat(){
System.out.println("学学学....");
}
}

类型转换
上面的代码涉及到了。。。不给例子了

动态绑定
package text2;
public class text3 {
public static void main(String[] args){
BangDing bd = new BangDing();
bd.judge(new Student());
bd.judge(new Teacher());
bd.judge(new People());
}
}
class People{
public void eat(){
System.out.println("吃吃吃...");
}
}
class Student extends People{
public void study(){
System.out.println("学学学...");
}
}
class Teacher extends People{
public void teach(){
System.out.println("教教教...");
}
}
class BangDing{
public void judge(People p){
p.eat();
}
}

访问权限修饰符：
1.private 私有的 只有在类里面才可以使用的
2.protected 受保护的 该类和子类都可以访问
3.public 公共的 都可以访问

package text2;
public class text4 {
public static void main(String[] args){
T t = new T();
System.out.println(t.i) ;
}
}
class T{
//private int i = 10; //会报错
protected int i = 10; //不会报错
//public int i = 10; //不会报错
}

static：
1.静态变量： 属于类，不属于某个变量可以通过类名访问，不需要创建对象；无论创建多少个对象，它只有一个
2静态方法： 只能访问静态成员，不能访问非静态成员，不能被重写为非静态方法
3.静态代码块： 在类被加载时只会执行一次，只能初始化静态数据成员

静态变量
package text2;
public class text5 {
public static void main(String[] args){
System.out.println(Chinese.country);
Chinese c1 = new Chinese();
Chinese c2 = new Chinese();
System.out.println(c1.country);
c2.set("aaa");
System.out.println(c1.country);
}
}
class Chinese{
static String country = "China";
String name;
int age;
void sing(){
System.out.println(country);
}
void set(String s){
country = s;
}
}

静态方法
package text2;
public class text6 {
public static void main(String[] args){
fun();
}
static void fun(){
System.out.println("静态方法");
}
}
class A{
static int[] values = new int[10];
static{
for(int i = 0; i < values.length; i++){
values[i] = (int)(Math.random()*100);
}
}
}

final：不可以被修改
package text2;
public class text7 {
final int a = 0 ;
public static void main(String[] args){
new text7();
}
public text7(){
//a = 1;
//a = 9;
System.out.println(a);
}
}

abstract：抽象方法，抽象类都不可以被实例化
package text2;
public class text8 {
public static void main(){
}
}
abstract class People{
abstract void eat();
}
class Student extends People{
void eat(){
}
}

接口：只有函数声明，不可以被实例化，interface定义接口，implements接口实现
public class text9 implements{
//展示使用方法
}
interface F{
public void fun1();
public void fun2();
public void fun3();
}