面向对象基础学习

2017.01.28

1) 面向对象(面向对象思想概述)(了解)

2) 面向对象(类与对象概述)(掌握)

３) 面向对象(学生类的使用)(掌握)

４) 面向对象(成员变量和局部变量的区别)(掌握)

D:初始化值不同

注意事项：

５) 面向对象(方法的形式参数是类名的时候如何调用)(掌握)

６) 面向对象(匿名对象的概述和应用)(掌握)

７) 面向对象(封装的概述)(掌握)

A:封装概述

B:封装好处

８) 面向对象(private关键字的概述和特点)(掌握)

９) 面向对象(this关键字的概述和应用)(掌握)

2017.01.29

1）面向对象(构造方法Constructor概述和格式)(掌握)

2）面向对象(构造方法的重载及注意事项)(掌握)

3）面向对象(给成员变量赋值的两种方式的区别)

B:构造方法

这两种方式使用setXXX更加方便，因为比较灵活

4） 面向对象(static关键字的特点)(掌握)

A:static关键字的特点

d:可以通过类名调用

class Demo_Person {    public static void main(String[] args) {        Person.country = "日本";        ...    }}class Person {    static String country;    ... }
e、共性用静态，单个个性用动态
5） 面向对象(static的注意事项)(掌握)
A:static的注意事项 a:在静态方法中是没有this关键字的 如何理解呢? 静态是随着类的加载而加载，this是随着对象的创建而存在。静态比对象先存在。b:静态方法只能访问静态的成员变量和静态的成员方法 静态方法：  成员变量：只能访问静态变量成员方法：只能访问静态成员方法非静态方法： 成员变量：可以是静态的，也可以是非静态的成员方法：可是是静态的成员方法，也可以是非静态的成员方法。简单记： 静态只能访问静态。
6）　面向对象(静态变量和成员变量的区别)(掌握)
静态变量也叫类变量  成员变量也叫对象变量A:所属不同 静态变量属于类，所以也称为为类变量成员变量属于对象，所以也称为实例变量(对象变量)B:内存中位置不同 静态变量存储于方法区的静态区成员变量存储于堆内存C:内存出现时间不同 静态变量随着类的加载而加载，随着类的消失而消失成员变量随着对象的创建而存在，随着对象的消失而消失D:调用不同 静态变量可以通过类名调用，也可以通过对象调用成员变量只能通过对 象名调用
７) 面向对象(main方法的格式详细解释)(了解)
A:格式 public static void main(String[] args) {}B:针对格式的解释 public 被jvm调用，访问权限足够大。static 被jvm调用，不用创建对象，直接类名访问void被jvm调用，不需要给jvm返回值main 一个通用的名称，虽然不是关键字，但是被jvm识别String[] args 以前用于接收键盘录入的
8) 面向对象(工具类中使用静态)(了解)
A:制作一个工具类 ArrayTool1,获取最大值2,数组的遍历3,数组的反转4,如果一个类中所有的方法都是静态的，需要多做一步，私有构造方法 private ArryTool() {}目的是不让其他类创建本类对象，直接用类名.调用即可
9) 面向对象(说明书的制作过程)(了解)
A:对工具类加入文档注释B:通过javadoc命令生成说明书 @author(提取作者内容)@version(提取版本内容)javadoc -d 指定的文件目录 -author -version ArrayTool.java@param 参数名称//形式参数的变量名称@return 函数运行完返回的数据
10) 面向对象(如何使用JDK提供的帮助文档)(了解)
A:找到文档，打开文档B:点击显示，找到索引，出现输入框C:你应该知道你找谁?举例：ScannerD:看这个类的结构(需不需要导包) 成员变量  字段构造方法  构造方法成员方法  方法
11) 面向对象(学习Math类的随机数功能)(了解)
打开JDK提供的帮助文档学习A:Math类概述 类包含用于执行基本数学运算的方法B:Math类特点 由于Math类在java.lang包下，所以不需要导包。因为它的成员全部是静态的,所以私有了构造方法C:获取随机数的方法 public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。D:我要获取一个1-100之间的随机数，肿么办? int number = (int)(Math.random()*100)+1; 
2017.01.30
1） 面向对象(代码块的概述和分类)(了解)
A:代码块概述 在Java中，使用{}括起来的代码被称为代码块。B:代码块分类 根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。C:常见代码块的应用 a:局部代码块  在方法中出现；限定变量生命周期，及早释放，提高内存利用率b:构造代码块 (初始化块) 在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行，即优先执行构造代码块！c:静态代码块  随着类的加载而加载，只执行一次在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。一般用于加载驱动静态代码块优先于主方法执行！
2） 面向对象(继承案例演示)(掌握)
A:继承(extends) 让类与类之间产生关系,子父类关系 B:继承案例演示： 动物类,猫类,狗类定义两个属性(颜色,腿的个数)两个功能(吃饭，睡觉)C:案例
class Demo1_Extends {    public static void main(String[] args) {        Cat c = new Cat();        c.color = "花";        c.leg = 4;        c.eat();        c.sleep();        System.out.println("color = " + c.color + " , leg = " + c.leg);    }}class animal {    String color;    int leg;    public void eat() {        System.out.println("eating...");    }    public void sleep() {        System.out.println("sleeping...");    }}class Cat extends animal {}
3） 面向对象(继承的好处和弊端)(掌握)
A:继承的好处 a:提高了代码的复用性b:提高了代码的维护性c:让类与类之间产生了关系，是多态的前提
B:继承的弊端
类的耦合性增强了。
开发的原则：高内聚，低耦合。
耦合：类与类的关系内聚：就是自己完成某件事情的能力
4） 面向对象(Java中类的继承特点)(掌握)
A:Java中类的继承特点 a:Java只支持单继承，不支持多继承。(一个儿子只能有一个爹) 有些语言是支持多继承，格式：extends 类1,类2,…b:Java支持多层继承(继承体系)B:案例演示 Java中类的继承特点 如果想用这个体系的所有功能用最底层的类创建对象如果想看这个体系的共性功能,看最顶层的类 
5） 面向对象(继承的注意事项和什么时候使用继承)(掌握)
A:继承的注意事项 a:子类只能继承父类所有非私有的成员（public）(成员方法和成员变量)b:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。c:不要为了部分功能而去继承项目经理 姓名 工号 工资 奖金程序员   姓名 工号 工资
B:什么时候使用继承
继承其实体现的是一种关系：”is a”。
Person StudentTeacher水果 苹果香蕉橘子
采用假设法。
如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。
6） 面向对象(继承中成员变量的关系)(掌握)
A:案例演示 a:不同名的变量b:同名的变量 子类父类在开发中是不允许出现同名变量的，子类继承父类就是为了使用父类的成员
7） 面向对象(this和super的区别和应用)(掌握)
A:this和super都代表什么 this:代表当前对象的引用,谁来调用我,我就代表谁super:代表当前对象父类的引用B:this和super的使用区别 a:调用成员变量 this.成员变量 调用本类的成员变量,也可以调用父类的成员变量super.成员变量 调用父类的成员变量b:调用构造方法 this(…) 调用本类的构造方法super(…)    调用父类的构造方法c:调用成员方法 this.成员方法 调用本类的成员方法,也可以调用父类的方法super.成员方法 调用父类的成员方法
8） 面向对象(继承中构造方法的关系)(掌握)
A:案例演示
子类中所有的构造方法默认都会访问父类中空参数的构造方法 
 class Demo4_Extends { public static void main(String[] args) {     Son s = new Son(); } }class Father {    public Father() {        System.out.println(“Father 构造方法…”);    }}class Son extends Father {    public Son() {                      //相当于在此处加了super();        System.out.println(“Son 构造方法…”);    }}相当于在子类空参构造中加上 super(); ，就算不写，系统也会默认加上！ 
B:为什么呢?
因为子类会继承父类中的数据，可能还会使用父类的数据。
所以，子类初始化之前，一定要先完成父类数据的初始化。
其实：
每一个构造方法的第一条语句默认都是：super() Object类最顶层的父类。
9) 面向对象(继承中构造方法的注意事项)(掌握)
A:案例演示 父类没有无参构造方法,子类怎么办?super解决this解决 
 class Son extends Father { public Son() {     //super(null,0);            //使用super解决     this(null,0);               //使用this解决     System.out.println("Son 空参构造"); } ... } B:注意事项 super(…)或者*this(….)必须出现在构造方法的第一条语句上*
10) 面向对象(继承中成员方法关系)(掌握)
A:案例演示 a:不同名的方法b:同名的方法
B:解决方法 
super可以调用父类的成员属性和方法 
 class Demo6_Extends { public static void main(String[] args) {     Son s = new Son();     s.print();     s.method(); } }class Father {    public void print() {        System.out.println(“Fu print”);    }}class Son extends Father {    public void print() {        super.print();                  //super可以调用父类的成员属性和方法        System.out.println(“Zi print”);    }public void method() {    System.out.println("Zi method");}}
11） 面向对象(方法重写概述及其应用)(掌握)
A:什么是方法重写 重写:子父类出现了一模一样的方法(注意:返回值类型可以是子父类,这个我们学完面向对象讲) B:方法重写的应用： 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容。
C:案例演示 
a:定义一个手机类。 
 class Demo7_Phone { public static void main(String[] args) {     Ios8 i = new Ios8();     i.siri();           //增加ios8的说中文和ios7的Speak English     i.call();           //调用ios7的call的功能 } }class Ios7 {    public void call() {        System.out.println(“Calling…”);    }public void siri() {    System.out.println("Speak English...");}}class Ios8 extends Ios7 {    public void siri() {        super.siri();        System.out.println(“说中文…”);    }}
12) 面向对象(方法重写的注意事项)(掌握)
A:方法重写注意事项
a:父类中私有方法不能被重写 因为父类私有方法子类根本就无法继承b:子类重写父类方法时，访问权限不能更低 最好就一致
c:父类静态方法，子类也必须通过静态方法进行重写
其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解(静态只能覆盖静态)
子类重写父类方法的时候，最好声明一模一样。
B:案例演示 方法重写注意事项
13) 面向对象(方法重写的面试题)(掌握)
A:方法重写的面试题
Override(重写)和Overload（重载）的区别?Overload能改变返回值类型吗?
overload可以改变返回值类型,只看参数列表
方法重写：子类中出现了和父类中方法声明一模一样的方法。与返回值类型有关,返回值是一致(或者是子父类)的
方法重载：本类中出现的方法名一样，参数列表不同的方法。与返回值类型无关。
子类对象调用方法的时候：
先找子类本身，再找父类。
14） 面向对象(使用继承前和使用继承后的学生和老师案例)(掌握)
A:案例演示 使用继承前的学生和老师案例属性:姓名,年龄行为:吃饭老师有特有的方法:讲课学生有特有的方法:学习B:案例演示 使用继承后的学生和老师案例
15） 面向对象(final关键字修饰类,方法以及变量的特点)(掌握)
A:final概述B:final修饰特点 修饰类，类不能被继承修饰变量，变量就变成了常量，只能被赋值一次修饰方法，方法不能被重写C:final修饰特点 final 修饰常量一般会与 public static 相修饰，组成public static final int NUM = …，这样做的好处是可以直接通过类调用。
16） 面向对象(final关键字修饰局部变量)(掌握)
基本类型，是值不能被改变
引用类型，是地址值不能被改变,对象中的属性可以改变
class Demo10_Final {    public static void main(String[] args) {        final int NUM = 10;        //NUM = 20;        System.out.println("NUM = " + NUM);    final Person p = new Person("张三",34);    //p = new Person("李四",44);          //不能再次创建对象    p.setName("李四");                    //可以对已创建的对象的属性进行赋值    p.setAge(55);    System.out.println("name : " + p.getName() + " , age : " + p.getAge());    method(20);    method(45);}public static void method(final int x) {        //将x改变为final类型    System.out.println(x);}}class Person {    private String name;    private int age;public Person() {}      //无参构造public Person(String name,int age) {        //有参构造    this.name = name;    this.age = age;}public void setName(String name) {    this.name = name;}public String getName() {    return this.name;}public void setAge(int age) {    this.age = age;}public int getAge() {    return this.age;}}
17） 面向对象(final修饰变量的初始化时机)(掌握)
A:final修饰变量的初始化时机 显示初始化 在对象构造完毕前即可
17.02.01
1）面向对象(package关键字的概述及作用)(了解)
A:为什么要有包 将字节码(.class)进行分类存放 包其实就是文件夹B:包的概述
举例：     学生：增加，删除，修改，查询     老师：增加，删除，修改，查询     …
方案1：按照功能分    com.heima.add        AddStudent        AddTeacher    com.heima.delete        DeleteStudent        DeleteTeacher    com.heima.update        UpdateStudent        UpdateTeacher    com.heima.find        FindStudent        FindTeacher方案2：按照模块分    com.heima.teacher        AddTeacher        DeleteTeacher        UpdateTeacher        FindTeacher    com.heima.student        AddStudent        DeleteStudent        UpdateStudent        FindStudent
2） 面向对象(包的定义及注意事项)(掌握)
A:定义包的格式 package 包名;多级包用.分开即可B:定义包的注意事项 A:package语句必须是程序的第一条可执行的代码B:package语句在一个java文件中只能有一个C:如果没有package，默认表示无包名C:案例演示 包的定义及注意事项
3） 面向对象(带包的类编译和运行)(掌握)
A:如何编译运行带包的类 a:javac编译的时候带上-d即可 javac -d . HelloWorld.java(不要忘记有一个点！)b:通过java命令执行。 java 包名.HellWord
4）面向对象(import关键字的概述和使用)(掌握)
A:案例演示 为什么要有import 其实就是让有包的类对调用者可见,不用写全类名了 B:导包格式 import 包名;注意：这种方式导入是到类的名称。虽然可以最后写*，但是不建议。C:package,import,class有顺序关系
5）面向对象(四种权限修饰符的测试)(掌握)
A:案例演示 四种权限修饰符B:结论（访问范围）
  
本类
  
同一个包下(子类和无关类)
  
不同包下(子类)
  
不同包下(无关类)
  
private
  
Y
  
  
  
默认
  
Y
  
Y
  
  
protected
  
Y
  
Y
  
Y
  
public
  
Y
  
Y
  
Y
6）面向对象(类及其组成所使用的常见修饰符)(掌握)
A:修饰符： 权限修饰符：private，默认的，protected，public状态修饰符：static，final抽象修饰符：abstract
B:类：
权限修饰符：默认修饰符，public状态修饰符：final
抽象修饰符：abstract
用的最多的就是：public
C:成员变量：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
用的最多的就是：private
D:构造方法：
权限修饰符：private，默认的，protected，public
用的最多的就是：public
E:成员方法：
权限修饰符：private，默认的，protected，public状态修饰符：static，final
抽象修饰符：abstract
用的最多的就是：public
F:除此以外的组合规则：
成员变量：public static final成员方法： public static public abstractpublic final
7） 面向对象(内部类概述和访问特点)(了解)
A:内部类概述B:内部类访问特点 a:内部类可以直接访问外部类的成员，包括私有。b:外部类要访问内部类的成员，必须创建对象。外部类名.内部类名 对象名 = 外部类对象.内部类对象;C:案例演示 内部类极其访问特点
8） 面向对象(静态成员内部类)(了解)
staticB:成员内部类被静态修饰后的访问方式是: 外部类名.内部类名 对象名 = 外部类名.内部类对象;
9）面向对象(成员内部类的面试题)(掌握)
A:面试题要求：使用已知的变量，在控制台输出30，20，10。class Outer {    public int num = 10;    class Inner {        public int num = 20;        public void show() {            int num = 30;            System.out.println(?);            System.out.println(??);            System.out.println(???);        }    }}class InnerClassTest {    public static void main(String[] args) {        Outer.Inner oi = new Outer().new Inner();        oi.show();    }   }？：num？？：this.num？？？：Outer.this.num（内部类之所以能获取到外部类的成员，这是因为它能获取到外部类的引用：外部类.this）
10）面向对象(局部内部类访问局部变量的问题)(掌握)
A:案例演示
局部内部类访问局部变量必须用final修饰
局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么? 因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用
但是jdk1.8取消了这个事情,所以我认为这是个bug
11）面向对象(匿名内部类的格式和理解)
A:匿名内部类 就是内部类的简化写法。B:前提：存在一个类或者接口 这里的类可以是具体类也可以是抽象类。C:格式：     new 类名或者接口名(){         重写方法;     }D:本质是什么呢? 是一个继承了该类或者实现了该接口的子类匿名对象。匿名内部类适用于只重写一个方法的时候使用
12）面向对象(匿名内部类在开发中的应用)
A:代码如下//这里写抽象类，接口都行abstract class Person {    public abstract void show();}class PersonDemo {    public void method(Person p) {        p.show();    }}class PersonTest {    public static void main(String[] args) {        //如何调用PersonDemo中的method方法呢?        PersonDemo pd = new PersonDemo ();    }}