2017.8.8

1:成员变量和局部变量的区别(理解)

(1)在类中的位置不同    成员变量：类中方法外    局部变量：方法定义中或者方法声明上(2)在内存中的位置不同    成员变量：在堆中    局部变量：在栈中(3)生命周期不同    成员变量：随着对象的创建而存在，随着对象的消失而消失    局部变量：随着方法的调用而存在，随着方法的调用完毕而消失(4)初始化值不同    成员变量：有默认值    局部变量：没有默认值，必须定义，赋值，然后才能使用

---

2:封装(理解)

    A:隐藏实现细节，提供公共的访问方式    B:提高代码的复用性    C:提高代码的安全性    D：隐藏实现细节，提供公共的访问方式    E：private是封装的一种体现。(3)设计原则    把不想让外界知道的实现细节给隐藏起来，提供公共的访问方式

---

为什么要封装（理解）？

---

1.将数据封装起来更容易维护代码。2.将相关联的变量和函数封装起来，变量描述对象的属性，函数描述对象的行为，这更符合我们对客观世界的认识。3.限制了数据访问，提高了代码数据的安全性。

---

构造方法：

1.方法名与类名相同。2.没有返回值类型，连void都没有。3.没有返回值

---

static（理解）:静态变量，可以修饰成员变量，成员方法。

---

1.随着类的加载而加载。2.优先于对象存在3.被类的所以对象所共享4.可以通过类名调用。

---

静态变量和成员变量的区别（理解）：

    A:所属不同        静态变量：属于类，类变量        成员变量：属于对象，对象变量，实例变量    B:内存位置不同        静态变量：方法区的静态区        成员变量：堆内存    C:生命周期不同        静态变量：静态变量是随着类的加载而加载，随着类的消失而消失        成员变量：成员变量是随着对象的创建而存在，随着对象的消失而消失    D:调用不同        静态变量：可以通过对象名调用，也可以通过类名调用        成员变量：只能通过对象名调用

---

继承的理解（必须理解）

---

概述：把多个类中相同的成员变量和成员方法给提取出来定义到一个独立的类中，然后让多个类和该独立的类产生关系。

好处：

    A:提高了代码的复用性    B:提高了代码的维护性    C:让类与类之间产生了关系，是多态的前提    类与类产生了关系，其实也是继承的一个弊端：    类的耦合性增强了。    开发的原则：低耦合，高内聚。    耦合：类与类的关系    内聚：就是自己完成某件事情的能力

继承的注意事项：

    A:子类只能继承父类所有非私有的成员(成员方法和成员变量)    B:子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。    C:不要为了部分功能而去继承    D：从一定意义上说打破了封装性

案列：

---

class Person {//姓名private String name;//年龄private int age;public Person() {}public Person(String name,int age) { //"老子",88    this.name = name;    this.age = 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;}

}

//定义学生类

class Student extends Person {public Student() {}public Student(String name,int age) { //"孔子",44    //this.name = name;    //this.age = age;    super(name,age);}}

---

//定义老师类class Teacher extends Person {}

---

class ExtendsTest4 {public static void main(String[] args) {    //创建学生对象并测试    Student s1 = new Student();    s1.setName("哈哈");    s1.setAge(17);    System.out.println(s1.getName()+"---"+s1.getAge());    Student s2 = new Student("呵呵",22);    System.out.println(s2.getName()+"---"+s2.getAge()); }}

1：方法重写和方法重载的区别?方法重载能改变返回值类型吗?

方法重写：    在子类中，出现和父类中一模一样的方法声明的现象。方法重载：    同一个类中，出现的方法名相同，参数列表不同的现象。

---

1:final关键字(掌握)

    (1)是最终的意思，可以修饰类，方法，变量。    (2)特点：        A:它修饰的类，不能被继承。        B:它修饰的方法，不能被重写。        C:它修饰的变量，是一个常量。

---

多态（理解+掌握）

---

概述：同一个对象在不同时刻体现出不同的状态。

案列

猫是猫，猫是动物。水（固态，液态，气态）    水(液体，固体，气态)。

多态的前提：

          要有继承和实现关系          有方法的重写          有父类指或者父类接口引用指向子类对象。

---

多态的分类：

        a:具体类多态            class Fu {}            class Zi extends Fu {}            Fu f = new Zi();        b:抽象类多态            abstract class Fu {}            class Zi extends Fu {}            Fu f = new Zi();        c:接口多态            interface Fu {}            class Zi implements Fu {}            Fu f = new Zi();

(4)多态的好处：

    A:提高代码的维护性(继承体现)    B:提高代码的扩展性(多态体现)

(5)多态的弊端：

    父不能使用子的特有功能。

---

案列：（猫狗）

动物类

class Animal {    public void eat(){        System.out.println("eat");    }    public void sleep(){        System.out.println("sleep");    }}

---

狗类：
class Dog extends Animal {
public void eat(){
System.out.println(“狗看家”);
}

    public void sleep(){        System.out.println("蹲着睡觉吧！");    }}

---

猫类：

class Cat extends Animal {    public void eat() {        System.out.println("猫偷鱼");    }    public void sleep() {        System.out.println("猫横着睡觉");    }}

---

//针对动物操作的工具类

class AnimalTool {private AnimalTool(){}/*//调用猫的功能public static void useCat(Cat c) {    c.eat();    c.sleep();}//调用狗的功能public static void useDog(Dog d) {    d.eat();    d.sleep();}public static void useAnimal(Animal a) {    a.eat();    a.sleep();}}

---

测试类

class DuoTaiDemo2

{public static void main(String[] args) {    //猫1    Cat c = new Cat();    c.eat();    c.sleep();    //猫2    Cat c2 = new Cat();    c2.eat();    c2.sleep();    //猫3    Cat c3 = new Cat();    c3.eat();    c3.sleep();    //...    System.out.println("--------------");    //useCat(c);    //useCat(c2);    //useCat(c3);    //AnimalTool.useCat(c);    //AnimalTool.useCat(c2);    //AnimalTool.useCat(c3);    AnimalTool.useAnimal(c);    AnimalTool.useAnimal(c2);    AnimalTool.useAnimal(c3);    System.out.println("--------------");    //我喜欢狗    Dog d = new Dog();    Dog d2 = new Dog();    Dog d3 = new Dog();    //AnimalTool.useDog(d);    //AnimalTool.useDog(d2);    //AnimalTool.useDog(d3);    AnimalTool.useAnimal(d);    AnimalTool.useAnimal(d2);    AnimalTool.useAnimal(d3);    System.out.println("--------------");    //猪    //定义一个猪类，它要继承自动物，提供两个方法，并且还得在工具类中添加该类方法调用    Pig p = new Pig();    Pig p2 = new Pig();    Pig p3 = new Pig();    //AnimalTool.usePig(p);    //AnimalTool.usePig(p2);    //AnimalTool.usePig(p3);    AnimalTool.useAnimal(p);    AnimalTool.useAnimal(p2);    AnimalTool.useAnimal(p3);    System.out.println("--------------");}/*//调用猫的功能public static void useCat(Cat c) {    c.eat();    c.sleep();}//调用狗的功能public static void useDog(Dog d) {    d.eat();    d.sleep();}}

---

抽象（理解+掌握）

---

抽象的概念：

抽象是从众多的事物中抽取出共同的、本质性的特征，而舍弃其非本质的特征。例如苹果、香蕉、生梨、葡萄、桃子等，它们共同的特性就是水果。得出水果概念的过程，就是一个抽象的过程

抽象的语法遵循：

　  1、一个类中如果有抽象方法，则这个类必须是抽象类。　　2、抽象类中可以没有抽象方法。　　3、抽象类是不能存在实例对象的，换句话说就是抽象类就是为了被继承而存在的。　　4、一个子类如果继承了抽象类，必须实现抽象类中定义的所有抽象方法。　　5、抽象类可以继承抽象类，可以不重写父类的方法。

---

案列：
abstract不能和哪些关键字共存?

private 冲突final   冲突  static  无意义

---

接口

---

接口是：是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现

java接口的用处主要体现在下面几个方面：

　　（1）通过接口可以实现不相关类的相同行为，而不需要了解对象所对应的类。　　（2）通过接口可以指明多个类需要实现的方法。　　（3）通过接口可以了解对象的交互界面，而不需了解对象所对应的类。

---

接口的用途：

实现类的多继承，以解决Java只能单继承，不支持多继承的问题（理解好了有很大的帮助）

(2)接口的特点：

    A:接口用关键字interface修饰        interface 接口名 {}    B:类实现接口用implements修饰        class 类名 implements 接口名 {}    C:接口不能实例化    D:接口的实现类        a:是一个抽象类。        b:是一个具体类，这个类必须重写接口中的所有抽象方法。

3接口的成员特点：
A:成员变量
只能是常量
默认修饰符：public static final
B:构造方法
没有构造方法
C:成员方法
只能是抽象的
默认修饰符：public abstract

---

类与类,类与接口,接口与接口

    A:类与类        继承关系，只能单继承，可以多层继承    B:类与接口        实现关系，可以单实现，也可以多实现。        还可以在继承一个类的同时，实现多个接口    C:接口与接口        继承关系，可以单继承，也可以多继承

---

抽象类和接口的区别：

A:成员区别    抽象类：        成员变量：可以变量，也可以常量        构造方法：有        成员方法：可以抽象，也可以非抽象    接口：        成员变量：只可以常量        成员方法：只可以抽象B:关系区别    类与类        继承，单继承    类与接口        实现，单实现，多实现    接口与接口        继承，单继承，多继承`

---

object类的简单讲解：

每个班都有Object作为超类。 所有对象（包括数组）都实现了这个类的方法
每个类都直接或者间接继承object类

Object()是无参构造所以很多类访问的无参构造

object的一些常用的方法：

clone() 创建并返回此对象的副本。  boolean equals(Object obj) 指示一些其他对象是否等于此。  protected void finalize() 当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象。  getClass() 返回此 Object的运行时类。  int hashCode() 返回对象的哈希码值。 void notify() 唤醒正在等待对象监视器的单个线程。 void notifyAll() 唤醒正在等待对象监视器的所有线程。  String toString() 返回对象的字符串表示形式。  void wait() 导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法。  void wait(long timeout) 导致当前线程等待，直到另一个线程调用 notify()方法或该对象的 notifyAll()方法，或者指定的时间已过。  void wait(long timeout, int nanos) 导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法，或者某些其他线程中断当前线程，或一定量的实时时间。 

---

String的简单运用

String类的概述和使用(掌握)

(2)构造方法：    A:public String()    B:public String(byte[] bytes)    C:public String(byte[] bytes,int offset,int length)    D:public String(char[] value)    E:public String(char[] value,int offset,int count)    F:public String(String original)

---

A:==和equals()

        String s1 = new String("hello");        String s2 = new String("hello");        System.out.println(s1 == s2);// false        System.out.println(s1.equals(s2));// true        String s3 = new String("hello");        String s4 = "hello";        System.out.println(s3 == s4);// false        System.out.println(s3.equals(s4));// true        String s5 = "hello";        String s6 = "hello";        System.out.println(s5 == s6);// true        System.out.println(s5.equals(s6));// true

B:字符串的拼接

        String s1 = "hello";        String s2 = "world";        String s3 = "helloworld";        System.out.println(s3 == s1 + s2);// false        System.out.println(s3.equals((s1 + s2)));// true

---

String的判断功能

---

String类的判断功能：

 * boolean equals(Object obj):比较字符串的内容是否相同,区分大小写 *  * boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写 *  * boolean contains(String str):判断大字符串中是否包含小字符串 *  * boolean startsWith(String str):判断字符串是否以某个指定的字符串开头 *  * boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾 *  * boolean isEmpty():判断字符串是否为空。 * 

---

String的获取功能

---------- * int length():获取字符串的长度。 *  * char charAt(int index):获取指定索引位置的字符 *  * int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。 *      为什么这里是int类型，而不是char类型? *       *      原因是：'a'和97其实都可以代表'a' *       * int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。 *  * int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。 *  * int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。 *  * String substring(int start):从指定位置开始截取字符串,默认到末尾。

---