一.面向对象

    1. 概念:它是一种思想,是基于面向过程的,它研究的主体是对象.

        面向过程也是一种思想.它是以函数为基础,完成各种操作,强调的是过程.

        面向过程是以对象为基础,完成各种操作,强调的是对象.

   2.特点:

        (1)更符合人们的思维习惯.

        (2)使程序员由执行者转变为指挥者.

        (3)把复杂的事情简单化.

  3.举例:

          做饭:  

                  面向过程:自己要买菜,洗菜.烧菜.最后吃饭就可.

                  面向对象: 找一个会做饭的人,给他说要吃啥饭,最后吃饭就可以.

   4.特征:

            封装    继承   多态

   5.怎么样才能让我们的操作更符合面向对象的思想呢?
        1、分析该系统中有那些对象。
             A:名词提取法。
             B:UML统一建模语言,闫闳
        2、每个对象的功能。
        3、明确各个对象之间的关系。

   6.类与对象的关系概述:
      理解性:
              开发:就是不断的创建对象,使用对象,指挥对象做事情。
              设计:维护和管理各个对象之间的关系。
              学Java就是为了把现实世界的事物通过编程语言给体现出来。
               Java描述事物无非就是描述事物的:属性和行为。
      掌握:
             属性:外在特征。
             行为:能够做什么。
      Java语言最基本的单位是:类 。
       计算机最基本的存储单位是:字节。

       类:属性和行为的集合体,一个抽象的概念。
       对象:类的具体实现,体现。
       成员变量;属性。
        定义在类中,方法外的变量。
       成员方法:行为。
   例子: 写一个学生类:
          1、分析学生事物
              属性:姓名,年龄,性别
              行为:学习,吃饭,睡觉
          2、把分析后的学生事物转成Java中的类:
              学生类;
              成员变量:
                    姓名:name
                    年龄;age
                    性别:sex/gender
               成员方法:
                    学习:study()
                    吃饭;eat()
                  睡觉: sleep()
     如果使用学生类中的内容?
       1、想使用学生类中的内容,必须明确通过那个学生来调用。
       2、怎么明确一个的具体对象?
             通过new关键字。
                     格式:类名 对象名 = new 类名();
        3、怎么使用类中的成员(成员变量,成员方法)。
             成员变量: 对象名.成员变量;
             成员方法: 对象名.成员方法();

     怎么给成员变量赋值?
         对象名.成员变量 = 值;
  什么时候定义成员变量?
         只有能够用于描述一个类的属性的东西,才可以定义为成员变量。
  注意:
         使用变量的时候,遵循一个“就近原则”。
         会现在局部范围内找,有就使用,没有就去成员位置找,有就使用,没有就报错。(先这样记,不严谨)

   成员变量和局部变量有什么区别?
       A:定义位置不同。
               成员变量:类中,方法外。
               局部变量:方法中,或者方法的形参上。
     B:初始化值不同:
              成员变量:有默认初始化值。
              局部变量:没有默认初始化值,必须先定义,再赋值,然后才能使用。
C:存储位置不同(生命周期不同):
             成员变量:堆。随着对象的创建而存在,随着对象的消失而消失。
             局部变量:栈。随着方法的调用而存在,随着方法调用完毕而消失。

   匿名对象:
       概述:没有名字的对象。
      应用场景:
               A:当对 对象(成员)方法仅调用一次的时候。
               B:匿名对象可以作为实际参数进行传递。

二.继承extends

    1. 概念:隐藏对象的属性和实现细节,仅对外提供一个公共的访问方式。

       怎么隐藏?
              private:是一个访问权限修饰符,表示私有的意思。他可以来修饰成员变量和成员方法。
                             被它修饰的内容,在其他类中不能被直接访问。
       公共的访问方式是什么?
          set方法:赋值。
           命名格式: set+成员变量名
        举例: public void setName(String n){ name = n; }
        public void setAge(int a){ age = a; }
        get方法:取值。
       命名格式: get+成员变量名
      举例:
             public String getName()
             {
               return name;
             }
              public int getAge()
            {
            return age;
              }
      注意:
            private仅仅是封装的一种体现,咱们之前学过的类,函数都是封装的体现。
            咱们写的功能代码(比如说:判断,求和,比较最大值),必须写在函数中。

      构造方法:
         特点:
            (1)方法名必须和类名一致(包括大小写)。
            (2)没有返回值类型。
            (3)没有具体的返回值。
          作用:对对象进行初始化(创建对象的)。
     注意事项:
           (1)如果我们没写构造方法,系统会默认提供一个无参构造。
           (2)如果我们写了构造方法,系统将不再提供默认的无参构造。
               推荐:永远手动给出无参构造。
           (3)构造方法可以重载。
           就是构造方法可以接受不同类型的参数。
      一般我们定义类的时候,都会写上无参构造,
     带参构造根据需求,可写可不写,写的话,一般是带全参。
    给成员变量赋值的两种方式:
         (1)通过set方法。(推荐)
         (2)通过构造方法。

      这两种赋值方式有什么区别?
构造方法强调的是创建对象,赋值是附带功能,不能取出其中一个变量的值,

        set.get方法,强调的就是赋值,它可以取任一一个变量的值
     2.this关键字: 
        概述:代表其所在方法所属对象的引用。
        换言之:this代表本类对象的引用(记忆)。
        大白话:那个对象调用方法了,在方法内部就有一个隐含的this代表这个对象。
        应用场景:
             (1)用于解决局部变量隐藏成员变量值的问题。

       编写一个狗(Dog)的标准代码,要求如下:
      属性:姓名,年龄
       功能:定义一个功能show,能够输出狗的年龄

   代码块:
     概述:由{}扩起来的内容。
     分类:局部代码块,构造代码块
     局部代码块:
    概述:方法内部。
    作用;让变量尽可能早的从内存中消失,提高效率。
    构造代码块:
    概述:类中,方法外。
     作用:把所有构造方法的同性内容提取出来,放在构造代码块中。
     因为先执行构造代码块,后执行构造方法。

    3.static关键字:
       概述:它是一个关键字,可以用来修饰成员变量和成员方法。
       被它修饰的成员,能被该类下所有的对象所共享(资源共享)。
       举例:
       班级的钱包。
      特点:
          (1)随着类的加载而加载。
          (2)优先于对象存在的。
          (3)资源共享。
               如果某个内容是被该类下所有的对象所共享的,就可以使用静态修饰,
               没有被静态修饰的内容,其实是属于对对象的特殊描述。
           (4)直接被 类名点 的方式调用。
          注意事项:
           (1)静态方法中是没有this关键字。
          (2)静态方法只能访问静态成员变量和静态成员方法。
          (3)静态成员可以直接被类名调用,也可以被对象调用。
            推荐使用:类名点的方式调用。

   4.封装的标准代码块

  Person p = new Person();

     封装的标准代码:
      class Teacher
      {
         private String name;
         private int age;
         private static String country;
    public Teacher()
   {
   }

     public void setName(String name)
    {
      this.name = name;
    }
    public String getName()
   {
     return name;
   }

    public void setAge(int a)
   {
     this.age = age;
    }
    public int getAge()
   {
     return age;
    }
}
class TeacherTest
{
     public static void main(String[] args)
{
//创建一个Teacher类的对象,分别给姓名和年龄赋值,然后输出结果
      Teacher t = new Teacher();
       t.setName("jake");
       t.setAge(18);
      System.out.println(t.getName()+"***"+t.getAge());
}
}
三.继承

     1.概述:把多个类中的同性内容提取出来放到一个单独的类(A)中,然后让这多个类和类A产生关系,
这样,这个多个类就具备了类A的功能,这种技术,就叫继承。
格式:
class A extends B 
{

}
叫法:
类A:子类,派生类
类B:父类,基类,超类,
注意:
子类可以直接访问父类中的所有非私有成员。

案例:
父类:Person
子类:Student
class Person
{
public void show()
{
sop("nihao");
}
}
class Student extends Person 
{
public void show()
{
sop("nihaoma ?");
}
}

}
class Demo
{
Student s = new Student();
s.show();
Student s1 = new Student();
}

继承使用是需要注意 的问题是?
子类可以直接访问父类中的所有非私有成员。
子类中如果想使用父类私有的成员变量怎么办?
1、通过父类的公共访问方式。
2、通过调用父类的其他带参构造(了解)。

   2.继承的好处和特点:
好处:
(1)提高代码的复用性。
(2)让类与类之间产生一个关系,是多态的前提。
特点:
(1)Java支持单继承,不支持多继承。
(2)Java支持多层继承(继承体系)。
类A继承类B,类B还可以继承类C,类C还可以继承。。。。
   3.类的组成:
   成员变量
        使用变量,遵循一个就近原则,先在局部范围找,没有就到本类的成员位置找,如果没有就到父类的成员                        
          位置找.如果还没有,就报错。
         在子类中,想输出本类的局部变量,成员变量,父类的成员变量值,
              局部变量:直接输出。
              成员变量:this.变量名。
             父类的成员变量:super.变量名。
              如果他们的变量名不同,直接输出即可。
   this和super有什么区别?
     this:代表本类对象的引用。
     super:代表父类的内存空间标识(可以理解为父类对象的引用)。
   this和super的用法:
     成员变量;
       this.成员变量:本类的成员变量
       super.成员变量:父类的成员变量
     构造方法:
       this(参数):本类的其他构造方法。
       super(参数):父类的构造方法。
    成员方法:
       this.方法名():本类的成员方法
       super.方法名():父类的成员方法
  
方法重载和方法重写有什么区别?
     方法重载:同一个类中,出现方法名相同,参数列表不同的两个或多个方法时,即构造方法重                                
                           载。
                        方法的重载与返回值的数据类型无关。
    方法重写:子父类间,出现一模一样的方法时,被称为方法的重写,或者复写。
 注意:方法重写,要求一模一样。包括返回值的数据类型。
    方法覆盖需要注意哪些问题?
        1、父类的私有方法不能被子类重写。
        2、子类方法的访问权限一定要大于等于父类方法的访问权限。
        3、静态方法只能被静态方法重写。(这个不算子类间对象的成员关系)
    方法重写的应用场景:
        当子类需要使用父类的某个功能,并且在这个功能的主体上需要加入自己特有内容的时候,
        就可以考虑使用方法的重写,这样,即沿袭了父类的功能,又加入了自己的功能。

     构造方法
        子父类间构造方法的执行顺序:
        子类的所有构造方法默认都去访问了父类的无参构造,
         原因是,子类的所有构造方法之前有一行默认的代码:super();
         为什么要这样做呢?
             子类默认具备了父类的非私有数据,而父类的数据的初始化是靠父类自己来完成的。
             所以在子类的构造方法执行前,需要先执行父类的构造方法对父类数据进行初始化。
     如果父类没有无参构造怎么办?
           1、通过super(参数)的形式来调用,父类的其他带参构造。
           2、通过this(参数)的形式来调用本类的其他带参构造。
      一个关于代码块的面试题:
            父类的构造方法,子类的构造方法
            父类的构造代码块,子类的构造代码块
            父类的静态代码块,子类的静态代码块。
    如果子父类都有静态代码块,构造代码块,构造方法,那么他们之间的执行顺序是什么?
          父类的静态代码块  -- 》子类的静态代码块 --》 父类的构造代码块 --》父类的构造方法
            --》 子类的构造代码块 --》子类的构造方法

    final关键字:
      概述:它是一个关键字,表示最终的意思,它可以修饰类,成员变量,成员方法。
        它修饰的类,不能被继承,但是可以继承其他类。
       它修饰的成员变量,其实是一个常量。
      常量的分类:
            字面值常量; 123,32,"Hello"
            自定义常量:格式跟咱们定义变量一样,加一个final即可。

           它修饰的成员方法,不能被子类重写。

  四.多态
(1)对象在不同时刻表现出来的不同状态。
举例:狗(狗、宠物、动物)
(2)多态的前提
A:要有继承或者实现关系。
B:要有方法的重写/实现。
C:要有父类引用或者父接口引用指向子类对象。

注意:多态有三种体现形式
类多态
抽象类多态
接口多态
(3)多态中的成员特点:
A:成员变量
编译看左边,运行看左边。
B:成员方法
编译看左边,运行看右边。

为什么?因为方法存在重写,而变量没有。

举例:孔子扮父。
(4)多态的弊端:
父类(接口)引用不能使用子类特有功能。
为了解决这个弊端,我们需要向下转型。

Fu f = new Zi(); //向上转型
Zi z = (Zi)f; //向下转型

Zi z = new Zi();
(5)多态的好处:
可以提高代码的扩展性和可维护性。

2:抽象类
(1)如果多个类中存在相同的方法声明,而方法体不一样,我们就可以只提取方法声明。
  如果一个方法只有方法声明,没有方法体,那么这个方法必须用抽象修饰。
  而一个类中如果有抽象方法,这个类必须定义为抽象类。
(2)抽象类的特点
A:抽象类和抽象方法必须使用abstract修饰
B:抽象类不能被实例化
C:抽象类有构造方法,用于子类实例化使用
D:如果一个类是抽象类,那么,继承它的子类
要么是抽象类。
要么重写所有抽象方法。
(3)抽象类的成员特点
A:成员变量 可以变量,也可以是常量
B:构造方法 有构造方法
C:成员方法 可以有抽象方法,也可以有非抽象方法(全是抽象方法或者非抽象方法都是可以的)
(4)抽象类的几个小问题
A:抽象类不能被实例化,为什么有构造?
用于子类实例化使用。
B:一个类没有抽象方法,为什么定义为抽象类?
不想被实例化,或者是抽取出来的一个规则类
C:abstract不能和哪些关键字共存。
final
private
static

3:接口
(1)如果一个抽象类中的方法都是抽象的,这个时候,java就提供了一种
  更抽象的表示形式:接口。
  接口:interface
  实现:implements

  格式:
interface 接口名{}

class 类名 implements 接口名 {}
(2)接口的特点:
A:接口不能被实例化。
B:一个类如果实现了接口:
要么是抽象类。
要么实现接口中的所有方法。
(3)接口的成员特点:
A:成员变量 只能是常量。默认修饰符 public static final
B:成员方法 只能是抽象方法。默认修饰符 public abstract
(4)接口的思想特点:
A:对外暴露的规则
B:是功能的扩展
C:降低耦合度
耦合:类与类的关系
内聚:类自己完成某件事情的能力

高内聚,低耦合。
D:接口可以多实现。
(5)类,接口的关系
A:类与类
继承关系,只能单继承,可以多层继承。
B:类与接口
实现关系,可以单实现,也可以多实现。
还可以在继承一个类的同时实现多个接口。
C:接口与接口
继承关系,可以单继承,也可以多继承。
(6)抽象类和接口的关系?自己补齐。
                接口是一种特殊的抽象类,比抽象类更抽象,因为它里

技术
©2019-2020 Toolsou All rights reserved,
LinkedHashMap基本用法&使用实现简单缓存 dedecms网站被黑 劫持到其他网站如何解决苹果不送充填器耳机真为环保?可能还是为了赚钱吧图片格式转换错误总结-myBatis plus 分页numpy:多维数组的创建用C语言做很简单的飞机游戏Keras保存与加载模型(JSON+HDF5)福布斯中国汽车富豪榜:何小鹏第11 李想第14 李斌第15hive大量小文件处理方法总结