java----基础（this,继承,多态,抽象类,接口）

  • this指针

　　this指针在类定义时用到，this属于用类实例化的对象，只能在定义类的时候使用；(在下面的代码中会有体现)

  • 类变量&类方法　　　

　　定义： 访问修饰符 static+数据类型+变量名

　　所有该类的对象均可访问，均可修改，不会在调用后初始化，相当于全局变量。
　　可以被所有对象访问到，并且可以通过类访问到  类名.类变量
　　

　　静态方法 == 类方法
　　可以被类名和对象访问到
　　原则上类变量用类方法来访问
　　类方法中不能访问非类变量，类变量可以被非类方法访问。

  • 四种访问控制符：

　　public ： 对外公开
　　private：仅对本身公开
　　无：　　 向同一个包中的类公开
　　protected：对子类和同一个包中的类公开

  • 包

　　　　同一个包中不能有同名的函数，包括类中的方法；

　　包名都是小写字母和下划线组成

　　作用：

　　　　区分相同名的类
　　　　对很多包进行管理
　　　　控制访问的范围　　

　　打包命令：   package  com.~~~   创建包时添加在同一个包的各个类文件的头部；
　　常用的包：   java.lang.* 自动引入
　　　　　　　　java.util.* 工具包
　　　　　　　　java.net.* 网络开发包
　　　　　　　　java.awt.* 窗口包
　　引入包        import + 包名

　　

(对于个人项目的命名，摘自zqxlonely的博文)indi ：

         个体项目，指个人发起，但非自己独自完成的项目，可公开或私有项目，copyright主要属于发起者。

         包名为“indi.发起者名.项目名.模块名.……”。

    pers ：

         个人项目，指个人发起，独自完成，可分享的项目，copyright主要属于个人。

         包名为“pers.个人名.项目名.模块名.……”。

    priv ：

         私有项目，指个人发起，独自完成，非公开的私人使用的项目，copyright属于个人。

         包名为“priv.个人名.项目名.模块名.……”。

    onem ：

         与“indi”相同，推荐使用“indi”。

    另外，我为了区分团队项目和前面所说项目的区分，还有了一下扩展：

    team ：

         团队项目，指由团队发起，并由该团队开发的项目，copyright属于该团队所有。

         包名为“team.团队名.项目名.模块名.……”。

    com ：

         公司项目，copyright由项目发起的公司所有。

         包名为“com.公司名.项目名.模块名.……”。
  • 重载

　　函数名相同，返回值不同或形参个数或类型或顺序不同，但仅仅返回值不同不构成重载。程序会根据参数列表选择相应函数。

/*
 * @2016.10.17
 * @Ziv
 * @重载演示
 * */
public class overload{
    public static void main(String[]args){
    over1 over11 = new over1();
    System.out.println(over11.getMax(10,11));
    System.out.println(over11.getMax(10.1f,11.1f));
    System.out.println(over11.getMax(10.22,11.22));
    }

}
class over1{
    public int getMax(int a,int b)
    {
        if(a>b)
        {
            return a;
        }
        else
        {
            return b;
        }
    }
    public float getMax(float a,float b)    //重载
    {
        if(a>b)
        {
            return (float)a;
        }
        else
        {
            return (float)b;
        }
    }
    public double getMax(double a,double b)
    {
        if(a>b)
        {
            return (double)a;
        }
        else
        {
            return (double)b;
        }
    }

}
  • 继承

　　父类中有的函数，能在子类中重新定义并覆盖，否则则为子类自己的方法

　　格式： class 类名 extends 父类{}

/*
 * @2016.10.17
 * @Ziv
 * 继承的演示
 */
public class jicheng {
    public static void main (String []args){
        Pupil p1 = new Pupil ();
        p1.out_();//子类对象调用从父类继承来的函数
    }
}
//抽象学生类，做父类
class Stu{
    //父类中的public protected 默认类型的都可被继承
    protected int age;
    protected String name;
    protected float fee;

    public void out_(){
        System.out.println("aaaaaa");
    }

}
//小学生类
class Pupil extends Stu{
    //成员属性
    public void pay(float fee){
        this.fee = fee;
    }

}

//中学生类
class Middle extends Stu{

    //计算学费
    public void pay(float fee){
        this.fee = fee*0.8f;
    }
}

//大学生类
class College extends Stu{

    //计算学费
    public void pay(float fee){
        this.fee = fee*0.1f;
    }
}
  • 多态　

　　一种引用（类型）在不同情况下的多种状态：
　　通过指向父类的指针，来调用在不同子类中的方法，即父类的引用引用子类的实例对象

/*
* @2016.10.18
* @Ziv
* @多态的程序实例演示
*/
public class duotai {

    public static void main(String[] args) {

        //多态
        Catt cat1 = new Catt();
        cat1.cry();
        Dogg dog1 = new Dogg();
        dog1.cry();

        //自动判断an的指向
        Anminall an = new Catt();
        an.cry();

        an = new Dogg();
        an.cry();

        //创建主人
        Host host = new Host();
        host.feed(dog1, new food());
        host.feed(cat1, new food());
    }

}
//食物类
class food{
    String name;
    public void Showname(){

    }
}

class Fish extends food{
    public void Showname(){
        System.out.println("Fish");
    }
}

class Bone extends food{
    public void Showname(){
        System.out.println("Bone");
    }
}

//主人类
class Host{
    //喂食，使用多态，方法就可以只用一个
    public void feed (Anminall an,food f){
        an.eat();
        f.Showname();
    }
}

//动物类
class Anminall{
    int age;//默认访问权限，可以被同类和同包的访问
    String name;
public void cry(){
        System.out.println("Do not konw");
    }
    //吃东西
    public void eat(){
        System.out.println("Do not konw");
    }
}
class Catt extends Anminall{
    public void cry(){
        System.out.println("喵喵");
    }

    //猫吃
    public void eat(){
        System.out.println("Fish");
    }

}
class Dogg extends Anminall{
    public void cry(){
        System.out.println("汪汪");
    }
    //狗吃
    public void eat(){
        System.out.println("Bone");
    }
}
  • 接口（更加抽象的抽象类）

　　给出一些没有内容的方法，封装到一起，到某类要使用时，具体写出来
　  定义接口：    interface 接口名
     用类实现接口 ：class 类名 implements 接口{方法；变量；}

  1. 当一个类实现了一个接口，要求该类把接口的所有方法都实现
  2. 一个类实现的接口可以被其他类使用
  3. 接口不能被实例化
  4. 接口中所有方法都不能有主体
  5. 一个类可以实现多个接口
  6. 接口中可以有变量，但不能是private和protected的
  7. 接口中的变量本质上都是static的，而且是final类型的
  8. 常把常用的变量放在接口中，做全局变量用 形式为：接口名.变量名
  9. 接口不能继承其它类，但可以继承其他接口
/*
 * @2016.10.18
 * @Ziv
 * @接口的实现演示
 * */
public class _implements {

    public static void main(String[] args) {

        //直接访问接口中的变量
        System.out.println(Usb.a);

        //实例化对象
        Phone phone1 = new Phone();
        Camera camera1 = new Camera();
        Computer com = new Computer();

        com.useUsb(camera1);
        com.useUsb(phone1);

        //调用接口中的方法
        camera1.cc();//camera中实现的是aa中的cc方法
        phone1.cc();//Phone中实现的是Usb从aa继承来的cc方法
    }
}

//Usb接口  定义接口，接口中所有方法都不能有主体
interface Usb extends aa{
    int a = 1;
    //声明两个方法
    public void start();
    public void stop();
}
interface aa{
    public void cc();
}
//编写类，实现USB接口
//当一个类实现了一个接口，要求该类把接口的所有方法都实现
class Camera implements Usb,aa{ //允许一个类实现两个接口
    public void start(){
        System.out.println("I am a Camera,i will start.");
    }
    public void stop(){
        System.out.println("I am a Camera,i will stop.");
    }
    //另一个接口的实现
    public void cc(){
        System.out.println("I am interface cc");
    }
}

//编写类，实现USB接口
class Phone implements Usb{
    public void start(){
        System.out.println("I am a Phone,i will start.");
    }
    public void stop(){
        System.out.println("I am a Phone,i will stop.");
    }
    //实现Usb继承的aa的方法
    public void cc(){System.out.println("Usb extends from aa");}
}
//计算机类
class Computer{
    //开始使用usb接口
    public void useUsb(Usb usb){
        usb.start();
        usb.stop();
    }
}
/*接口继承别的接口
interface Tt{
}
interface Son extends Tt{
}
*/
  • 抽象类

　   由于父类方法的不确定性 用abstract修饰方法/类

　　定义：abstract void Son();
　　只有抽象类中才能定义抽象方法，但抽象类中可以没有抽象方法
　　抽象类的子类必须实现父类中所有的的抽象方法
　　抽象类不能实例化对象

/*
 * @2016.10.18
 * @Ziv
 * @抽象类的必要性演示
 * */
public class abstract_class {
    public static void main (String []args){
        Son son = new Son();
        son.say();
    }
}

//抽象类
abstract class Father{
    int age;
    String name;

    //说话 抽象方法
    abstract public void say();
}

class Son extends Father{
    public void say(){
        System.out.println("i am Son");
    }
}

class GSon extends Father{
    public void say(){
        System.out.println("i am GSon");
    }
}
时间： 2024-10-21 14:03:31

java----基础（this,继承,多态,抽象类,接口）的相关文章

JAVA基础笔记（很实用）继承-多态-抽象类-接口-异常-集合-IO-线程-Socket

第七章:Java继承 一.继承的概念 1.一个父类派生出一个子类的机制称为继承. 2.承是重用程序代码的有力手段,当多个类之间存在相同的属性和方法时,可以从这些类中抽象出父类. 3.们只需要在父类中定义这些属性和方法,而子类无须重新定义这些属性和方法,直接从父类继承即可. 4.通过继承,子类就会自动的拥有在父类中定义的属性和方法. 5.两个或多个类的成员中存在一部分相同的情况,通过继承机制,可以利用现有的类来创建新的类. 6.子类不但拥有父类的成员,还可以定义新的成员. 7.可以提高软件的可重用

黑马程序员——Java基础——面向对象——继承、抽象类、接口、多态、包、内部类、异常等

第一讲 继承 1.继承: 当多个类拥有相同的功能时,那么这些类不需要每个都写这些相同的功能,只需要把相同功能抽到 一个单独的类中,继承这个类就能获得这些相同的功能: (1)继承的体系结构:就是对要描述的事物进行不断的向上抽取,就出现了体系结构. 要了解这个体系结构中最共性的内容,就看最顶层的类. 要使用这个体系的功能,就用最底层的类创建对象 (2)好处: A.提高代码复用性: B.继承的出现,让类与类之间产生关系,为多态的前提 (3)特点: A.只能单继承(准确的说是java对多继承进行优化,避

Java基础笔记-继承、抽象类、接口、多态、内部类、异常

继承:多个类具有相同的属性和行为时,将这些内容单独抽取到一个单独的类中,那么多个类无需再定义这些属性和行为,直接继承那个类即可 1)  多个类称为子类,单独的类称为父类或者超类 2)  子类可以继承父类中非私有的属性和方法 3)  通过extends关键字让类与类之间建立继承关系 4)  继承的出现提高了代码的复用性,让类与类之间产生了关系,为多态的出现提供了前提 5)  不能为了实现某类的功能,简化代码而继承,必须是类与类之间具有所属关系才可以继承,所属关系:is a 6)  特点:java只

初识JAVA（【面向对象】：pub/fri/pro/pri、封装/继承/多态、接口/抽象类、静态方法和抽象方法；泛型、垃圾回收机制、反射和RTTI）

JAVA特点: 语法简单,学习容易 功能强大,适合各种应用开发:J2SE/J2ME/J2EE 面向对象,易扩展,易维护 容错机制好,在内存不够时仍能不崩溃.不死机 强大的网络应用功能 跨平台:JVM,字节码 两个命令: javac helloworld.java:将Java文件编译为字节码的.class文件 java helloworld:运行Java程序...??暂时这么认为 数据类型: 普通数据类型:int a=3; 对象数据类型:使用关键字new,String s=new String("

Java基础学习总结--多态

一.面向对象的三大特性:封装.继承.多态 ? 从一定角度来看,封装和继承几乎都是为多态而准备的. 二.什么是多态? ? 指允许不同类的对象对同一消息做出响应.即同一消息可以根据发送对象的不同而采用多种不同的行为方式.(发送消息就是函数调用) 三.实现多态的技术以及三个必要条件: ? 实现多态的技术称为:动态绑定(dynamic binding),是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法. 三个必要条件: 继承 重写 父类引用指向子类对象 四.多态的作用.好处.类型

Java基础十二--多态是成员的特点

Java基础十二--多态是成员的特点 一.特点 1,成员变量. 编译和运行都参考等号的左边. 覆盖只发生在函数上,和变量没关系. Fu f = new Zi();System.out.println(f.num);//是父类,答案是3 2,成员函数(非静态). 编译看左边,运行看右边. 因为成员函数存在覆盖特性. Fu f = new Zi();//f.show();输出的是子类里面的show方法 3,静态函数. 编译和运行都看左边. 静态函数不具备多态性,多态性是对象的多态性,然后静态函数不涉

Java基础08 继承（转载）

继承(inheritance)是面向对象的重要概念.继承是除组合(composition)之外,提高代码重复可用性(reusibility)的另一种重要方式.组合是重复调用对象的功能接口.继承可以重复利用已有的类的定义. 类的继承 我们之前定义类的时候,都是从头开始,详细的定义该类的每一个成员.比如下面的Human类: 从上面的类定义,我们可以了解该类的所有细节: 该类的数据成员,该类的方法,该类的接口. 现在要定义一个新的类,比如Woman类,并假设Woman与Human类相当类似: 可以像以

黑马程序员-Java基础-面向对象—继承、构造函数、重写、final、抽象类、接口

第一讲  继承 1.  继承的作用 1) 提高代码复用性: 2) 让类与类之间产生了关系: 2.  java继承特点 1) java只支持单继承,不支持多继承 因为多继承容易带来安全隐患:当多个父类中定义了相同功能,但功能内容不同时,子类对象不确定要运行哪一个. 2) java支持多层继承:可以形成一个继承体系 利用一个继承体系的方法:阅读体系父类,了解共性功能(该体系的基本功能),具体要调用这些基本功能时,需要创建最子类的对象,为什是最子类: 一是:父类有可能不能创建兑现(如,静态类或接口):

黑马程序员--java基础之多态,抽象类,接口,匿名内部类

------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 4.4 子类的实例化过程 子类中所有的构造函数默认都会访问父类中空参数的构造函数. 因为每一个构造函数的第一行都有一条默认的语句super();. 子类会具备父类中的数据,所以要先明确父类是如何对这些数据初始化的. 为什么子类实例化的时候要访问父类中的构造函数呢? 那是因为子类继承了父类,获取到了父类中内容(属性),所以在使用父类内容之前,要先看父类是如何对自己的内容进行初始化的. P.S.