突然技术员,面向对象

By admin in 4858.com on 2019年5月26日

面向对象基础知识

面向对象是周旋面向进程而言的 面向目的和面向进度都是壹种构思
面向经过强调的是法力行为 面向对象将作用封装进对象,重申具有了职能的对象
面向对象是依靠面向进程的

面向对象的特点:

  • 封装
  • 继承
  • 多态

java中用类Class来叙述事物: 属性:对应类中的成员变量
行为:对应类中的成员函数

分子变量 成员变量定义在类中,在总体类中都能够被访问
成员变量随着对象的确立而树立,存在于对象所在的堆内部存款和储蓄器中
成员变量有暗中同意开端化值

有些变量 局地变量之定义在有个别范围内,如函数内 局地变量存在栈内部存款和储蓄器中
功用的界定甘休,变量空间会自行释放 局地变量未有暗许先河化值

无名氏对象 无名氏对象是指标的简化格局 佚名对象有二种采纳状态:
当对象方法仅进行叁次调用时 佚名对象足以看狠抓际上参数进行传递

摘抄:https://my.oschina.net/u/267295/blog/52716

2、面向对象

——-android培训java培训盼望与你调换!———-

heap-stack

java -x 输出java的非规范选项 java -Xss<size> xxx 设置stack大小
如:java -Xss521k

java -Xmx 设置堆最大值 java -Xms 设置堆开头值

java中指标和数组都位居堆内部存款和储蓄器中,局地变量函数参数等都位于栈内部存款和储蓄器中

1、面向对象

特点:
一、将复杂的职业轻易化
二、面向对象将在此之前的经过中的试行者。
三、面向对象这种思虑是顺应现行反革命大家观念的壹种思维。

行吗进度作为函数,能够呢对象看做是将函数等剧情张开了包装。

无名氏对象使用情况:
一、成员变量:对应事务的品质
贰、成员函数:其实对应的就是东西的表现。

定义类就是概念成员变量和成员函数。可是在概念前,必须对作业实行品质和行事的解析。

在开拓时,属性是用于存款和储蓄数据的,直接被访问,轻松并发安全隐患。所以,类中的属性寒时被私有化,并且提供公共访问方法。

成员变量和某个变量的界别:
突然技术员,面向对象。1、成员变量直接定义在类中,局地变量直接定义在点子中,参数上,语句中。
贰、成员变量在这些类中央银一蹴而就。局地变量只在和睦所属的大括号有效,大括号停止,局地变量失去成效域。
3、成员变量存在于堆内部存储器中,随着对象的产生而留存,消失而熄灭。
一些变量存在于栈内部存款和储蓄器中,随着所属区域的运行而留存,甘休而自由。

构造函数和一般函数的界别:
1、多个函数定义的格式分歧。
2、构造函数是在目的成立时,就被调用于初阶化,而且开端化动作只举办二回。一般函数,是目的创设后,要求调用才施行,能够被调用数次。

结构代码块和构造函数有吗分歧:
协会代码块:是给全数目的开始展览先导化,也正是说,全部的靶子都会调用八个代码块,只要对象第三建工公司立,就能调用这几个代码块。
构造函数:是给予之相应的指标进行开首化的,它具有针对性。

新建1个指标内部存款和储蓄器的变化 ?:
Person p = new Person();
一、先将硬盘上钦点的岗位的Person.Class文件加载进内部存款和储蓄器
二、施行main方法时,在栈内部存款和储蓄器中开垦了main方法的上空(压栈-进栈),然后在main方法的栈区分配了二个变量p;
三、在堆内部存款和储蓄器中开荒叁个实体空间,分配了内部存款和储蓄器的首地址值。 new
四、在该实体空间中开始展览质量的空中分配,并拓展了默许起首化。
伍、对空间中的属性实行进行实际发轫化。
陆、进行实体的结构代码块初叶化。
七、调用该实体的相应的构造函数,进行组织初叶化()
八、将首地址赋值给p,p变量就引述了该实体。(指向该目的)

1.1、方法

多少个特征:封装,承接和多态。

成员变量成效在整整类,且位于堆内部存款和储蓄器中,而某些变量成效在函数或语句中,位于栈内存中。

1.面向对象概念

a.面向目的概念

  • 领悟面向对象:面向对象是面向进程来说。是一种思念。将功能封装进对象,强调具有了效益的靶子。
  • 任何事物都能抽象成靶子,比方人。人都有共性:年龄,性别,身高,文凭等等。把人抽象成靶子,而以这厮目标内部的功力能够定义成年龄,性别,身高档等这么些;而对于外界想要调用你此人的某部成效属性,对她的话不要关怀你人指标内部的落到实处,他只管调用你的那几个目的某些成效,获取她需求的结果就能够。方便连忙,升高编制程序效能。
  • 面向对象多个性子:封装、承接、多态

b.类与目的的涉嫌

  • 类:对现实生活中东西的叙说。
  • 目标:正是真真切切的民用的那类事物。
  • 定义:
    A.
    定义类正是在讲述事物,也正是在概念属性和行为。属性和行为共同成为类中的成员(成员变量,成员函数)。
    B. 对象由new操作符来变化,在堆内部存款和储蓄器发生2个实体。
  • 示例:

//定义类
    class People{
    //属性
    public int age;
    public string name;
    ...
    //定义方法 行为
    public int age()
    {
            return age;
    }

    //对象
    People p = new People();
    p.age();
    ...
  • 分子变量和部分变量
    A.最大分裂分裂:成效的界定不均等。成员变量功用于漫天类中,从属于类,不必开首化。局地变量功能于函数中可能语句中,必须手动开端化。
    B.内部存款和储蓄器的地方:成员变量在堆内部存款和储蓄器中,因为对象的存在才存在于内存中。局地变量存在栈内部存储器中。
  • 无名氏对象
    A.无名氏对象是指标的简化方式,没出名字的靶子。格式为new 实例名称();
    B.无名氏对象二种采用状态:
    (一).当对指标方法仅实行一回调用时
    (二).无名氏对象能够看作实际上参数进行传递

new People().age = 23;

age(new People());

封装

卷入是指隐藏对象的属性和促成细节,仅对外提供公共访问方式

打包原则: 将不要求对外提供的内容都躲藏起来
把品质都隐藏起来,提供公共艺术对其访问

代码例子:

package study_java.ex01;

public class ClassDemo1 {
    public static void main(String[] args){
        Man man = new Man();
        // 不能直接通过man访问到money,只能通过getMoney方法
        System.out.println(man.getMoney());
        man.addMoney(100);
        System.out.println(man.getMoney());
        // 对于public的变量我们可以直接通过man访问
        System.out.println(man.age);
    }

}

class Man{
    private int money = 100;
    public int age = 23;

    // 通过封装的方式获取money
    public int getMoney(){
        return money;
    }
    // 通过封装的方式修改money
    public void addMoney(int num){
        money += num;
    }
}

二、封装

封装指的是隐身对象的质量和促成细节,仅对外提供公共访问格局。
好处:将扭转隔断,便于使用,提升重用性,安全性。

this:代表对象自身,正是所在函数所属对象的引用。
this到底代表如何呢?哪个指标调用了this所在的函数,this就代表哪个目的,就是哪位指标的引用。
支出时,什么时候利用this?
在概念作用时。若是该意义内部选用到了调用该意义的目的,那时就用this来表示那个目的。

this还能够用来构造函数间的调用。
调用格式:this(实际参数)
this对象后边的..调用的是成员变量属性和成员方法(一般方法);
this对象前面跟上()的是本类中的对应参数的构造函数。

瞩目:使用this构造函数,必须定义在构造函数的首先行,因为构造函数是用于初叶化的,所以开始化动作一定要执行。不然编写翻译失利。

static关键字:是多少个修饰符,用于修饰成员(成员变量和分子函数)
特点:
一、有些数据是目的特有的数额,是不得以被静态修饰的。因为那样的话,特有数据会形成对象的共享数据,那样子对事物的描述就出了难点。所以在概念静态时,必须旗帜鲜明,那么些数量是或不是被对象所共享。
三、静态方法中不能够动用this、super关键字。因为this代表对象,而静态在时,有看吗个尚未对象,所以this无法使用。
四、主函数是静态的。

什么样时候定义静态成员?
一、成员变量(数据共享时静态化)
该成员变量的数码是不是是全部指标都一样;
如要是那么该变量要被静态修饰,因为是共享数据。
假若不是,那么就说那是目的特有多少,要存款和储蓄到指标中。
二、成员函数。
情势中有特有数据时就定义静态。
1旦判别成员是或不是须求被静态修饰?
只要参考 ,该函数内是还是不是访问了目的中的特有数量;
假设有访问特有数据,这艺术不可能被静态修饰。
借使未有访问过故意的多寡,那么这一个主意须要被静态修饰 。

分子变量和静态变量的界别:
一、成员变量所属于对象,所以也成为实例变量。
至于成员变量和类变量的分裂:
http://www.cnblogs.com/huyuyu/p/6392987.html
二、成员变量存在于堆内部存款和储蓄器中,
静态变量存在方法区中。
3、成员变量随着对象的创办而存在,随着类的消散而熄灭。
四、类变量(静态变量)随着类的加载而存在,随着类的消逝而消亡。
分子变量只可以被对象调用,静态变量既能够被对象调用也能够被类名调用。
故而,成员变量堪称对象的特有多少,静态变量称为对象的共享数据。

静态的小心:静态的生命周期十分短。
静态代码块:正是三个有静态关键字标示的贰个代码块区域,定义在类中。
职能:能够做到类的起初化。静态代码块随着类的加载而施行,而且只进行三遍。如若和主函数在同二个类中,优先于主函数实践。

静态代码块、构造代码块】构造函数同期设有时的实行各样:
静态代码块、构造代码块构造函数

1、成员变量的开首化

  • 字节型(byte)              0
  • 短整数(short)             0
  • 整数型(int)               0
  • 长整数型(long)            0l
  • 单精度小数(float)         0.0f
  • 双精度小数(double)        0.0d
  • 字符型(char)              ‘\u0000′(空)
  • 布尔型(boolean)           false
  • 别的体系(All type)        null
c.封装
  • OOP3大特点之壹。
  • 概念:指隐藏独享的属性和落到实处细节,仅对外提供公共访问格局。
  • 包装的利润:将扭转隔断、便于使用、进步重用性、提升安全性
  • 包裹原则:将没有必要对外提供的内容都躲藏起来、把品质都隐藏,提供公共艺术对其访问。
  • private:私有权力反问修饰符。用于修饰类中的成员(成员变量,成员函数),私有指只在本类中一蹴而就。仅仅是包装的1种表现格局。

d.构造函数

  • 特色:函数名与类名一样、不用定义重回值类型、不得以写return语句。
  • 作用:给指标开始化,用于对象伊始化。
  • 只顾:当1个类中一贯不概念构造函数时,那么系统会私下认可给该类参加二个空参数的构造函数,用于对象起先化。当在类中定义了初叶化构造函数,默许的构造函数就从未有过了。
  • 特征:构造函数和一般函数在写法上分化在运作上也比不上,构造函数是在指标第贰建工公司立就运维,给指标开头化。而相似方法是目的调用才实践,给是目的增加对象具有的效益多少个目的创设,构造函数值运营贰次,而相似方法能够被该对象调用多次。

//定义类
class People{
    //默认构造函数
    People(){}
}
  • 概念构造函数的时间:当对象必要分明的表征可能作为,就需求对其进展构造函数。

协会代码块

//定义类
class People{
    /**
     * 作用:给对象进行初始化
     * 特点:对象一建立就运行,而且优先于构造函数执行,针对所有的对象进行初始化都会先被执行一次。
     * 和构造函数的区别:
     *             构造代码块是给所有对象进行统一初始化。
     *             构造函数时给对应的对象进行初始化。
     * 用处:定义给不同对象的共性进行初始化。
     */
    {
        System.out.println("构造代码块");
    }
}

e.this关键字

  • 用于区分部部变量和分子变量同名情形。
  • this代表它所在的函数所属对象的引用。
  • this代表本类对象。

    private int age;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
  • 应用:当定义类中功效时,该函数内部要用到调用该函数的指标是,那时使用this来代表行使此目的。凡是本类作用内部使用了本类对象,都用this表示。

class People{
    private int age;

    /**
     * 构造函数
     * @param age
     */
    People(int age)
    {
        this.age = age;
    }
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age = age;
    }

    /**
     * 比较两个人的年龄是否相等。此处的this代表当前调用的对象的引用也就是p1。
     * @param p 人的对象变量
     * @return boolean
     */
    public boolean compare(People p)
    {
        return this.age == age;
    }


    public static void main(String[] args) {
        People p1 = new People(20);
        People p2 = new People(23);
        boolean b = p1.compare(p2);
        System.out.println("b = " + b);

    }
}
  • this与构造函数:this用与构造函数的时期相互调用。而且不得不定义在构造函数的率先行。因为初叶化要先进行

class People{
    private int age;
    private String name;

    /**
     * 空构造函数
     */
    People()
    {
    }

    /**
     * 构造函数
     * @param age
     */
    People(int age)
    {
        this();//调用People()构造函数
    }

    /**
     * 构造函数
     * @param age
     * @param name
     */
    People(int age, String name)
    {
        this(23);//调用People(int age)构造函数
        this.name = name;
    }

f.static关键字

  • static修饰符,修饰变量、方法和代码块。
  • 当成员被static修饰后,可以用类名直接调用。格式:类名.静态成员。

    static String name;

    public static void main(String[] args) {
        System.out.println("People.name = " + People.name);
    }
  • 特征:随着类的加载而加载,静态随着类的消亡而熄灭,生命周期最长、优先于对象的存在、被抱有指标所共享、能够一贯被类名所调用。
  • 实例变量和静态成员变量差距:
    A.存放位置:(壹)静态成员变量随着类的加载而存在方法区中。(二)实例变量随着对象的确立而留存于堆内部存款和储蓄器中。
    B.生命周期:(一)静态成员变量最长,随着类的消逝而未有。(2)实例变量随着对象的消解而熄灭。
  • 静态使用注意点:
    A.静态方法只可以访问静态成员(方法与变量)。非静态方法即能够访问静态也足以访问非静态。
    B.静态方法中不能定义this、super关键字。因为静态优先于对象存在。
    C.主函数是静态的。
  • 静态优缺点:
    A.优:对指标的共享数据开始展览独立空间的贮存,节省空间。能够直接被类名调用。
    B.缺:生命周期过长、访问出现局限性(只好访问静态)。

静态的施用时间:

  • 静态变量(类变量)定义:当对象中的出现对象调用的共享数据时,该数额被静态所修饰存在于方法区中;对象中的特有多少定义成非静态存在于堆内部存款和储蓄器中。
  • 静态函数定义:当类中的某些功效尚未访问到非静态数据(对象特有的多少),那么该功用可以定义成静态的(static)。
class People{
    String name;

    //没有关联到非成员变量name,那么这个函数可以设置成static的,方便后面直接通过类名调用
    public static void show()
    {
        System.out.println("没有访问到成员变量");
    }

    public static void main(String[] args) {
        //调用此方法时,与name没有关系。没有封装进数据。可以不建立对象来调用,设置成static的通过类名调用方便明了。
        People.show();
    }
}

静态代码块

  • 格式:

    static
    {
        System.out.println("静态代码块");
    }
  • 特点:随着类的加载而举行,只进行叁遍,用于给类进行初始化。并优先于主函数。

g.mian函数

public static void main(String[] args)
  • public:表示全局全数访问权限最大。也等于封装性。
  • static:表示只可以通过类调用。主函数乘机类的加载就已经存在了。
  • void:主函数未有现实重回值。
  • main:不是最主要字,特殊的七个词,能够被JVM识别。
  • String[] args:函数的参数,是2个字符串数组。

主函数是固定格式:JVM识别


h.对象初步化进度:
People p = new People("zhangsan", 23);

壹.因为new用到了People.class,所以会先找到People.class文件并加载到内部存款和储蓄器中。
2.实施该类中的static代码块,要是有些话。再给People.class类进行发轫化。
三.在堆内部存款和储蓄器中开垦空间,分配内部存储器地址。
肆.在堆内部存款和储蓄器中国建工业总会公司立指标的特有属性,并实行私下认可初阶化。
五.对质量进行体现发轫化。
六.对指标开始展览协会代码块起首化。
7.对指标开展对应的构造函数起始化。
八.将内存地址赋给内部存款和储蓄器中的引用变量p。


private关键字

是一个权力修饰符 用于修饰成员变量和分子函数 被私有化的分子只在本类中有效

常用来:
将成员变量私有化,对外提供相应的set,get方法对其开展走访,升高对数据访问的安全性

三、继承

好处:
壹、进步了代码的复用性
二、让类与类之间发生了关乎,提供了其它三个特色多态的前提。

父类的来头:
实质上正是三个类不断提高抽出共性内容而来。
java中对此接二连三,java只支持单继承,java纵然不辅助多三番五次,然而保留了这种多一连机制,进行改正。

单承袭:3个类只好有多个父类。
多一连:贰个类能够有多少个父类。
java不支持多一连的缘由:因为当壹个类同有的时候候继续多少个父类时,多少个父类中有同等的法力,那么子类对象调用该意义时,应该调用哪二个吗?
但是java支持多种承袭,A承接B、B承接C.
多种承袭的面世,就有了承袭体系。体系中的顶层父类是通过不停升华抽取而来的,它当中定义的该类别最基本最共性内容的效果。
所以,1个系统要想被选取,直接查阅该连串中的父类的功能就可以见道该系统的中心用法,那么想要使用一个体系时,须要树立指标。建议建构最子类对象。因为最子类不唯有能够接纳父类中的作用,还足以子类中特有的片段效果。
简短来讲,对于八个继续类别的使用,查阅顶层父类中的内容,创立最尾巴部分子类对象。
子分类出现后,类中成员都有了何等特征:
1、成员变量。
当子父类中冒出一样的个性时,子类类型的对象,调用该属性,值时子类的属性值。若是想调用父类中的属性值,须要采纳2个注重字:supper
this:代表是本类类型中的对象引用。
supper:代表的是子类所属的父类中的内部存款和储蓄器空间的引用。
瞩目:子父类中数见不鲜不会油然则生同名的成员变量的,因为只要父类定义了,子类就不用在概念了,直接接轨过来用就好了。
2、成员函数。
当子父类中出现同样的措施时,创建子类对象会运作等等中的方法。好像父类中的方法被遮盖掉一样。所以这种境况,是函数的另三个表征:覆盖(重写、复写)
何以时候利用覆盖呢?当二个类的法力内容供给修改时,能够透过覆盖来兑现。
3、构造函数。
察觉子类的构造函数运营时,先运转了父类的构造函数。原因是:子类的富有构造函数中的第一行,其实都有一条隐匿的super();
super():表示父类的构造函数,并会调用于参数相呼应的父类中的构造函数。而supper()是在调用父类中的空参数的构造函数。

为什么子类对象发轫化时,都要调用父类中的函数?
因为子类承袭父类,所以必要求看父类是何许对自个儿的数目开始展览初步化的,所以子类在开始展览对象早先化时,先调用父类的构造函数,那就睡子类的实例化过程。
子类中具有的构造函数都会私下认可访问父类的空参数的构造函数,因为每二个子类构造内率先行都有暗许的语句super();

假设父类中尚无空参数的构造函数,那么子类的构造函数内,必须通过super语句钦命要访问的父类中的构造函数。
一经子类构造函数中用this来钦赐调用子类自身的构造函数,那么被调用的构造函数也1致会造访父类中的构造函数。

专注:super();和this()四个语句唯有贰个定义在率先行,所以只好出现当中2个。

super和this为何一定要定义在第3行:
因为super或许this都以电泳构造函数,构造函数用于伊始化。所以开始化的动作要先产生。

延续的底细:
当类之间有is a的所属关系时,能够运用持续。
细节二:
在章程覆盖时,注意两点:
一、子类覆盖父类时,须要求确认保证,子类方法的权限必须高于等于父类的方式权限能够兑现接二连三,不然编写翻译失利。
2、覆盖时,要么都静态。要么都不静态。(静态只可以覆盖静态,只怕被静态覆盖)

承袭的三个弊病:打破了封装性。对于一些类,或然类中的效率,是索要被再而三,可能复写的。

final:
一、那几个入眼字是修饰符。能够修饰类、方法、变量。
二、被final修饰的类是3个最终类,不得以持续。
三、被final修饰的艺术是1个末尾的不二诀要,无法被遮盖。
四、被final修饰的变量是多少个常量,只可以赋值二遍。

常量定义时,全数字母都大写,假诺由多少个单词组成,中间用_连接。

抽象类:
一、抽象方法只可以定义在抽象类中,抽象类和架空方法必须由abstract关键字修饰(能够描述类和措施,不可能描述变量)
贰、抽象方法只定义方法声明,并不定义方法达成。
3、抽象类不得以被创设对象(实例化)
四、只有通过子类承继抽象类并覆盖了抽象类中的全数抽象方法后,该子类才具被实例化。不然,该子类仍旧一个抽象类。
5、抽象类的底细:
架空关键不能够和final、private、static那多少个第二字并存。
陆、抽象类中能够不定义抽象方法。抽象方法的目标是单独为了不让该类创设对象。

模板设计形式:
缓和难题:当功用内部一些完毕时规定,1部分完毕是不明确的。那时可以把不鲜明的某些暴流露来,让子类去落到实处。
模板方法设计方式:

缓慢解决的标题:当作用内部一些达成时规定,1部分兑现是不分明的。那时能够把不鲜明的有的暴暴光来,让子类去贯彻。

abstract class GetTime{

public final void getTime(){ //此功能如果不需要复写,可加final限定

    long start = System.currentTimeMillis();

    code(); //不确定的功能部分,提取出来,通过抽象方法实现

    long end = System.currentTimeMillis();

    System.out.println("毫秒是:"+(end-start));

}

public abstract void code(); //抽象不确定的功能,让子类复写实现

}

class SubDemo extends GetTime{

public void code(){ //子类复写功能方法

    for(int y=0; y<1000; y++){

        System.out.println("y");

    }

}

}

2、函数的重载

在同八个类中,允许存在三个之上的同名函数,只要它们的参数个数大概参数类型分裂就能够。(只和参数列表有涉及)

//返回两个整数的和
int add(int x, int y){return x+y;}
//返回三个整数的和
int add(int x,int y, int z){return x+y+z;}
//返回两个小树的和
double add(double x, double y){return x+y;}
i.继承
  • 面向对象特征之二。
  • 把目标间的共性特征举行收取,类与类之间有关系,最终抽象成一个共性类,被抽出的类的持续自那么些共性类就可。减少代码量,提升复用性。
  • 形式:

继承类 extends 被继承类
  • Java只支持单承接。支持多层传承:B继承A,D承继B。D类能够采用A类的功力。
  • 一连关系中类成员的性情:
    A.
    变量:若是子类中冒出非私有的同名变量时,子类要访问本类中的变量,用this。子类要拜访父类中的同名变量,用super,super跟this的使用大概相同。super代表父类对象的引用,this代表本类对象引用。

/**
 * Created by Sergio on 2014/11/2.
 */
public class ExtendsDemo1 {
    public static void main(String[] args) {
        Sun s = new Sun();
        s.show();
    }
}

class Parents{
    int num = 5;
}

//子继承父类
class Sun extends Parents{
    int num = 4;
    void show()
    {
        System.out.println(num);//访问的是子类的变量,相当于this.num
        System.out.println(super.num);//碰到同名变量可以使用super关键字访问父类的变量。
    }
}

B.
函数:当父类出现和子类完全一样的函数时,当子类对象调用该函数,会运作子类函数的从头到尾的经过,就如父类的函数被遮盖掉。那也叫做覆盖(重写)。

/**
 * Created by Sergio on 2014/11/2.
 */
public class ExtendsDemo1 {
    public static void main(String[] args) {
        Sun s = new Sun();
        s.show();
    }
}

class Parents{
    int num = 5;
    void show()
    {
        System.out.println("被覆盖");
    }
}

//子继承父类
class Sun extends Parents{
    int num = 4;
    void show()
    {
        System.out.println(num);//访问的是子类的变量,相当于this.num
        System.out.println(super.num);//碰到同名变量可以使用super关键字访问父类的变量。
    }
}

覆盖注意点:子类覆盖父类,必须保障子类权限大于等于父类权限,才得以叫覆盖,不然编写翻译战败。静态只好覆盖静态。
C.
构造函数:在对子类对象举行早先化时,父类的构造函数也会运作,那是因为子类的构造函数暗中同意第一行有一条隐式的语句super()[会造访父类中空参数的构造函数。而且子类中颇具的构造函数暗中认可第一行都是super();];

/**
 * Created by Sergio on 2014/11/2.
 */
public class ExtendsDemo2 {
    public static void main(String[] args) {
        Sun2 s2 = new Sun2(2);
        System.out.println(s2.x);//访问的是父类抽取的x = 4;
    }
}

class Parents2{
    int x = 4;
    Parents2()
    {
        System.out.println("fu run");
    }

    Parents2(int x)
    {
        System.out.println("x = " + x);
    }
}

//子继承父类
class Sun2 extends Parents2{
    Sun2()
    {
        //super();隐式的构造函数
        super(1);//根据父类构造函数来指定
        System.out.println("zi run");
    }

    Sun2(int x)
    {
        super(3);//根据父类构造函数来指定
        System.out.println("zi run");
    }
}

super语句一定定义在子类构造函数的率先行,开始化动作要先做。子类的兼具的构造函数,私下认可都会访问父类中空参数的构造函数,因为子类每贰个构造函数的率先行都有一句隐式super();当父类中从不空参数的构造函数时,子类必须手动通过super语句方式来钦命要拜访的构造函数。子类的构造函数第叁行也得以手动钦赐this语句来访问本类中的构造函数。子类中足足会有叁个构造函数会访问父类中的构造函数。


构造函数

函数名与类名同样 不用定义再次回到值类型 没有切实可行的重回值

功能:给指标举办伊始化

package study_java.ex01;

public class ConstructDemo1 {

    public static void main(String[] args){
        Dog d = new Dog("aa");
        d.watch();
    }
}

class Dog{
    private String name;
    private String color;

    // 构造函数
    public Dog(String n){
        name = n;
        System.out.println("new Dog()");
    }

    public void watch(){
        System.out.println("旺旺");
        System.out.println(name);
    }

}

组织代码块也是类成员,是为构造函数增添共有的有些情节并且构造函数先于构造函数实践

对象的创导进度: 当new叁个目的的时候

  • 在内个存中分配内部存款和储蓄器空间
  • 对成员变量赋暗中同意值
  • 试行协会代码块或赋值语句,试行各类从上到下实践
  • 构造函数

三、函数的包裹

包装:是指隐藏对象的本性和贯彻细节,仅对外提供公用访问格局。

public class Person {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
j. final关键字
  • 解释:最终。修饰符。
  • 修饰的限制:类、函数、变量。
  • 特色:被final修饰的类不得以被一而再,为了制止被再而三,被子类复写功能。
  • final类:被final修饰的类不得以复写。
  • final变量:被final修饰的变量是贰个常量只好赋值一遍,既能够修饰成员变量,又能够修饰局地变量。
  • 选取的时候。描述事物时,一些多少的产出值是一向的。可以用一个常量来代表。
  • 命名:常量的书写标准全数字母都大写。假如有几个单词定义,每一个单词通过”_”链接。P_AI。比如PI。

静态代码块

动用static修饰的代码构造块,在类加载的时候调用二回,现在不再调用。
经常放置对静态成员的初叶化进度

static成员,跟对象毫无干系,访问的办法是通过Class.XXX()

一.二、构造函数

  • 对象第二建工公司立就能够调用与之绝对应的构造函数(方法),用来给目的实行开首化。
  • 类中有定义构造函数则采用定义的构造函数,没概念构造函数则系统自动增多无参构造函数。
  • 构造函数未有回来值类型,不得以被接续,但是能够透过super语句调用父类的构造函数。

瞩目:未有回去值类型不平等 void,void 也是一种回到值类型。无法利用
return 关键字重临任何值。

k. 抽象类
  • 八个类出现一样效果,可是意义宗旨差别,举办发展收取,只抽出功用定义,而不收取功用核心。
  • 概念形式:abstract 类名带有抽象方法和非抽象方法、abstract 方法名();泛泛方法唯有法子名从未办法内容。
  • 留意:抽象方法只设有于抽象类中。抽象类不得以用new制造对象,因为调用抽象方法未有意义。抽象方法要被选拔,必须由子类复写全体的架空方法后,创设子类对象调用;假如子类只覆盖了壹部分虚幻方法,那么该子类依旧三个抽象类,因为虚无方法只设有于抽象类中。
  • 抽象类不能实例化,没意义。

this关键字

this:代表其所在函数所属对象的引用,即this代表类对象的引用

1、this和super

this:

  • this代表本类对象的引用,何人调用this所在函数,this就象征何人。
  • 被this所调用的变量一定是成员变量。
  • 个中类中访问外部类的分马时,格式: 外部类名.this.成员名
    。(内部类具备外部类的引用)
  • this能够作为实际参数举行传递。
  • 二1010二线程中同步函数使用的锁是this。

this语句和super语句

this语句只可以定义在构造函数的率先行,用于构造函数之间张开互动调用。

super语句代表父类引用,会访问父类的构造函数(子类全部构造函数第二行有隐式的super语句)。

l. 接口
  • 格式:interface 接口名{}。接口中定义常量、方法固定修饰符如下(修饰符可以简轻松单,interface会自动抬高。):
    A. 常量:public static final
    B. 方法:public abstract
    接口中的成员都是public。接口中的方法都以虚幻的。

/**
 * Created by Sergio on 2014/11/3.
 */
interface InterfaceDemo {
    public static final int NUM = 3;//变量定义
    public abstract void intefaceDemo();//方法定义
}


//接口必须被子类实现用关键字implements,接口可以被多个子类实现。子类也可以继承于一个父类。必须将接口中的所有方法实现因为接口中的方法都是抽象的
class InterfaceTest extends ExtendsDemo2 implements InterfaceDemo,InterfaceDemo2....{
    @Override
    public void intefaceDemo() {

    }
}

接口是不能创制对象的,因为有抽象方法存在。必要被子类实现,覆盖接口中的抽象方法后,子类才足以实例化,否则子类是1个抽象类。
接口与接口之间的关系是一连关系,支持多一而再关系。

  • 接口特点:
    -. 接口是对外揭穿的平整
    -. 接口是先后的作用增添
    -. 接口能够用来多完成
    -. 类与接口之间是促成关系,而且类能够持续1个类的还要落到实处多个接口
    -. 接口与接口之间可以有承接关系

static 关键字

用以修饰成员(成员变量和分子函数)

被修饰后的成员具备以下特征: 随着类的加载而加载 优先于对象存在
被全部的靶子所共享 能够直接被类名调用

应用注意: 静态方法只能访问静态成员 静态方法不能够写this,super关键字
主函数是静态的

代码例子如下:

package study_java.ex01;

public class StaticDemo1 {
    public static void main(String[] args){
        System.out.println(Benz.brand1);

        Benz b1 = new Benz();
        System.out.println(b1.getBrand());

        // 直接访问静态方法
        System.out.println(Benz.getBrand1());
    }
}

class Benz{
    // 静态成员
    private static String brand = "BENZ";

    public static  String brand1 = "BENZ1";

    private String color;

    public void setColor(String color){
        this.color = color;
    }

    public String getBrand(){
        return brand;
    }

    public static String getBrand1(){
        return brand;
    }
}

this(): 调用任何构造函数的主意,而且必须作为第2条语句

2、两种成员变量开头化情势

★通过构造函数先河化

class Person {
    private String name;
    //构造函数初始化
    Person(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
}

★通过get和set方法实行起始化。

class Person{
    private String name;
    //get方法
    public void setName(String name){
        this.name = name;
    }
    //set方法
    public String getName(){
        return name;
    }
}
m. 多态与根本字instanceof

一. 概念

  • 面向对象特征之三
  • 概念:事物存在的二种反映形象。举例人分成:男子、女孩子。人 r = new
    男士(); 人 r贰 = new 女孩子();

贰. 多态扩充性

  1. 多态的反映:父类的引用指向了自身的子类对象(父类)。
  2. 多态的前提:类与类之间有提到,有持续恐怕完成。
  3. 多态的益处:多态的出现增进了先后的扩充性,日常有前提条件是:存在覆盖。
  4. 多态的坏处:只可以利用父类的引用访问父类中的成员。
  5. 多态中成员的特征:
    • 非静态成员函数:
      a.
      在编写翻译时代:参加引用型变量所属的类中是不是有调用的情势,纵然有编写翻译通过,倘使未有编写翻译退步。
      b. 在运维时期:插手对象所属的类中是或不是有调用的主意。
      总计正是:成员函数在多态调用时,编写翻译看左侧,运维看左侧。
    • 分子变量:
      甭管编写翻译和周转:都参照右边(引用型变量所属的类)
    • 静态成员函数(子类不掩盖父类方法,父类走父类,子类走子类。变量也1律。):
      随意编译和平运动作:都参照左侧

/**
 * Created by Sergio on 2014/11/19.
 */
public class PolymorphicDemo {
    public static void main(String[] args) {
        //调用子类覆盖父类的eat()方法,有局限性在这点上
        function(new Dog());
        function(new Pig());
    }

    //定义共性的功能方法eat()
    public static void function(Animal a)
    {
        a.eat();
    }
}

/**
 * 集中抽象功能的父类Animal
 */
abstract class Animal{
    abstract void eat();
}


/**
 * 定义Dog类继承之Animal父类,并且拥有自己的特定功能类houseKeeping().
 */
class Dog extends Animal{
    //覆盖父类eat()方法
    public void eat()
    {
        System.out.println("Dog.eat");
    }

    //子类特有的方法
    public void houseKeeping()
    {
        System.out.println("看家");
    }
}


/**
 * 定义Pig类继承之Animal父类,并且拥有自己的特定功能类fat().
 */
class Pig extends Animal{
    //覆盖父类eat()方法
    public void eat()
    {
        System.out.println("Pig.eat");
    }

    //子类特有的方法
    public void fat()
    {
        System.out.println("养膘");
    }
}

叁. 父类、子类类型转型

/**
 * Created by Sergio on 2014/11/19.
 */
public class PolymorphicDemo {
    public static void main(String[] args) {
        //类型提升,向上转型。将Dog类型提升为Animal类型
        Animal a = new Dog();
        a.eat();

        /**
         * 如果要调用子类特有的方法操作:强制将父类的引用转成子类类型,向下转型.将父类a引用强制转换成子类类型Dog。
         *
         * 注意:不能将父类对象转成子类类型。能转换的是父类指向了自己的子类对象时,该引用可以被提升也可以强制转换。
         * 多态始终都是子类在作者变化。
         */
        Dog d = (Dog)a;
        d.houseKeeping();

        //fun函数调用子类对象的功能
        fun(new Dog());
        fun(new Pig());
    }

    //提炼共性函数特征fun(Animal a)
    public static void fun(Animal a)
    {
        a.eat();

        /**
         * 判断传递进来的子类是那个对象的。使用关键字instanceof,判断左边对象是否属于右边类的实例,返回boolean
         * 类型数据。
         *
         * instanceof是一个二元操作符。使用的前提:1.子类型有限、2.对象需要做比较首先判断是否属于某个类的实例
         */
        if (a instanceof Dog){
            Dog d = (Dog)a;
            d.houseKeeping();
        }
        else if(a instanceof Pig)
        {
            Pig p = (Pig)a;
            p.fat();
        }
    }
}

/**
 * 集中抽象功能的父类Animal
 */
abstract class Animal{
    abstract void eat();
}


/**
 * 定义Dog类继承之Animal父类,并且拥有自己的特定功能类houseKeeping().
 */
class Dog extends Animal{
    //覆盖父类eat()方法
    public void eat()
    {
        System.out.println("Dog.eat");
    }

    //子类特有的方法
    public void houseKeeping()
    {
        System.out.println("看家");
    }
}


/**
 * 定义Pig类继承之Animal父类,并且拥有自己的特定功能类fat().
 */
class Pig extends Animal{
    //覆盖父类eat()方法
    public void eat()
    {
        System.out.println("Pig.eat");
    }

    //子类特有的方法
    public void fat()
    {
        System.out.println("养膘");
    }
}

四:小示例

package com.sergio.lianxi;

/**
 * Created by Sergio on 2014/11/20.
 *
 * 需求:电脑运行实例。电脑运行基于主板。
 */
public class PolymorphicDemo2 {
    public static void main(String[] args) {
        MotherBoard mb = new MotherBoard();
        mb.run();
        mb.usePCI(new SoundCard());
    }

}

/**
 * 电脑的各种部件基于电脑主板上的pci接口运行。模拟PCI接口。
 */
interface PCI{
    public void open();
    public void close();
}

//定义主板,运行的基础
class MotherBoard{
    public void run(){
        System.out.println("主板运行");
    }

    public void usePCI(PCI p)//接口型引用指向自己的子类对象
    {
        if(p != null)
        {
            p.open();
            p.close();
        }
    }
}


/**
 * 需要运行部件实现方式
 */
class SoundCard implements PCI
{
    @Override
    public void open() {
        System.out.println("声卡运行");
    }

    @Override
    public void close() {
        System.out.println("声卡关闭");
    }
}

继承

七个类中留存同样的性质和作为时,将这么些剧情抽出到独门一个类中,那么四个类没有要求再定义那些属性和表现,只要继续这么些类就能够。

八个类称得上子类,单独那些类称为父类
子类能够从来访问父类中夏族民共和国非私有的品质和办法
通过extends关键字让类与类之间时有爆发持续 java中只帮助单冲承接 + 多层承接

总结的事例:

package study_java.ex01;

public class ExtendsDemo1 {

    public static void main(String[] args){
        JingBa jingba = new JingBa();
        jingba.name = "大黄";
        jingba.watch();
        jingba.owner="zz";
    }


}


class Animal{
    public String name;
    public int weight;
    public void move(){
        System.out.println("move.....");
    }
}

class Dog extends Animal{
    public void watch(){
        System.out.println("有人来了");
    }
}

class JingBa extends Dog{
    public String owner;
}

1.3、静态

二.设计情势

super关键字

调用的是父类的构造函数,必须是率先条语句 通过上边例子领会:

package study_java.ex01;

public class ExtendsDemo2 {

    public static void main(String[] args){
        // 创建对象
        BMWSportCar mychar = new BMWSportCar();
        mychar.color = "red";
        mychar.velocity = 200;
        mychar.price = 20000;
        mychar.run();

    }
}

class Car{
    public String color;
    public void run(){
        System.out.println("running.....");
    }

    public Car(String color){
        this.color = color;
        System.out.println("new car("+color+")");
    }
}

class SportCar extends Car{
    public int velocity;
    public SportCar(int velocity){
        super("yellow");
        this.velocity = velocity;
        System.out.println("new SportCar("+velocity +")");
    }
}

class BMWSportCar extends SportCar{
    public int price;

    public BMWSportCar(){
        super(200);
        System.out.println("new BMWSportCar");
    }
}

假定被三番五次的父类的特性是个人的,借使想要访问依然改换,可以因此定义公有的主意来落到实处,代码例子如下:

package study_java.ex01;

public class ExtendsDemo2 {

    public static void main(String[] args){
        // 创建对象
        BMWSportCar mychar = new BMWSportCar();
        mychar.setColor("red");
        mychar.velocity = 200;
        mychar.price = 20000;
        mychar.run();
        System.out.println(mychar.getColor());

    }
}

class Car{
    //私有属性
    private String color;
    public void run(){
        System.out.println("running.....");
    }

    public Car(){

        System.out.println("new car()");
    }
    // 公有方法
    public String getColor(){
        return color;
    }
    public void setColor(String color){
        this.color = color;
    }
}

class SportCar extends Car{
    public int velocity;
    public SportCar(){
        System.out.println("new SportCar()");
    }
}

class BMWSportCar extends SportCar{
    public int price;

    public BMWSportCar(){
        System.out.println("new BMWSportCar");
    }
}

super和this的用法有一点相像

  • this代表本类对象的引用
  • super代表父类的内部存款和储蓄器空间的标志
  • 子类要调用父类构造函数时,能够应用super()语句
  • 当子类和父类出现同名成员时,能够用super举办区分

super()和this()

调用父类的构造函数,必须是首先条语句

package study_java.ex01;

public class ExtendsDemo2 {

    public static void main(String[] args){
        // 创建对象
        BMWSportCar mychar = new BMWSportCar();
        mychar.setColor("red");
        mychar.velocity = 200;
        mychar.price = 20000;
        mychar.run();
        System.out.println(mychar.getColor());

    }
}

class Car{
    //私有属性
    private String color;
    public void run(){
        System.out.println("running.....");
    }

    public Car(){

        System.out.println("new car()");
    }
    // 公有方法
    public String getColor(){
        return color;
    }
    public void setColor(String color){
        this.color = color;
    }
}

class SportCar extends Car{
    public int velocity;
    public SportCar(){
        System.out.println("new SportCar()");
    }
    public void setColorPro(String color){
        // this.color = color;  //这里和下面的的super是一样的
        super.setColor(color);
    }

    public void setColor(String color){
        super.setColor(color);
    }

}

class BMWSportCar extends SportCar{
    public int price;

    public BMWSportCar(){
        System.out.println("new BMWSportCar");
    }
}

其余叁个对象的始建都包含全部家族簇的始建,任何2个分子的创导,都包含这一全勤顺序的达成通过下边代码驾驭这一个进度

package study_java.ex01;

public class ExtendsDemo3 {
    public static void main(String[] args){
        // 创建对象
        BMWSportCar mychar = new BMWSportCar();
        mychar.setColor("red");
        mychar.velocity = 200;
        mychar.price = 20000;
        mychar.run();
        System.out.println(mychar.getColor());

    }
}

class Car{
    //私有属性
    private String color;

    {
        System.out.println("Cons Block in Car");
    }

    public void run(){
        System.out.println("running.....");
    }

    public Car(){

        System.out.println("new car()");
    }
    // 公有方法
    public String getColor(){
        return color;
    }
    public void setColor(String color){
        this.color = color;
    }
}

class SportCar extends Car{
    public int velocity;

    {
        System.out.println("Cons Block in SportCar");
    }
    public SportCar(){
        System.out.println("new SportCar()");
    }
    public void setColor(String color){
        super.setColor(color);
    }

}

class BMWSportCar extends SportCar{
    public int price;

    public BMWSportCar(){
        System.out.println("new BMWSportCar");
    }
}

壹、静态方法和静态成员

(壹)用于修饰成员(成员变量,成员函数).

(二)能够被对象调用外,还足以被类名调用。(类名.静态成员).

静态成员变量和静态方法都以随着类的加载而记载,生命周期长,它预先于对象存在,被全体指标所共享,能够通过类名间接调用。

分子变量和类变量的界别:

(一)类变量随着类的加载而存在于方法区中。

(2)成员变量随着对象的创设而留存堆内存中。

(叁)类(静态变量)变量生命周期最长,随着类的无影无踪而消亡。

(二)成员变量生命周期随着对象的消灭而未有。

注意事项

  • 静态方法只好访问静态成员,非静态方法能够访问静态成员,也得以访问非静态成员。
  • 静态方法中不得以用super,this等重大字。(因为静态先于对象存在)
  • 主函数是静态的。
单例设计形式
  • 设计格局概念:化解某一类难题最可行的章程,能够再度使用。java有二三种设计格局。
  • 单例情势:只对外提供3个实例。在内部存款和储蓄器中只存在3个对象。
  • 三要素:(一)在类体中必要具备静态的民用的本类型的变量、(二)构造方法必须是私有的,不容许实例化、(三)提供3个公家的静态的入口方法。

package com.sergio.lianxi;

/**
 * 单例模式饿汉式。
 * 第一种方式。类一进内存就建立对象。
 * Created by Sergio on 2014/10/10.
 */
public class SinglePattern {
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "SinglePattern{" +
            "age=" + age +
            '}';
    }

    //以下三个方法是单例使用的必须写法
    /**
     * 静态私有化本类的成员变量
     */
    private static SinglePattern instance = new SinglePattern();

    /**
     * 私有化构造方法,禁止对象实例化
     */
    private SinglePattern(){}

    /**
     * 对外提供一个公共的静态入口方法
     */
    public static SinglePattern getInstance()
    {
        return instance;
    }
}

class SinglePatternTest
{
    public static void main(String[] args) {

        SinglePattern s1 = SinglePattern.getInstance();
        SinglePattern s2 = SinglePattern.getInstance();
        s1.setAge(23);
        System.out.println("s2 = " + s2);
    }
}

package com.sergio.lianxi;

/**
 * Created by Sergio on 2014/10/10.
 * 单例模式懒汉式。也叫延迟加载式。只有调用了getInstance方法时,才建立对象
 */
public class SinglePattern2 {
    private static SinglePattern2 instance = null;
    private SinglePattern2(){}
    public static synchronized SinglePattern2 getInstance()
    {
if
        if(instance == null)
        {
            instance = new SinglePattern2();
        }
        return instance;
    }
}

留意:开拓时候使用饿汉式,也正是第贰种。

函数覆盖

子类中冒出与父类中大同小异的秘籍时,会产出覆盖操作,也称为重写大概复写
父类中的私有方法不能被覆盖
在子类覆盖形式中,继续选取被遮住的艺术能够通过super函数名获得

蒙面时要求注意的标题: 覆盖时,子类方法权限一定要抢先等于父类方法权限
静态只可以覆盖静态

重在的行使是:
当子类需求父类的法力,而效果大旨子类有自身特有的内容时,能够复写父类中的方法,那样就既沿袭了父类
的功能,又定义了父类特有的原委

代码例子:

package study_java.ex01;

public class OverrideDemo1 {
    public static void main(String[] args){
        Rich2Man s2 = new Rich2Man();
        s2.consume(200000);
    }
}

class RichMan{
    public void consume(int money){
        if(money < 500){
            System.out.println("消费了"+money+"w");
        }
        else {
            System.out.println("不能消费了");
        }

    }
}

class Rich2Man extends RichMan{
    public void consume(int money){
        if(money < 50000){
            System.out.println("消费了"+money+"w");
        }
        else {
            System.out.println("不能消费了");
        }

    }
}

二、构造代码块和构造函数

布局代码块在目的创造时,会先行于构造函数的调用,所以一般用来给指标进行初阶化。

public class Person {
    {
        // 共性语句
    }
}

结构代码块和构造函数的差异:

(一)构造代码块是给具备目的举办统1初步化。

(贰)构造函数是给相应对象开始展览初步化。

(叁)构造代码块中定义的是见仁见智对象共性的伊始化内容。

静态代码块

public class Person {
    static{
        // 静态代码块中的执行语句
    }
}

脾性:随着类的加载而举行,只进行二遍,优先于主函数和构造函数。给类实行伊始化。

父类静态代码块 -> 子类静态代码块-> 父类非静态代码块 ->
父类构造函数-> 子类非静态代码块 -> 子类构造函数

静态代码块只在首先次创造对象时奉行,之后不再奉行,而非静态代码块在每便创设对象都实行。

子类的实例化进程

子类中具备的构造函数morning都会造访父类中空参数的构造函数
因为每贰个构造函数的率先行都有一条默许的语句super()
子类会具有父类中的数据,所以要先明了父类是怎么着对那么些数量初叶化的。
当父类中从来不空参数的构造函数时,子类的构造函数必须经过this或然super语句内定要访问的构造函数

1.4、继承

final 关键字

final 能够修饰类,方法和变量

final 修饰的类不得以被一连

final 修饰的办法不能被覆盖(可以再三再四)

final 修饰的变量是一个常量只好被赋值一次

内部类只可以访问被final修饰的部分变量

 

package study_java.ex01;

public class FinalDemo1 {
    public static void main(String[] args){
        Jing8 j = new Jing8();
        j.watch();
        System.out.println(j.name);
    }
}

class Dog1{
    // 常量
    public final String name = "aaa";

    // final 修饰的方法不能重写
    public /*final */ void watch(){
        System.out.println("来人了");
    }
}

class Jing8 extends Dog1{
    public void watch() {
        System.out.println("听一听");
        super.watch();
    }
}

有关内部类 定义在class内部的类 编写翻译产生OuterClass$Innerc.class
内部类访问外部类的片段变量,须要final修饰

代码例子:

package study_java.ex01;

public class InnerClassDemo {
    public static void main(String[] args){
        Car2 c = new Car2();
        c.run();
    }
}

class Car2{
    public String color = "red";
    public int tires;

    public void run(){
        new Engine().fire();
        System.out.println("running.....");
    }

    class Engine{
        public void fire(){
            System.out.println("fire");
        }
    }
}

只是假如内部类写在了办法里,这里有二个难题亟待小心:

public class InnerClassDemo {
    public static void main(String[] args){
        Car2 c = new Car2();
        c.run();
    }
}

class Car2{
    public String color = "red";
    public int tires;

    public void run(){
        // 这里的key必须是final 字段
        final String key = "ss";
        class Engine{
            public void fire(){
                System.out.println("插入钥匙"+key);
                System.out.println("fire");
            }
        }
        new Engine().fire();
        System.out.println("running.....");
    }


}

一、承接介绍

接轨的益处是,提升代码的复用性,让类和类之间发生子父关系,java只协助单传承,但是足以多种承继。

public class Person {
    public void speak(){
        System.out.println("peron speak!");
    }
}
class Student extends Person {
    public void speak() {
        //super.speak(); 访问父类的speak方法
        // 实现子类自己的逻辑
    }
}

this代表的是本类引用,super代表父类的引用,能够经过this或super来访问本类或父类的分子变量或艺术。

抽象类

抽象类的概念: 抽象正是从多个东西上将共性的,本质的剧情抽出出来 java
中得以定义尚无方法体的点子,该方法的有血有肉落到实处交给子类实现该
方法称为抽象方法,包罗抽象方法的类便是抽象类

抽象类和抽象方法必须用abstract关键字修饰
抽象方法只有方法表明,未有实际的方法体,定义在抽象类中
抽象类不得以被实例化,也正是无法用new成立对象
抽象类通过其子类实例化,而子类须求覆盖掉抽象类中具备的点子后才方可创立对象,不然该子类也是抽象类

 

 

 

 

 

 

贰、函数的重写

(一) 重写:当子父类出现同名函数时,会运转子类函数的原委。

(一)
子类覆盖父类,必须确认保障子类权限大于等于父类权限才足以覆盖,不然编写翻译退步。

(二) 静态只好覆盖静态。

public class Person {

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

class Student extends Person {

    // 重写父类的方法
    @Override
    public void sing() {
        System.out.println("sing and dance");
    }
}

三、构造函数

(一) 子类全数的构造函数,暗许都会造访父类中空参数的构造函数。

(2) 子类每四个构造函数内的第一行都有一句隐式的super()。

(叁)
当父类中从不空参数的构造函数时,子类必须手动通过super语句情势来内定要访问父类中的构造函数。

注意:

(一) 子类的构造函数第一行也足以手动钦赐this语句来访问本类中的构造函数。

(二) 子类中足足会有多少个协会函数会访问父类中的构造函数。

肆、重写和重载的不一样:

1.重写是子类的方法覆盖父类的方法,须求方法名和参数都同样

二.重载是在同一个类中的几个或四个以上的诀要,方法名同样,参数列表差别,最广泛的重载的例子正是类的构造函数。

一.5、权限修饰符

壹、私有权限(private)

村办,权限修饰符:用于修饰类中的成员(成员变量,成员函数,内部类)。

(壹)私有只在本类中有效.

(二)私有仅仅是包裹表现格局的一种。

(3)提升代码健壮性。

(四)通过get和set方法访问。

2、暗许权限(default)

暗中认可的,权限修饰符:也称为同包权限,即不写任何重大字。

(1)能够修饰类,数据成员,构造函数,方法成员.

(二)同包权限的因素只可以在概念它们的类中,以及同包的类中被调用。

叁、受保险权限(protected)

受有限扶助的,权限修饰符:修饰成员变量,构造函数,成员函数,以及中间类。

(1)被protected修饰的分子,能在概念它们的类中,同包的类中被调用。

(2)被protected修饰的成员,分化包的类想调用它们,那么那一个类必须是概念它们的类的子类。

四、公共权力(public)

当众的。权限修饰符:用于修饰(类,成员变量,构造方法,成员函数)。

(1)权限最大的修饰符。

(二)public修饰的成员,能够在别的一个类中被调用。

(叁)包与包里面开始展览走访,被访问的包中的类以及类中的成员,须求public修饰。

(四)同个源文件中,被public修饰的类,必须保险和源文件名同样。

总结:

1.并不是每一种修饰符都能够修饰类(指外部类),唯有public和default能够。

2.存有修饰符都能够修饰成员变量,成员函数,构造函数。

三.为了代码安全起见,修饰符尽恐怕用private。

4.修饰符修饰的是“被访问”的权柄。

4858.com 1

1.陆、生成文书档案和工具

4858.com 2

文书档案注释

/**
  @author  作者
  @version 版本
  @param   参数
  @return  返回值
*/

1.7、接口、抽象类、枚举

1、接口

接口是外暴漏的平整,叁个类能够在延续的还要实现几个接口。

接口和接口之间能够有再三再四关系,子类达成接口后必须重写接口中的全部办法。

接口具有多态性、它不能够创设对象,也绝非构造函数,然而能够让接口引用指向子类对象。

接口中的成员都有固定修饰符:

interface IAction{
    public static final String TAG = "Iaction";
    public abstract void doSomething();
}

接口实例演示:

class Student implements IAction {
    public void doSomething() {

    }
}
interface IAction{
    public static final String TAG = "Iaction";
    public abstract void doSomething();
}

4858.com ,2、抽象类

抽象类使用abstarct修饰,抽象中能够有抽象方法或一般方法,要是2个类有二个架空方法,那么类也亟须注脚称抽象类。

架空方法是从未方法体的,相当于说它未有实际的完成。

abstract class Demo{
    // 抽象方法,没有具体实现
    public abstract void sing();
    // 普通方法,有具体实现
    public void dance(){

    }
}

final关键字

  • final能够修饰类,方法,变量。final修饰的类无法被一连,不过能够创制对象。
  • final修饰的办法不得以被遮盖,final修饰的变量是贰个常量,只好被赋值一回。
  • 佚名内部类和一些内部类只可以访问final修饰的部分变量。

final和abstract的区别:

  • final和abstract修饰类正好相反。
  • final修饰的类不可能被一连。能够创设对象。
  • abstract修饰的类能够被持续,没办法创设对象。

3、枚举

能够把有关的常量分组到1个枚举类型里,而且枚举提供了比常量越多的艺术。(JDK一.5事后)

public class TrafficLight  { 
    enum Color {
        RED, GREEN, BLANK, YELLOW
    } 
    Color color = Color.RED;
    public void change(){
        switch (color) {
        case RED:
            color = Color.GREEN;
            break;
        case GREEN:
            color = Color.YELLOW;
            break;
        case YELLOW:
            color = Color.RED;
            break;
        default:
            break;
        }
    }
}

1.8、多态

能够驾驭为东西存在种种展现情势。

延续,重写,父类引用指向子类对象。(必须父类引用指向子类对象技能够向下转型。)

壹、多态的前提

不可能不是类与类之间有涉及。要么延续,要么完成。

日常还可能有3个前提:就是存在覆盖。

便宜:多态的面世大大的提升了先后的扩大性。

弊病:提升了扩充性,可是只可以采用父类的引用访问父类中的成员。

解析:

1.因为父类是先出现的,子类有哪些他并不知道。假使强制去调用子类的特有方法,就违背了自然规律。

二.因为父类引用指向子类对象后,如若子类重写了父类的措施,那么调用的是子类所重写的艺术,所以就不能访问父类的成员了

2、向上转型:

父类 父类引用 = (父类)子类引用

Person p = new Student()
1.假设Person和Student是继承关系,都有show方法。
p.show(),访问的是子类的show方法。
2.假设Student没有重写Person的show方法。
p.show(),访问的是父类的show方法。
总结:就近原则,先找子类再找父类。

当大家想要访问子类所特有的诀要时,必须进行向下转型。

3、向下转型:

前提:向下转型的前提是父类引用指向子类对象。(也正是先有升高转型才有向下转型)。

当大家想访问子类特有措施时,要是再new子类对象的话,便是三个新指标了,不吻合自然规律。

我们能够对其进行向下转型来访问子类所特有的情势。

子类  子类引用 = (子类)父类引用
例:Student s = (Student)p
总结:多态自始至终都是子类在做变化。

其实向上和向下转型转的只是父类引用。而不是更动类型。仿照效法下边。

留神:贰个违背自然规律的操作,会并发ClassCastException

Person p = new Person();

Student s = (Student)p;

那是漏洞相当的多的,因为父类是先出现的,子类的后出现的。那几个是反其道而行之自然规律的。

纯属记住,向下转型的前提是父类引用指向子类对象。

//动物类
class Animal {
    public void eat() {
        System.out.println("Animal....eat...");
    }
}
// 猫类重写了eat方法,还有特有的catchMouse方法。
class Cat extends Animal {
    public void eat() {
        System.out.println("Cat....eat...");
    }
    // 特有抓老鼠方法
    public void catchMouse() {
        System.out.println("Cat.....CatchMouse..");
    }
}
// 狗类没有重写eat方法,只有特有的catchMouse方法。
class Dog extends Animal {
    // 特有吃骨头方法
    public void eatBoune() {
        System.out.println("Dog....eatBoune....");
    }
}
// 公开类
public class AnimalDemo {
    public static void main(String[] args) {
        // 多态特性,父类引用指向子类对象
        Animal a = new Cat();
        a.eat();// "Cat....eat..."子类(猫类)重写了父类的eat方法,调用的是子类重写的eat()方法。
        // 这时将不能调用子类(Cat)所特有的catchMouse()方法。如果想调用则必须向下转型。
        Cat c = (Cat) a;
        c.catchMouse();
        // 多态特性,父类引用指向子类对象
        Animal a1 = new Dog();
        a1.eat();// Animal....eat... 子类(狗类)没有重写父类eat方法,调用的则是父类的eat()方法。
        // 这时将不能调用子类(Cat)所特有的eatBoune()方法。如果想调用则必须向下转型。
        Dog d = (Dog) a1;
        d.eatBoune();
    }
}

小结:当子类重写了父类方法,则调用子类重写的措施。当子类未有重写父类的艺术,则调用父类的艺术。(就近原则)

1.9、内部类

类中定义的类,大家誉为内部类或嵌套类,它能够访问外部类中拥有成员(包罗个人)。

里面类具备外部类的引用所以能够一向访问外部类,外部类访问内部类则必要创制对象。

java中一同有四种内部类,静态内部类、成员内部类、局部内部类、无名氏内部类

1、静态内部类

最简便易行的里边类方式,类定义时增进static关键字,且不能够和外部类同名,只好访问外部类的静态成员或方法。

变动静态内部类对象的法子为:

OuterClass.InnerClass inner = new OuterClass.InnerClass();

静态内部类应用实例:

public class OuterClass {
    private static int a = 4;

    // 静态内部类
    static class InnerClass{
        public void test(){
            // 静态内部类只可以访问外部类的静态成员
            System.out.println(a);
        }
    }

    public static void main(String[] args) {
        OuterClass.InnerClass inner = new OuterClass.InnerClass();
        inner.test();
    }
}

2、成员内部类

成员内部类也是概念在1个类中,但是定义时无需static修饰符,它可以访问外部类的静态和非静态方法。

在外部类里面成立成员内部类的实例:

public class OtherOuterClass {
    class OuterClass {
        private int a = 1;
        // 定义一个成员内部类
        public class InnerClass {
            private int a = 8;
            public void test() {
                // 访问到的是内部类的a
                System.out.println(a);
                // 如何访问到外部类里的a呢?
                System.out.println(OuterClass.this.a);
            }
        }
    }
    // 其他类访问OuterClass的内部类
    public void show(){
        OuterClass.InnerClass inner = new OuterClass().new InnerClass();
        inner.test();
    }

    public static void main(String[] args) {

    }
}

三、局地内部类

有的内部类定义在措施中,比办法的限定还小。是当中类中用得最少的类型。

它像有个别变量同样,不可能被public、protected、private和static修饰。

唯其如此访问方法中定义的final类型的局地变量。

class OuterClass {
    int a = 1;
    public void test(){
        int b = 2;
        final int c = 3;
        // 定义一个局部内部类
        class InnerClass{
            public void show(){
                System.out.println(a);
                // 无法访问到非final的局部变量
                //System.out.println(b);
                System.out.println(c);
            }
        }

        // 创建局部内部类的实例并调用方法
        new InnerClass().show();
    }
}
public class OtherOuterClass{
    public static void main(String[] args) {
        // 创建外部类对象
        OuterClass outer = new OuterClass();
        // 调用外部类的方法
        outer.test();
    }
}

四、无名氏内部类

无名氏内部类就是没盛名字的部分内部类,不选择主要字class, extends,
implements, 没有构造方法。

佚名内部类隐式地持续了2个父类恐怕完毕了三个接口。

佚名内部类使用得比较多,平常是用作1个形式参数

abstract class AbsDemo {
    abstract void show();
}
class Oute {
    int x = 3;
    /*
     * 对其进行简化,用匿名内部类。参看下面 class Inner extends AbsDemo{ void show(){
     * System.out.println("show:"+x); } }
     */
    public void function() {
        // 简化成匿名内部类,这个整体其实是一个对象,这个其实就是AbsDemo子类的对象。所以可以调用show方法。
        new AbsDemo() {
            void show() {
                System.out.println("x=" + x);
            }
        }.show();
    }
}
class InnerClassDemo {
    public static void main(String[] args) {
        new Oute().function();
    }
}

######################################

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有