面向对象-继承

JDK中主要的包介绍

1.java.lang----包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。

2. java.net----包含执行与网络相关的操作的类和接口。

3.    java.io   ----包含能提供多种输入/输出功能的类。

4.  java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。

5. java.text----包含了一些java格式化相关的类

6.     java.sql----包含了java进行JDBC数据库编程的相关类/接口

7. java.awt----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界 面(GUI)。

8. java.applet---- 包含applet运行所需的一些类。

---

继承： extends 父类名称

当然也可以用implements 关键字，但这叫接口。

        多个类中存在相同属性行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类就好了

此处多个类称为子类，单独的称为父类

        不要为了获取其他类中的某个功能而去继承 ，继承要有逻辑关系，不要随便继承。

子类不能直接拿到父类的私有的属性和方法，但可以通过get/set的操作获取到

子类是父类的扩展

子类只能有一个父类，但父类有多个 儿子

Java 只支持单继承，不支持多继承 ,不能同时认多个父亲(不能认干爸，父类能认多个干儿子)

Java支持多层继承（继承体系）

语法：class 子类 extends 父类{}

class A{}
class B {}
class C extends A ,b {}    //错误的,不能同时认多个父亲

class A{}
class B extends A{}
class C extends B{}
class C extends A{}

C就是爷爷，B就是爸爸，A就是儿子

简单来说就是，Java中不允许多重继承，但是允许多层继承！多层继承一般不会超过三层，，但一个类可以实现多个接口，从而克服单继承的缺点

你的就是我的，我的还是我的。听懂掌声

就是你能拿你继承你爸的财产，但你的钱绝对不会给你爸的。......不肖啊。

为啥要继承呢？

因为有相同属性或方法，不想再cv一下，可以直接继承你爸的属性或方法，但是呢继承的财产不能直接使用，要经过你爸的同意，也就是经常用的就是get、set。

子类呢，也可以进行功能上的扩充。

package com.company;

public class Student extends demo {  //extend继承Text里面的主构造方法    子类
   String school="清华";

   int i=age = 12;  //可以给继承过来的东西赋值，但必须要有东西给他装起来，因为继承是单向的,不能再把值放回父类了，也就是自慰。
   String name = "123";//如果重新定义父类的成员变量，优先拿子类的成员变量

   public void ShowInfo1(){
      System.out.println(name);//可以拿到子类里面的方法属性，优先拿子类的成员变量
      System.out.println(super.name);//super超级类，可以拿父类里面的方法和属性
      System.out.println(sex);//
      System.out.println(age);
      System.out.println(i);
      System.out.println(school);
   }
}

package com.company;

public class demo{   //父类
    public String name="李富贵";
    public String sex;
    public int age;

    public void showInfo(){
        System.out.println(name);
        System.out.println(sex);
        System.out.println(age);
    }
    public static void main(String[]args) {  //主方法
        new demo().showInfo();
        System.out.println("_______________________");
        new Student().showInfo();
    }

}

虽然不能直接拿，但我能new一下子类拿的到他的值

 不能直接给继承过来的值赋值

一个类继承了抽象类，必须要重写它的所以的抽象方法，否则这个类就是抽象方法

---

内部类 多重继承

就是类里面还有类。

–内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。

–内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的。

成员内部类：

在类的成员位置，和成员变量以及成员方法所在的位置是一样的

在内部类中，可以直接访问外部类的成员，包括私有成员

package Demo;

/**
 * @author 123
 *	成员内部类
 */
public class InnerDemo {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
 // 在主方法创建内部类对象
Outer.Inner i =new Outer().new Inner();
	}
}
class Outer{
	private int num = 10;
	public void method() {
		//可以在外部类里的方法创建内部类的对象
		Inner i =new Inner();
		i.funtion();
		
	}
	
	//Inner  成员内部类
	class Inner{
		public void funtion() {
			System.out.println("funtion");
			System.out.println(num);
		}
	}
}

我们可以用权限修饰符修饰成员内部类，但如果用private 修饰，则无法在其他类中访问

static 修饰的成员内部类，不用再创建外部类的对象

局部内部类：在方法里面，出了方法就无法使用

匿名内部类：没有名字的内部类

可以把匿名内部类看成是一个没有名字的局部内部类

      定义在方法当中

       必须在定义匿名内部类的时候创建他的对象

  格式：

     new 类/接口(){

          如果是创建了继承这个类的子类对象，我们可以重写父类的方法

           如果是创建了实现这个接口的子类对象，我们必须要实现该接口的所有方法

       };

  原理：而是创建了继承这个类的子类对象或者是创建了实现这个接口的子类对象

public class InnerDemo4 {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}
 
 
interface Inner {
    public void function();
}
 
class Outer {
    public void method() {
       
        /*new Inner() {
 
            @Override
            public void function() {
                System.out.println("function");
            }
          //直接使用   只能一次
        }.function();;*/
       //通过赋值给对象使用，可以多次使用
        Inner i = new Inner() {
 
            @Override
            public void function() {
                System.out.println("function");
            }
           
        };
       
        i.function();
        i.function();
       
       
    }
}