------- android培训、java培训、期待与您交流! ----------
*面向对象:
定义:是一种思想,是一种符合现实生活人们思考习惯的思想。
1、面向过程 强调过程,执行者
2、面向对象 强调对象,指挥者
举例:大象放进冰箱里:
面向过程:打开冰箱——存储食物——关闭冰箱(面对三个动作)
(执行这些功能)
面向对象:(冰箱)打开冰箱——存储食物——关闭冰箱(动作)
(面对的是一个事物“冰箱”,这个事物也称为对象)
面向过程PK面向对象:
面向对象是将具体的动作封装到事物当中,那么就不用再面对动作,而是直接面向对象。找到对象,就已经具备了这些动作。
3、面向对象思想的特点:
---它是一种更符合人们思考习惯的思想
---它是复杂的内容简单化
---它是我们从执行者变成了指挥者
请解释面向对象的思想?
4、面向对象的特点:
---封装
---继承
---多态
面向对象的面试回答:
它本身是符合现在人们生活中的思想习惯,是一种思想;它的出现能让生活中复杂问题简单化,它可以让我们从执行者变成指挥者,指挥做事情。
面试官,其实你就是在用面向对象的思想在思考问题,公司里下面的工作需要人来做,即使你都可以做,但是也需要更多的人来帮你做。而你就是指挥者,下属的员工就是执行者。
类和对象:
1、类 对现实世界中事物的描述(属性和方法)
2、对象 现实世界中实际存在具体的个体
3、对象的使用以及内存图 new
4、局部变量和成员变量
(1)局部变量:(栈内存)
定义:只在某个程序块或只在方法体内有效。
局部变量在使用前必须初始化,系统不会对局部变量进行默认初始化。
(2)成员变量:(堆内存)
(3)定义:不在方法体也不在程序块中的变量。只要对象被引用,成员变量就将存在。类中,对整个类有效。
5、变量初始化:
所有的局部变量在使用之前,都必须初始化(即必须要有值),手动赋值。
在初始化变量时,应该把变量名写在左边,随后是赋值操作符“=”,然后再在右边加上一个恰当的java表达式或值。
变量的初始化有两种方法:
(1)在声明变量时就同时给它赋一个值:int i = 4;
(2)先声明变量,然后再在适当的时机给它赋值:
int k ;
......
k = 10;
*封装:
定义:把实现细节隐藏,对外提供公共的访问方式,在java中最常见的就是把成员变量用private修饰,提供get/set方法。
1、封装的好处:便于重复使用,安全性高。
2、private权限修饰符(代码体现)
class Demo
{
private int age;
public void setAge(int age)
{
if(age>100 || age<0)
{
System.out.println("年龄有误");
}
else
{
this.age = age;
}
}
public int getAge()
{
return age;
}
}
构造函数
1、用途:用于创建对象,也有可能要进行初始化。
A:格式 类名(){//code}
B:Person(){}
2、特点 你不给,系统会自动给一个空参构造,你给了,系统就不给了。
3、重载构造函数
重载特点:与返回值类型无关,只看参数列表。
A:Person(){}
B:Person(String name){}
C:Person(int age){}
D:Person(String name,int age){}
注意:构造还可以用于给属性赋值。
*继承(extends):
定义:子类具有父类的所有属性和方法,没有构造器
1、继承的体系结构:就是对要描述的事物进行不断的向上抽取,就出现了体系结构。
--- 先学习顶层内容,因为它是共性内容。
--- 一般使用的时候使用的是底层的类。
2、继承的好处:
A:继承的出现,提高了代码的复用性。
B:继承的出现,让类与类之间产生了关系,extends来表示,这个关系的出现,为后面我们讲面向对象的第三个特点多态打下了基础。
3、特点:
A:java只支持单继承。父类VS多子类,子类VS一父类。
B:java支持多重(层)继承。父类——子类——孙子类——重孙子类。
4、注意:
A:子类可以直接访问父类中的非私有的属性和行为。
B:不要仅为了获取其他类中部分功能而去继承。
C:类与类之间要有所属( " is a " )关系,xx1是xx2的一种。
5、继承后子父类之间成员的关系
(1)成员变量
class Father
{
int num1 = 5;
}
class Son extends Father
{
int num1 = 20;
int num2 = 10;
public void show()
{
int num1 = 30;
System.out.println("num1:"+num1);
System.out.println("num2:"+num2);
//局部范围内有的变量,如果我想使用成员变量,this
System.out.println("this num1:"+this.num1);
//就想子类中访问父类中和子类同名的变量super
System.out.println("father num1:"+super.num1);
}
}
总结:使用子类中的成员变量时,首先看局部有没有和成员变量同名的,如果有就是用局部的。
其实,在子类的成员变量里面找,如果有,直接输出。
最后,在父类中找同名的变量,如果有,就输出父类的值。否则报错。
(2)成员方法
class Father
{
public void show()
{
System.out.println("father show");
}
}
class Son extends Father
{
public void show()
{
System.out.println("son show");
}
public void show1()
{
System.out.println("son show1");
}
}
总结:在使用子类的成员方法时:首先在子类中找,其次在父类中找。否则,报错。
super可以在子类中使用父类的成员方法。
子类中存在和父类成员方法同名的这种现象,叫做重写,复写,覆盖。
重写(override)和重载(overload)的区别:
重载的特点:
1--在同一类中。
2--方法名相同,参数列表不同。
重写的特点:
1--要有继承关系。在子父类中
2--方法的声明相同。(方法名和参数列表都相同)
----覆盖时,子类方法权限一定要大于等于父类方法权限
----静态只能覆盖静态。
(3)构造方法
class Father
{
Father(){}
Fahter(int age)
{
System.out.println("father age:"+age);
}
}
class Son extends Father
{
Son()
{
//默认这里有一个东西 super();
//this(20);
System.out.println("son");
}
Son(int age)
{
super(age);
System.out.println("son age:"+age);
}
}
Son s = new Son(); //father;son
Son s = new Son(20);//father;son age:20
总结:子类中所有的构造方法默认都会访问父类中空参数的构造方法。
因为每一个构造方法的第一行都有一条默认的语句super();
当父类中没有空参数的构造方法时,子类的构造函数必须通过this,
或者super语句指定要访问的构造方法。类手动提供无参构造方法。
this(...):调用本类中的构造方法
super(...):调用父类中的构造方法
以前:构造方法用于创建对象,并进行初始化。
class Person
{
Person(){}
Person(int age)
{
this.age = age;
}
Person(int age,String name)
{
this(age);
//this.age = age;
this.name = name;
}
}
//Person p =new Person(); //系统默认给出无参构造
//当你手动给出构造方法后,系统就不会再给出默认的空的构造方法。
//手动无参数,如果你想给属性赋值或者做一些初始化,无参不要删
class Demo
{
private String name;
Demo(){}
public void setName(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
}
*抽象类(abstract):
定义:只抽取了很多类的方法的声明,为了保证不出问题,方法声明用abstract修饰。
1、抽象类的特点
A:一个类如果有了抽象方法,那么这个类必须是抽象类。抽象类里边可以 没有抽象方法。
B:抽象类是不能够被实例化的。不能够创建对象的。
C:如果一个类继承抽象类,那么,它要么实现抽象类中的所有抽象方法,
要么本身也是抽象类。
3、抽象类的成员特点:
A:成员变量:子类可以直接继承抽象类中的成员变量。(抽象类中的成员变量可以和以前是一样的)
B:成员方法:抽象类中分为两种方法,一种是抽象方法,这种方法在子类中必须要被实现。一种是普通的方法。可以被子类直接继承使用。
C:构造方法:抽象类不能被实例化,那么它有构造方法吗?抽象类是class,那么它就有构造方法。它的构造方法为了让子类实例化。
4、抽象类的相关问题:
A:抽象关键字abstract不可以和哪些关键字共存?
private:私有的,外部直接无法访问。
static:那么这个时候抽象方法就可以可以通过类名调用,但是这 样是没有意义的。
final:final修饰的方法不能被重写。所以它和abstract冲突。
B:抽象类中可以没有抽象方法,防止其他类创建该类对象。
*接口(interface):
定义:当一个类中的方法都是抽象的时候,你没必要定义为抽象类,定义为接 口就可以了。
1、解决了java中只能单继承的问题。(对多继承进行了优化)
A:类与类:只能是单继承。
B:接口与接口:可以是单继承,也可以是多继承。
C:类与接口:可以是单实现,也可以是多实现。
2、成员特点:
A:只有成员变量和成员方法。
B:成员变量:默认修饰符 public static final
**int x = 20;
**其实是这样的 public static final int x = 20;
C:成员方法:默认修饰符 public abstract
**void show();
**其实是这样的 public abstract void show();
建议:自己手动加上修饰符。
4、接口特点:
A:接口是对外暴露的规则
B:接口是功能的扩展
C:接口降低了程序的耦合性。
**内聚(自己实现功能的能力)
**高内聚,低耦合。
举例:主板和CPU,USB接口,电源插座。
D:扩展说了下接口的理解
**狭义的理解就是java中的接口。
**广义的理解就是:任何定义的规范都是接口。
5、接口实现的语法格式:A a = new B();
public interface MyInner{
public abstract void fun();
}
class MyClass implements MyInner{
public void fun(){
}
}
6、接口和抽象类的区别:
A:抽象类只能被单继承;接口可以被多实现。
B:抽象类中的成员:
成员变量:可以是常量,也可以是变量。
成员方法:可以是抽象的,也可以是非抽象的。
构造方法:虽然不可以创建对象,但是可以给子类实例化用。
接口中的成员:
成员变量:只能是常量。默认修饰符 public static final
成员方法:只能是抽象的。默认修饰符 public abstract
C:抽象类中定义的是体系结构中的共性的内容。
接口中定义的是对象的扩展功能。
D:抽象类被继承表示的是:"is a"的关系。xx是yy中的一种。
接口被实现表示的是: "like a"的关系。xx像yy中的一种。
常见接口总结:
Collection
List
Set
Map
Comparable
Comparator
Runnable
Serializable
FilenameFilter
*多态:
定义:同一个对象在不同时刻所对应的状态。
例如:水(气态、液态、固态)
**方法重载(静态多态)
**方法重写(动态多态,对象多态)
1、对象多态的前提
A:类与类(或接口)要有继承(或实现)关系。
B:一定要有方法的重写。
C:一定要有父类或者接口的引用指向子类的对象。
2、多态思想:可以指挥同一类型的一批对象做事情。多态的出现让我们复杂的 问题简单化了。
3、多态中成员的特点:
Fu f = new Zi();
A:成员变量:编译和运行都看Fu。
B:非静态方法:编译看Fu,运行看Zi。
C:静态方法:编译和运行都看Fu。
4、代码体现:
class Fu{
int num = 10;
public void show(){
Sop(“show Fu”);
}
}
class Zi extends Fu{
int num = 20;
public void show(){
sop(“show Zi”);
}
}
class Test{
public static void main(String[] args){
Fu f = new Fu();//创建父类对象
f.show();//show Fu,调用Fu的show方法
Sop(f.num);//10
Zi z = new Zi();//创建子类对象
z.show();//show Zi,调用Zi的show方法
Sop(Zi.num);//20
//多态A a = new B();
Fu f = new Zi();
f.show();
Sop(f.num);//10
}
}