黑马程序员-Java学习03-面对对象

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

1.类与对象的关系

使用计算机语言就是不断的在描述现实生活中 的事物。

java中描述事物通过类的形式体现，类是具体事 物的抽象，概念上的定义。

对象即是该类事物实实在在存在的个体。
2. 成员变量和局部变量的区别？

成员变量：

成员变量定义在类中，在整个类中都可以被访问。
成员变量随着对象的建立而建立，存在于对象所在的堆内存中。
成员变量有默认初始化值。

3 局部变量：

局部变量只定义在局部范围内，如：函数内，语句内等。
局部变量存在于栈内存中。
作用的范围结束，变量空间会自动释放。
局部变量没有默认初始化值。

4.匿名对象

匿名对象是对象的简化形式
匿名对象两种使用情况 当对对象方法仅进行一次调用的时 匿名对象可以作为实际参数进行传递

如Car c =new Car()

c.run()

new Car().run();

5.private(私有)关键字

private关键字：

是一个权限修饰符。
用于修饰成员(成员变量和成员函数)
被私有化的成员只在本类中有效。
私有化以后，类以外即使建立了对象也不能直接访问。

常用之一：

将成员变量私有化，对外提供对应的set ，get 方法对其进行访问。提高对数据访问的安全性。

练习：构造Person类

class Person{
public int age;
public String name;
public Person(int age, String name) {
super();
this.age = age;
this.name = name;
}
public void sayHello(){
//		sayHello方法
System.out.println("我叫"+name+"， 今年"+age+"岁了");
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

6.构造函数

特点：

函数名与类名相同
不用定义返回值类型
不可以写return语句

作用：给对象进行初始化。

构造函数的小细节：

当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。
当在类中自定义了构造函数后，默认的构造函数就没有了。
多个构造函数是以重载的形式存在的。
一个类中默认会有一个空参数的构造函数，
这个默认的构造函数的权限和所属类一致。

7.this关键字

特点：this代表其所在函数所属对象的引用。 换言之：this代本类对象的引用。

什么时候使用this关键字呢？ 当在函数内需要用到调用该函数的对象时，就用this。

this关键字在构造函数间调用：
this（）;用于构造函数间的调用。
通过this调用构造方法，必须位于第一句。

8.构造代码块。

作用：给对象进行初始化。

对象一建立就运行，而且优先于构造函数执行。

和构造函数的区别：

构造代码块是给所有对象进行统一初始化，
而构造函数是给对应的对象初始化。
构造代码快中定义的是不同对象共性的初始化内容。

9.static关键字：

用于修饰成员（成员变量和成员函数）
被修饰后的成员具备以下特点：
随着类的加载而加载
优先于对象存在
被所有对象所共享
可以直接被类名调用

使用注意

实例变量和类变量（静态变量）的区别：

存放位置。

类变量随着类的加载而存在于方法区中。

实例变量随着对象的建立而存在于堆内存中。

生命周期：

类变量生命周期最长，随着类的消失而消失。

实例变量生命周期随着对象的消失而消失。

静态使用注意事项：

静态方法只能访问静态成员。

非静态方法既可以访问静态也可以访问非静态。

静态方法中不可以定义this，super关键字。

因为静态优先于对象存在。所以静态方法中不可以出现this。

主函数是静态的。

10.静态代码块。

格式：
static
{
静态代码块中的执行语句。
}
特点：

随着类的加载而执行，只执行一次,并优先于主函数。
用于给类进行初始化的。

静态代码块，与构造代码块的区别：

静态只运行一次，构造代码每次次构造对象都会运行。

执行顺序：静态代码块-主方法-构造代码块-构造方法
验证程序

package nuddles.j2seDemo;

public class StaticCode {

* @param args
public static void main(String[] args) {
// TODO Auto-generated method stub
new StaticDemo(67).info();
System.out.print("第二次：");
new StaticDemo(690).info();
}

}

class StaticDemo{
private static int num = 10;
int num2;
static{
System.out.println("c");
}
public StaticDemo(int num2) {
// TODO Auto-generated constructor stub
this.num2 = num2;
System.out.println("b");
}
public  void info(){
System.out.println("数值是"+this.num2);
}
}

运行结果

c

b

数值是67

第二次：b

数值是690

11.对象初始化的过程

Person p = new Person("zhangsan",20);

该句话都做了什么事情？
1，因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。
2，执行该类中的static代码块，如果有的话，给Person.class类进行初始化。
3，在堆内存中开辟空间，分配内存地址。
4，在堆内存中建立对象的特有属性。并进行默认初始化。
5，对属性进行显示初始化。
6，对对象进行构造代码块初始化。
7，对对象进行对应的构造函数初始化。
8，将内存地址付给栈内存中的p变量。

12.单一设计模型

设计模式：解决某一类问题最行之有效的方法。
java中23种设计模式：
单例设计模式：解决一个类在内存只存在一个对象。
想要保证对象唯一。

为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

这三部怎么用代码体现呢？

将构造函数私有化。
在类中创建一个本类对象。
提供一个方法可以获取到该对象。

对于事物该怎么描述，还怎么描述。
当需要将该事物的对象保证在内存中唯一时，就将以上的三步加上即可。

package nuddles.j2seDemo;

public class SingleDemo {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Single1 single1 = Single1.getInstace();
Single2 single2 = Single2.getInstance();
System.out.println(single1);
System.out.println(single2);
Single2 single3 = Single2.getInstance();
System.out.println(single3);
}

}

//饿汉式：一进内存 就创建了对象

class Single1{
private Single1(){};
private static Single1 single  = new Single1();
public static Single1 getInstace(){
return single;
}
}

//懒汉式：什么时候调用什么时候创建对象,对象的延时加载
class Single2{
private Single2(){};
private static Single2 single = null;
public static Single2 getInstance(){
if(single==null){
synchronized(Single2.class)//同步锁
{
if (single==null){
//                	   此处用两个if来判断增加效率
single=new Single2();
}
}
}
return single;
}
}

运行结果：

nuddles.j2seDemo.Single1@1bc4459

nuddles.j2seDemo.Single2@12b6651

nuddles.j2seDemo.Single2@12b6651

13.继承：

提高了代码的复用性。
让类与类之间产生了关系。有了这个关系，才有了多态的特性。

注意：

千万不要为了获取其他类的功能，简化代码而继承。
必须是类与类之间有所属关系才可以继承。所属关系 is a。
Java语言中：java只支持单继承，不支持多继承
因为多继承容易带来安全隐患:当多个父类中定义了相同功能，
当功能内容不同时，子类对象不确定要运行哪一个。
但是java保留这种机制。并用另一种体现形式来完成表示。多实现。
java支持多层继承。也就是一个继承体系

如何使用一个继承体系中的功能呢？
想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性功能。
通过了解共性功能，就可以知道该体系的基本功能。
那么这个体系已经可以基本使用了。
那么在具体调用时，要创建最子类的对象，为什么呢？

一是因为有可能父类不能创建对象，
二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。

简单一句话：查阅父类功能，创建子类对象使用功能。

子父类出现后，类成员的特点：

变量

如果子类中出现非私有的同名成员变量时，
子类要访问本类中的变量，用this
子类要访问父类中的同名变量，用super。
super的使用和this的使用几乎一致。
this代表的是本类对象的引用。
super代表的是父类对象的引用。

子父类中的函数。

当子类出现和父类一模一样的函数时，
当子类对象调用该函数，会运行子类函数的内容。
如同父类的函数被覆盖一样。

这种情况是函数的另一个特性：重写(覆盖)
当子类继承父类，沿袭了父类的功能，到子类中，
但是子类虽具备该功能，但是功能的内容却和父类不一致，
这时，没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容。

覆盖：

子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。
静态只能覆盖静态。

记住大家：
重载：只看同名函数的参数列表。
重写：子父类方法要一模一样。（重写最后用copy);

子类在构造的时候会先调用父类构造方法
super();
子父类中的构造函数。

在对子类对象进行初始化时，父类的构造函数也会运行，
那是因为子类的构造函数默认第一行有一条隐式的语句 super();
super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();

为什么子类一定要访问父类中的构造函数。
因为父类中的数据子类可以直接取获。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。
所以子类在对象初始化时，要先访问一下父类中的构造函数。
如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。
注意：super语句一定定义在子类构造函数的第一行。
子类的实例化过程。
结论：
子类的所有的构造函数，默认都会访问父类中空参数的构造函数。
因为子类每一个构造函数内的第一行都有一句隐式super();

14.final : 最终。作为一个修饰符，

可以修饰类，函数，变量。
被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。
被final修饰的方法不可以被复写。
被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，也可以修饰局部变量。
当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字。方便于阅读。 而这个值不需要改变，所以加上final修饰。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成。单词间通过_连接。
内部类定义在类中的局部位置上是，只能访问该局部被final修饰的局部变量。

抽取：当多个类中出现相同功能，但是功能主体不同，
这是可以进行向上抽取。只抽取功能定义，而不抽取功能主体。

15.抽象：看不懂。

抽象类的特点：

抽象方法一定在抽象类中。
抽象方法和抽象类都必须被abstract关键字修饰。
抽象类不可以用new创建对象。因为调用抽象方法没意义。
抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。

如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。
抽象类的抽象方法必须全被子类全部覆写，因此相当于抽象类可以强迫子类去做某些事情。
抽象类中还可以有普通方法，可以不被子类覆写。
抽象类和一般类没有太大的不同。
该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。
这些不确定的部分，也是该事物的功能，需要明确出现。但是无法定义主体。
通过抽象方法来表示。
抽象类比一般类多个了抽象函数。就是在类中可以定义抽象方法。
抽象类不可以实例化。
特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

/*
假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：
姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个
奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方
法进行属性访问。
员工类：name id pay
经理类：继承了员工，并有自己特有的bonus。
*/

abstract class Employee{
private String name;
private String id;
private double pay;

Employee(String name,String id,double pay){
this.name = name;
this.id = id;
this.pay = pay;
}
public abstract void work();

}

class Manager extends Employee{
private int bonus;//private 只有自己才有的
Manager(String name,String id,double pay,int bonus){
super(name,id,pay);
this.bonus = bonus;
}
public void work(){
System.out.println("manager work");
}
}

class Pro extends Employee{
Pro(String name,String id,double pay){
super(name,id,pay);
}
public void work(){
System.out.println("pro work");
}
}

16.模板设计

/*
要求：定义一个类，要求实现运行一代程序的时间。
思路：用System.currentTimeMillis()方法记录下开始和结束的时间。
*/

abstract class GetTime{
public final long getTime()//用final 定义禁止别人修改
{
long start =System.currentTimeMillis();
//静态方法System.currentTimeMillis() 返回long类型
runCode();
long end =System.currentTimeMillis();
return (end -start);
}

abstract void runCode();
//抽象此方法，子类覆写
}

class Sub extends GetTime{
public void runCode(){
for(int i=0;i < 1000; i++) {
System.out.print(i+",");
}

}
}

public class Template{
public static void main(String[] args) {
//Sub gt = new Sub();
System.out.print(new Sub().getTime());
//用匿名类也可以完成，只调用一次方法。
}
}

注：abstract 不能与private static final 一起用。理由你懂的

final：被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类。
private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。 而抽象方法出现的就是需要被复写。
static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。 可是抽象方法运行没义。

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------