黑马程序员_java面向对象总结

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

1：面向对象:

       (1)面向对象是相对应面向过程而言的一种编程思想，是基于面向过程的。

       (2)思想特点：

              A:是一种更符合我们思考习惯的思想。

              B:把复杂的事情简单化。

              C:让我们从执行着变成了指挥者。

       (3)案例：

A:买电脑：只需要把钱给懂电脑行情的人，就可以拿到电脑。省掉选机器，还价的过程

              B:吃饭：去餐馆，不用自己买菜，洗菜，做饭等过程

       (4)把大象装进冰箱，让大家对面向对象有一点点的了解。

              面向过程：

class Demo {
				public static void main(String[] args) {
					open();
					in();
					close();
				}
				public static void open() {
					System.out.println("开门");
				}
				public static void in() {
					System.out.println("我要进去");
				}
				public static void close() {
					System.out.println("关门");
				}
			}

 

面向对象：

                    如何让我们的代码更符合面向对象思想

                            A:有哪些类

                            B:类有哪些功能

                            C:类与类的关系

class 大象 {
				public void in() {
					System.out.println("我要进去");
				}
			}
			class 冰箱 {
				public void open() {
					System.out.println("开门");
				}
				public void close() {
					System.out.println("关门");
				}
			}
			class Test {
				public static void main(String[] args) {
					冰箱 b = new 冰箱();
					大象 d = new 大象();
					b.open();
					d.in();
					b.close();
				}
			}

 

2：类与对象的关系:

       (1)现实世界的事物：

              属性：事物的特征

              行为：事物的功能

       (2)java中最基本的单位是类。所以，我们要把事物转换为对应的类。

       (3)如何转换呢：

              类           事物

              成员变量       属性

              成员方法       行为

              成员变量：属性，字段

              成员方法：函数，方法

       (4)类与对象的概念

              类：是一组相关的属性和行为的抽象的集合体。

              对象：是该类事物的具体存在的个体。

              类：学生

              对象：小明

3：类与对象的使用:

       学生类的制作和使用

class Student{
	String name;
	int age;
	String gender;
	public void study(){
		System.out.println("我要学习");
	}
	public void eat(){
		System.out.println("我要吃饭");
	}
}
class StudentDemo{
	public static void main(String[] args){
		Student stu=new Student();
		s.name="小明";
		s.age=18;
		System.out.println(s.name+"---"+s.age);
		s.study();
		s.eat();
	}
}

 

4：内存图:

       (1)一个对象的内存图：

              一个对象的基本初始化过程。

       (2)二个对象的内存图：

              方法的共用。

       (3)三个对象的内存图：

              两个引用变量指向同一个对象。

5：成员变量和局部变量的区别?

       (1)在类中的位置不同：

              成员变量：类中方法外。

              局部变量：方法中或者方法声明上。

       (2)在内存中的位置不同：

              成员变量：堆中。

              局部变量：栈中。

       (3)生命周期不同：

              成员变量：随着对象的存在而存在，随着对象的消失而消失。

              局部变量：随着方法的调用而存在，随着方法的调用完毕而消失。

       (4)初始化值不同；

              成员变量：有默认初始化值。

              局部变量：没有默认初始化值。

       问题：

              成员变量和名称可以不可和局部变量一样呢?

                    可以。

class Demo {
			int x = 10;
			public void show() {
				int x = 20;
				System.out.println(x);
			}
			public void method() {
				System.out.println(x);
			}
		}

第二部分：

1:变量什么时候该定义成员变量:

       (1)如果变量和类之间存在这描述性的关系，就该定义为成员变量。

       (2)注意：

              变量的定义范围越小越好。

2:引用类型作为形式参数和返回值:

       (1)顾客点菜案例。

              顾客--服务员--厨师

       (2)引用类型作为参数和返回值的问题：

              A:如果一个方法的形式参数是一个类名，那么，这里肯定需要的是该类的对象。

              B:如果一个方法的返回值是一个类名，那么，这里返回的肯定是该类的对象。

              class Demo {

                     public void printStudent(Student s) {

                            s.show();

                     }

                     public Student getStudent() {

                            Student s = new Student();

                            return s;

                     }

              }

3:匿名对象:

       (1)就是没有名字的对象。

       (2)应用场景：

              A:调用方法。但是仅仅只调用一次的时候使用。

              B:作为实际参数传递。

                     Demo d = new Demo();

                     d.printStudent(new Student());

4:封装:

       (1)隐藏实现细节，提供公共的访问方式。

       (2)体现有哪些呢?

              A:类

              B:方法体

              C:private修饰成员变量

       (3)private关键字：

              是私有的意思。可以修饰类中的成员变量和成员方法。

              注意：被它修饰的成员只能在本类中被访问。

       (4)标准代码：

              class Student {

                     private String name;

                     private int age;

                     public void setName(String n) {

                            name = n;

                     }

                     public String getName() {

                            return name;

                     }

                     public void setAge(int a) {

                            age = a;

                     }

                     public int getAge() {

                            return age;

                     }

              }

5:构造方法:

       (1)创建对象，并对对象的内容进行初始化。

       (2)特点：

              A:方法名和类名相同。

              B:没有返回值类型。

              C:没有返回值。

       (3)注意事项：

              A:如果我们没给构造方法，系统给出一个默认构造。无参构造。

              B:如果我们给出了构造方法，系统将不再提供构造方法。

                    这个时候，要么我们不使用无参构造方法。

                    要么，自己定义一个，然后使用。

                    推荐：自己给出无参构造方法。

       (4)给成员变量赋值的方式：

              A:无参+setXxx()

              B:带参

       (5)获取值：

              getXxx()

       (6)标准代码：

              class Student {

                     private String name;

                     private int age;

                     public Student() {}

                     public Student(String n,int a) {

                            name = n;

                            age = a;

                     }

                     public void setName(String n) {

                            name = n;

                     }

                     public String getName() {

                            return name;

                     }

                     public void setAge(int a) {

                            age = a;

                     }

                     public int getAge() {

                            return age;

                     }

              }

6：this关键字。:

       (1)代表当前类的一个对象。谁调用代表谁。

       (2)应用场景：

              A:使用本类的成员变量:

                     this.变量名;

              B:使用本类其他构造方法

                     this(...)

              C:使用本类的其他成员方法

                     this.方法名();

       (3)标准代码：

              class Student {

                     private String name;

                     private int age;

                     public Student() {}

                     public Student(String name,int age) {

                            this.name = name;

                            this.age = age;

                     }

                     public void setName(String name) {

                            this.name = name;

                     }

                     public String getName() {

                            return name;

                     }

                     public void setAge(int age) {

                            this.age = age;

                     }

                     public int getAge() {

                            return age;

                     }

              }

              测试类：

                     Student s = new Student();

                     s.setName("小明");

                     s.setAge(27);

                     System.out.println(s.getName()+"---"+s.getAge());

                     Student ss = new Student("小明",27);

                     System.out.println(ss.getName()+"---"+ss.getAge());

      

7：static关键字:

       (1)是静态的意思，可以修饰类中成员变量和成员方法。

       (2)静态的特点：

              A:随着类的加载而加载。

              B:优先于对象存在。

              C:被所有对象共享的数据。

                    这个也被我们作为为什么要使用静态的一个判断条件。

                    举例：饮水机和水杯。

              D:让我们的调用多了一种方式：

                     a:非静态的数据，必须创建对象访问。

                     b:静态的数据，可以通过对象访问，也可以通过类名访问。

       (3)静态的访问问题：

              A:非静态方法

                    非静态成员变量

                    静态成员变量

                    非静态成员方法

                    静态成员方法      

              B:静态方法

                    静态成员变量

                    静态成员方法      

              总之：静态只能访问静态。

              称呼：

                    静态的成员被成为类成员。跟类相关。

                    非静态的成员被称为实例成员。跟对象相关。

       (4)main方法的解释以及如何接收键盘录入数据：

              public:权限最大

              static:静态，不用创建对象。

              void:返回没有意义。

              main:大家都是这样做的。

              String[] args:接收键盘录入数据。

              接收键盘录入的格式：

                     java HelloWorld hello world java

                     java HelloWorld 10 20 30

8：代码块:

       (1)用{}括起来的代码。

       (2)分类：

              A:局部代码块。

                    方法内。

                    作用：限定变量的生命周期，提高效率。

              B:构造代码块。

                    类中，方法外。

                    作用：把所有构造方法中相同的代码定义到一处。

              C:静态代码块。

                    类中，方法外，加static。

                    作用：在整个系统运行过程中只执行一次的内容。

       (3)面试题：

              构造方法，构造代码块，静态代码块的执行流程?

              静态代码块 -- 构造代码块 --构造方法。

              特点：

                    静态代码块只执行一次。

                    构造代码块每次调用构造方法都执行。

9：一个类的实例化过程:

       Person p = new Person();

       A:把Person.class加载到内存。

       B:在栈内存为p变量开辟空间。

       C:在堆内存为Person对象开辟空间。

       D:对成员变量进行默认初始化。

       E:对成员变量进行显示初始化。

       F:如果有构造代码块，通过构造代码块对成员变量进行初始化。

       G:通过构造方法对成员变量进行初始化。

       I:对象初始化完毕，把堆内存的地址给p变量。

第三部分

1：制作工具类和API。

       (1)静态的使用场景：

              A:被所有对象共享的数据。

              B:工具类一般成员都是静态修饰。

       (2)如何通过javadoc命令制作帮助文档呢?

              A:写一个java源程序。

              B:对java源程序加入文档注释。

              C:通过javadoc命令生成即可。

                     javadoc -d doc -author -version ArrayTools.java

2：使用API:

       (1)使用API的步骤：

              参照：day08\code\02_如何使用API和Math类的学习\如何使用API.txt

       (2)通过Math类的学习来实践。

              A:绝对值

              B:向上/下取整

              C:最大/小值

              D:四舍五入

              E:平方根

              F:次幂

              G:随机数

       (3)案例：

              猜数字小游戏。

      

import java.util.Scanner;

class GuessNum {

       public static void main(String[]args){

              int num=(int)(Math.random()*100)+1;

              int start=1;

              int end=100;

              int count=0;

      

              while(true){

                     count++;

                     System.out.println("请输入"+start+"-"+end+"之间的整数");

                     Scanner sc=new Scanner(System.in);

                     int guessNum=sc.nextInt();

                     if(guessNum>num){

                            end=guessNum-1;

                            System.out.println("你猜的数字大了");

                     }else if(guessNum<num){

                            start=guessNum+1;

                            System.out.println("你猜的数字小了");

                     }else{

                            System.out.println("恭喜你，"+count+"次就猜对了！");

                            break;

                     }

              }

       }

      

}

3：继承:

       (1)把多个类中相同的内容提取出来，定义到一个类中。

          然后让这多个类和这个类产生一个关系，这多个类就具备该类的数据了。

          这种关系叫：继承。

       (2)表现形式：

              class SonClass extends FuClass {}

              SonClass:子类,派生类

              FuClass:父类，基类，超类

       (3)继承的好处：

              A:提高了代码的复用性。

              B:让类与类之间产生了一个关系，是多态的前提。

       (4)Java中继承的特点：

              A:Java中类只支持单继承。

              B:Java中类可以多层(重)继承。

       (5)继承间的成员关系：

              A:成员变量

                    在子类方法中使用变量：

                           局部范围

                           成员范围

                           父类成员范围

              B:构造方法

                     a:子类构造方法中默认去访问父类的无参构造方法。

                           原因：因为子类要使用父类的数据，父类的数据必须先初始化。

                     b:假如父类没有构造方法

                           要么，使用super(...)调用带参

                           要么，使用this(...)访问本类其他构造，本类至少有一个构造方法访问了父类构造方法。

              C:成员方法

                    通过子类对象使用成员方法：

                           子类

                           父类

4：方法重写:

       (1)子类中出现了和父类中方法声明一模一样的方法。

          复写，覆盖。

       (2)注意事项：

              A:子类方法的权限不能低于父类方法的权限

              B:父类私有的不能被重写

              C:静态只能重写静态。(多态中讲解一个问题)

      

5：面试题：:

      

       (1)方法重载和方法重写的区别?

              方法重写：

              子类中出现和父类中一模一样的方法声明的方法。

       方法重载：

              同一个类中，出现方法名相同，参数列表不同的方法。

              跟返回值无关。

       重载可以改变返回值类型，因为他跟返回值无关。

       (2)this和super的区别?

              this:当前类的引用对象。谁调用代表谁。

           super:父类的存储空间标识。可以理解为父类对象，谁调用代表谁父亲。

       应用场景：

              A:成员变量

                     this.成员变量本类的成员变量

                     super.成员变量 父类的成员变量

              B:构造方法

                     this(...)   本类的构造方法

                     super(...)父类的构造方法

              C:成员方法

                     this.成员方法()     本类的成员方法

                     super.成员方法()父类的成员方法

第四部分

1：final:

       (1)是一个关键字，表示的是最终的意思。

       (2)它可以修饰类，修饰成员变量，修饰成员方法。

       (3)特点：

              它修饰的类不能被继承。

              它修饰的变量是常量。

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

       (4)面试题：

              修饰局部变量。

              方法的形式参数：

                    基本类型：基本类型的值不能发生改变。

                    引用类型：引用类型的地址值不能发生改变，但是内容可以发生改变。

2：多态:

       (1)同一个对象在不同时刻表现出现的多种状态。

              举例：

                    水(水蒸气,冰,水)

              理解：

                    编译时期状态和运行时期状态不一致的现象。

                    判断下面哪个有问题：从右边往左边念。

                     Fu f = new Fu();

                     Zi z = new Zi();

                     Fu f = new Zi(); //多态

                     Zi z = new Fu(); //报错

       (2)多态的前提：

              A:要有继承或者实现关系。

              B:有方法重写。

                    因为一般都是抽象类或者接口的多态。

              C:要有父类/父接口的引用指向子类对象。

       (3)多态访问的成员特点：

              Fu f = new Zi();

              A:成员变量

                    编译看左边，运行看左边。

              B:成员方法

                    编译看左边，运行看右边。

              C:静态方法

                    编译看左边，运行看左边。

       (4)多态的好处和弊端：

              A:好处

                    提高了程序的可维护性和可扩展性。

                    维护性：继承保证

                    扩展性：多态保证

              B:弊端

                    父类/父接口不能访问子类特有功能。

       (5)多态中的类型转换：

              A:向上转型

                     Fu f = new Zi();

              B:向下转型

                     Zi z = (Zi)f;

              举例：孔子装爹。

       (6)多态的体现形式：

              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 Inter {}

                     //接口的实现类命名：接口名+Impl

                     class InterImpl implements Inter{}

                     Inter i = new InterImpl();

3：抽象类:

       (1)把多个类中相同的方法声明给抽取出来。定义到一个类中。

          一个方法如果只有方法声明，没有方法体，那么该方法必须定义为抽象方法。

          而一个类中如果有抽象方法，那么，该类必须定义为抽象类。

       (2)抽象类的特点：

              A:抽象方法和抽象类都必须用abstract表示。

              B:一个类继承抽象类的时候；

                    要么：本身是一个抽象类。

                    要么：实现抽象类中的所有抽象方法。

              C:抽象类不能实例化。可以按照多态的使用方式使用。

              D:成员特点：

                     a:成员变量

                           可以是变量，也可以是常量。

                     b:构造方法

                           有

                     c:成员方法

                           可以是抽象，也可以非抽象。

       (3)抽象类的好处：

              A:抽象类中的非抽象方法提高了代码的复用性。

              B:抽象类中的抽象方法强制要求子类必须重写某些方法。

       (4)抽象类的案例：

              A:猫狗案例

              B:老师案例

              C:学生案例(自己做的)

              D:员工案例

       (5)抽象类中的几个小问题：

              A:抽象类不能实例化，构造方法有什么用呢?

                    用于子类访问父类数据的初始化。

              B:如果一个类中没有抽象方法，而类却被定义为了抽象类，请问为什么?

                    不让创建对象。

              C:abstract不能和哪些关键字共存：

                     private:冲突

                     final:冲突

                     static:无意义

4：接口:

       (1)如果一个抽象类中的所有成员方法都是抽象的，java就提高了一种更抽象的表达方式：接口。

       (2)接口的特点：

              A:接口用interface定义。

                类实现接口用implements关键字。

              B:一个类要实现接口：

                    要么：本身是抽象类。

                    要么：实现接口中的所有抽象方法。

              C:接口不能实例化。可以按照多态的使用方式使用。

              D:成员特点：

                     a:成员变量：只能是常量。

                              默认修饰符：public static final

                     b:成员方法：只能是抽象方法。

                             默认修饰符：public abstract

       (3)类与接口的关系：

              A:类与类的关系

                    继承，单继承。

              B:类与接口的关系

                    实现，单实现，多实现。

                    继承一个类的同时实现多个接口。

              C:接口与接口的关系

                    继承，单继承，多继承。

       (4)案例：

              A:猫狗案例用接口实现基本版本。

       (5)抽象类和接口的区别:

              A:成员区别

                    抽象类：

                            a:成员变量

                                  可以是变量，也可以是常量。

                            b:构造方法

                                  有

                            c:成员方法

                                  可以是抽象，也可以非抽象。

                    接口：

                            a:成员变量：只能是常量。

                                      默认修饰符：public static final

                            b:成员方法：只能是抽象方法。

                                      默认修饰符：public abstract

              B:关系区别

                     a:类与类的关系

                           继承，单继承。

                     b:类与接口的关系

                           实现，单实现，多实现。

                           继承一个类的同时实现多个接口。

                     c:接口与接口的关系

                           继承，单继承，多继承。

              C:设计理念不同

                    抽象类被继承体现的是：is a的关系。抽象类中定义的是继承体系共性功能。

                    接口被实现体现的是：like a的关系。接口中定义的是继承体系的扩展功能。

              案例：

                    运动员和教练案例。

                    分析：从具体到抽象。

                    实现：从抽象到具体。

                    使用：具体。

第五部分

1：包:

       (1)其实就是文件夹。

       (2)作业：把同名称的类放到不同的文件夹下使用。

       (3)格式：

              package xxx.yyy.zzz;

       (4)带包的类的编译和运行：

              A:手动式

                     a:javac编译当前类文件。

                     b:手动建立包对应的文件夹。

                     c:把a的class文件放到b的最终文件夹下。

                     d:通过java命令执行。注意了：需要带包名称的执行。

                            java cn.itcast.HelloWorld

              B:自动式

                     a:javac编译的时候带上-d即可

                            javac -d . HelloWorld.java

                     b:通过java命令执行。注意了：需要带包名称的执行。

                            java cn.itcast.HelloWorld

2：导包:

       (1)不同包下的类之间的访问。

          我们发现，每次使用不同包下的类的时候，都需要加包的全路径。

          比较麻烦。这个时候，java就提供了导包的功能。

       (2)格式：

              import xxx.yyy.zzz.类名;

              扩充格式：

                     import xxx.yyy.zzz.*;

                    但是不建议使用这种做法。

       (3)面试题：

              package,import,class的有没有顺序呢?

              package > import > class

              唯一         多个      多个

3：权限修饰符:

       (1)案例：

              cn.itcast

                     Fu

                     Zi

                     Demo

              com.liuyi

                     Zi

                     Demo

       (2)结论：

                                  本类       同一个包下   不同包下的子类    不同包下的无关类

              private                  Y

              默认(什么都没有) Y     Y                  

              protected        Y     Y            Y

              public                   Y     Y            Y            Y

4：常见的修饰符的使用:

                    类    成员变量      构造方法       成员方法

       private                  Y            Y            Y

       默认              Y     Y            Y            Y

       protected        Y            Y            Y

       public            Y     Y            Y            Y

       final        Y     Y                          Y

       static                     Y                          Y    

       abstract   Y                                 Y

       类：public

       成员变量：private

       构造方法：public

       成员方法：public

5：内部类:

       (1)把类定义在其他类的内部，就被称为内部类。

       (2)内部类的访问特点：

              A：内部类可以直接访问外部类的成员，包括私有。

              B：外部类要访问内部类的成员，必须创建对象。

       (3)内部类的分类：

              A:成员内部类

                     a:private访问的安全性

                     b:static访问的方便

              B:局部内部类

                     a:带名字的(类)

                     b:不带名字的(对象)

       (4)面试题：

              局部内部类访问局部变量必须加final修饰。

       (5)匿名内部类：:

              格式：

                     new类名或者接口名() {

                           重写方法;

                     };

               本质：是继承类或者实现接口的子类匿名对象。