java4android十二集到十七集记录

十二集

主要内容：

1.什么是面向对象？

2.应该如何学习面对对象？

3．面向对象的思维方式？

一、什么是面向对象？

1. 面向对象是一种编程方法

2. 面向对象是一种思维方式

用java语法写面向对象的程序，不要写C的面向过程的代码==

3. 面向对象不是一种编程语言

二、应该如何学习面向对象？

1. 掌握一门面向对象语言的语法

2. 掌握面向对象的思维方式

3. 熟悉面向对象设计原则

面向对象设计的终极目标，消除应用程序中的重复的代码，遵守设计原则。

4. 掌握面向对象设计模式

三、什么是面向对象思维方式？

1. 首先确定谁来做，其次确定怎样做。

2. 首先考虑整体，其次考虑局部。

3. 首先考虑抽象，其次考虑具体

四、总结

1. 不要认为掌握一门面向对象语言就是掌握了面向对象。

2. 习惯于将面向对象与现实世界做比较。

十三集

主要内容：

1. 创建类的方法

2. 创建对象的方法

3. 对象和对象的引用

一、定义类的方法

Class 类名

｛

属性；

方法

｝

属性也叫成员变量，主要用于描述类的状态

方法也叫成员方法，主要用于描述类的行为

二、类的表示方法

Class Person

{

Int age;//age是类的属性，也叫类成员变量

Void shout()// shout是类的方法，也叫类的成员函数

{

System.out.println(“我的年龄是” + age);

}

}

Shout方法可以直接访问同一个类中的age变量，如果一个方法中有与成员变量同名的局部变量，该方法中对这个变量名的访问是局部变量，而不再是成员变量。

三、生成对象的方法

格式：类名 对象名 = new 类名（）；

例如：Dog dog = new dog（）；

根据内存模型：

栈内存：存放对象名字（引用，一般存储对象实体的存储地址）

堆内存：存放对象实体（对象中的内容）。

1、Dog d = new Dog（）；创建一个Dog的引用

2、Dog d = new Dog（）；创建一个Dog的对象

3、Dog d = new Dog（）；将创建的Dog对象赋给这个引用。


四、类和对象的关系

1. 类是众多同一类型对象共性的抽象

2. 对象是类的的实例化

五、总结

1. 对象的创建方法

2. 栈内存和堆内存的使用

3. 类和对象的关系

十四集

主要内容：

1. 对象的使用方法

2. 多对象的创建方法

3. 匿名对象的创建和使用方法

一、对象的使用方法

使用对象调用变量和函数

1. 对象变量

2. 对象函数（）

Class Dog｛

String name;

int age;

String color;

void jump（）｛//定义一个动作函数

System.out.println(“jump”);｝

｝

class E01{

public static void main(String args []){

Dog d = new Dog();

d.name = “旺财”；

d.age =2;

d.color = “黑”；

d.junp（）；//调用方法时这个括号不能拉下

System.out.println(“名字是” +d.name);

} }

二、生成多个对象

Dog d1 = new Dog();

Dog d2 = new Dog();

三、匿名对象的使用

可以不定义对象的引用名称而直接调用这个对象的方法。这样的对象叫做匿名对象，例如：new Dog().jump;匿名对象都是一次性的。

十五集

主要内容

1. 函数的重载

2. 构造函数的作用

一、重载的定义

1. 两个或者多个函数在同一类当中

2. 函数名相同

3. 参数列表不同

注意 （1）函数名相同：行为相同（2）参数不同：行为的目标不同

class A{

void funA(){

System.out.println("没有参数的funA函数")； }

void funA(int i){

System.out.println("一个整形参数的funA函数")； }

void funA(int i ,double d){

System.out.println("两个参数的funA函数")； }

}

class Test｛

public static voidmain(String args[]){

A a = new A();

a.funA();

a.funA(10);

a.funA(1,2);}｝

二、构造函数

1. 构造函数语法特征

（1）无返回值

（2）函数名与类名必须相同

2、构造函数两个作用

（1）生成类的实例

（2）类成员的初始化

class Person{

String name;

int age;

Person(){

}

Person(String n,int a){

name = n;

aga = a;}}

class Test｛

public static voidmain(String args[]){

Person person1 = new Person();

person1.name = "zx";

person1.age = 10;

Person person2 = new Person();

person2.name = "z2";

person2.age = 10;

Person person3 = newPerson("wangwu",2);

System.out.println("person1的name是： " + person1.name + ",age是：" + person1.age);

System.out.println("person2的name是： " + person2.name + ",age是：" + person2.age);

System.out.println("person3的name是： " + person3.name + ",age是：" + person3.age);}｝

三、总结

1. 函数的重载

（1）同一个类中

（2）函数名相同

（3）参数列表不同

2. 构造函数的作用

（1）构造函数名需和类名相同

（2）构造函数没有返回值类型的定义

（3）使用new来调用构造函数

（4）如果类中没有构造函数，编译器会自动生成一个参数为空，方法体为空的构造函数

十六集

主要内容：

1. 使用this调用成员变量和成员函数

2. 使用this调用个构造函数

一、this调用成员变量和成员函数

1. 面向对象编程调用类中成员变量和成员函数

class Person01{

String name;

void talk(){

System.out.println("my nameis " +name);

}}

class E01{

public static void main(String[]args){

Person01 p1 = new Person01();

p1.name = "zx";

p1.talk();

Person01 p2 = new Person01();

p2.name = "ll";

p2.talk();}}

面向对象的编程思想才用类。成员的方式调用类中的变量和函数，所以编译器不会搞混淆调用者和调用对象。

2. 当类中函数参数和类中变量重名时，才用this来区分成员变量和参数

（1）没有才用this，输出的参数信息

class Person01{

String name;

void talk(String name){

System.out.println("my nameis " +name);

}}

class E01{

public static void main(String[]args){

Person01 p1 = new Person01();

p1.name = "zx";

p1.talk("zx01");

}}

(2)采用this时，输出的是成员变量信息

class Person01{

String name;

void talk(String name){

System.out.println("my nameis " +this.name);

}}

class E01{

public static void main(String[]args){

Person01 p1 = new Person01();

p1.name = "zx";

p1.talk("zx01");

}}

二、this调用构造函数

一个构造函数在函数内部用this调用其他构造函数时，this语句一定是该构造函数中的第一条语句。

class Person01{

String name;

int age;

String address;

Person01(){

System.out.println("无参数的构造函数！");}

Person01(String name, int age){

this();

this.name = name ;

this.age = age ;

System.out.println("两个参数的构造函数！");}

Person01(String name ,int age,String address){

this(name,age);

this.address = address;

System.out.println("三个参数的构造函数！");}

}

class E01{

public static void main(String[]args){

Person01 p1 = newPerson01("zx",21,"sd");

}}

十七集

主要内容：

（1）静态成员变量的语法特点

（2）静态函数的语法特点

（3）静态代码块的语法特点

一、静态变量

语法特点：

（1）静态变量声明时用static修饰

class Person{

static int i;}

(2)可用类名直接调用静态变量，同时也可以用对象调用静态变量

class test{

public ststic void main (String [] args ){

Person.i=10;

personp1 = new Person();

System.out.println("Person类中静态变量i的值是" + p.i);}}

(3)类的不同对象共享类的成员变量

class test{

public static void main(String [] args){

Person p1 = new Person();

Person p2 = new Person();

Person.i = 10;

System.out.println("p1的i值为" + p1.i);

System.out.println("p2的i值为" + p2.i);

p1.i = 20

System.out.println("p1的i值为" + p1.i);

System.out.println("p2的i值为" + p2.i);}}

二、静态函数

语法特点：

（1）静态函数声明时用static修饰。

class Person{

static void main fun (){

System.out.println(“我是静态函数！”)；}}

（2）静态函数可以用类名直接调用，也可以用对象直接调用。

class test{

public static void main(String [] args){

Person.fun();

Person p = new Person();

p.fun();}}

（3）静态函数中不能使用非静态的成员变量

class Person{

Stringname;

staticvoid talk(){

System.out.println("Myname is" + name);

}}

(4)类的不同对象共享类的静态函数

class test{

public static void main(String [] args){

Person p1 = newPerson();

p1.talk;

Person p2 = newPerson();

p2.talk

}}

三、静态代码块

在装载类的时候执行行静态代码块。

class Person{

static{

System.out.println("这是静态代码块" );

}}

四、总结：

1. 静态成员变量只有一份

2. 在静态函数当中不能使用this

3. 静态代码块的主要作用是为了静态成员变量赋值