面向对象

单例设计模式：

         1.所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例

         2.如何实现？

               饿汉式VS懒汉式

        3.区分饿汉式和懒汉式

             饿汉式：

                           坏处：对象加载时间过长

                           好处：饿汉式是线程安全的

package com.exer;

/**
 * @author lwh
 * @date 2020/7/28/028
 */
//单例饿汉式实现
public class SingletonTest {
    public static void main(String[] args) {
      Bank bank=Bank.getInstance();
      Bank bank1=Bank.getInstance();
        System.out.println(bank==bank1);
    }
}
//饿汉式
class Bank{
    //.私有化类的构造器
    private Bank(){
    }
    //2.内部创建类的对象
   //4.要求此对象也必须声明为静态的
    private static Bank instance = new Bank();

    //3.提供公共静态的方法，返回类的对象
   public static Bank getInstance(){
       return instance;
   }
}

               懒汉式：

 

                           好处：延迟对象的创建

                           坏处：不安全

package com.exer;

/**
 * @author lwh
 * @date 2020/7/28/028
 */
//单例懒汉式实现
public class SingletonTest1 {
    public static void main(String[] args) {
        Order order=Order.getInstance();
        Order order1=Order.getInstance();
        System.out.println(order==order1);
    }
}
class Order{

    //私有化类的构造器
    private Order(){

     }

    //2.声明当前类对象，没有初始化
    //4.此对象也必须声明为static的
    private static Order instance = null;

    //3.声明public，static的返回当前类对象的方法
    public static Order getInstance(){
        if(instance==null){
            instance=new Order();
        }
        return instance;
    }
}

 1.面向对象思想编程内容的三条主线分别是什么

           1.）类及类的成员：属性，方法，构造器：代码块.内部类

          2.）面向对象的三大特征：封装，继承，多态

          3.）其它关键字：this，super, abstract ,intrerface, static,final, paclage, import

2.谈谈你对面向对象中类和对象的理解，并指出二者的关系？

          1） 类：抽象的，概念上的内容

          2） 对象：实实在在存在的一个个体

          3） 对象是由类派生出来的

3.面向对象思想的体现：类和对象的创建和执行操作有那三步？

          1）创建类,设计类的成员   2）创建类的对象   3）调用对象的结构：“对象.属性”，“对象.方法”

4.面向对象与面向过程（理解）

           1）面向对象：强调具备了功能的对象 已类/对象为最小单位，考虑谁来做。

           2）面向过程：强调的是功能行为，已函数为最小单位，考虑怎么做

5.面向对象中两个重要的概念

           1）类：对一类事物的描述，是抽象的，概念上的定义

           2）对象：是实际存在的该类事物的每个个体，因而也称为实例

                       >面向对象程序设计的重点是类的设计

                       >设计类，就是设计类的成员

                       >二者的关系：对象是由类派生出来的'

6.方法形参的传递机制：值传递

1.形参：方法定义时，声明的小括号内的参数

   实参：方法调用时，实际传递给形参的数据

2.值传递机制

如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。

如果参数是引用数据类型，此时实参给形参的是实参存储数据的地址值

7.为什么要引入封装性？

    我们程序设计追求 “高内聚”，“低耦合”

         高内聚：类的内部数据操作细节自己完成，不允许外部干涉；

         低耦合：仅对外暴露少量的方法用于使用。

   隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的扩展性，可维护性，通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

 

类 new对象：String ，String[] ，new对象

 构造方法 ：我们发现没有构造方法，系统会自动赠送一个无参的构造方法

名字和类名完全一样，不能有返回值，

一旦你自己定义了构造方法，系统不在提供构造方法

每个方法，定义的时候，都会默认传入两个变量

1.this this代表new出来的那个对象

2.super 当前类的父类的对象

get  set

set的意思为设置，而get的意思为获取，由此可见get()和set()两个方法分别是用来获取和设置数据的。

在使用两方法时一般的方法都是后边加上某个单词来表明将要设置或者获取的功能，比如setAge(),getName() 其含义为设置年龄，获取名字。

那么为什么要使用set(),get()方法呢？这就要涉及到java语言的封闭性和安全性，在某些类中需要用到private来修饰，这样的话其他的类不能访问这个类里边的变量，就提高了安全性

 封装，继承 （extends）

Object 顶级类 所有对象都有object的所有方法

单继承  1.一个爹可以有多个儿子     2.一个儿子只能有一个爹

java有基本类型byte short int long float double boolean char和引用类型（类，接口，zhi数组，枚举）

基础类型的包装类——八种 因为基础类型没有方法，不好操作，所有java对每一种类型进行了一次包装

 Integer是int的包装类  Integer i=new Integer(3)——Integer i=3自动装箱； String str = i.toString();

int和一些语句-循环遍历，判断组成了方法。方法和基本的数据类型和引用类型组成了类

String：字符串是引用类型，但是为什么不用new，因为太常用了,就简化了

既然是个对象就有属性和方法：

他的方法无非就是处理帮助我们方便的处理字符串

使用string必须用一个新的String接受

String name= new String("name")——String name="name";

boolean na = name.contains("na");//name里面是否包含na字符串

String substring = name.substring(1,3);//字符的下标0开始，包含前，不包含后

int length = name.length();//数字长度 4 

String split="a_b_c"

String[] s=split.split("_")//分割_打印 a b c

for(String s1 : s){ 

       System.out.println(s1);

 } 

api：就是个工具类，帮助我们看一看，java给我们写了那些类，有什么方法

 抽象类

1.不能new因为有某些方法没有方法体，这些方法就是用了来重写的，就是定义了之类必须有这些方法

2.他必须被继承才能被使用 ，必须实现所有的抽象方法

如果一个类继承了抽象类

要么，把自己声明成一个类。要么，实现抽象类的所有方法

接口

叫实现

单继承，但是是多实现。一个类可以实现多个接口。

实现接口，必须实现接口里的全部方法。接口里只能有静态常量，抽象方法