------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------
---Java之--------面对对象-----
[1]面对对象：就是对事物进行描述。事物就是对象。
[2]所有的事物都有两个方面：
有什么（属性）：用来描述对象。
能够做什么（方法）：告诉外界对象有那些功能。
[3] 面对对象有什么好处？
符合人类看待事物的一般规律
[4]类与变量的关系
类是对一类事物的描述，是对象的抽象
对象是该类事物的实例，是类的具体表现
[5] 定义一个类，就是定义里面的成员。
成员包括：属性（成员本身的特点，成员变量）方法 （成员的行为，成员函数）
注意----------类名中单词的首字母大写。
[6]成员变量与局部变量的区别
1，成员变量定义在类中，整个类中都可以访问。
---局部变量定义在函数，语句，局部代码块中，只在所属的区域有效。
2，成员变量存在于堆内存的对象中。
----局部变量存在于栈内存的方法中。
3，成员变量随着对象的创建而存在，随着对象的消失而消失。
----局部变量随着所属区域的执行而存在，随着所属区域的结束而释放。
4，成员变量都有默认初始化值。
--局部变量没有默认初始化值。
5，实例变量和局部变量允许命名冲突。
例如：public int addNumber(int a,int b){}
注：方法名中的参数int a,int b为局部变量
public int addNumber(int a,int b){}
注：方法名中的参数int a,int b为局部变量
[7] 基本数据类型和引用数据类型参数的传递
import java.util.Scanner;
//基本数据类型参数传递
class Demo {
public static void main(String[] args) {
int x = 3;
show(x); // 传值
System.out.println("x=" + x);
} // 结果为3
public static void show(int x) {
x = 4;// 改变的是局部变量
}
}
// 引用数据类型参数传递
class Demo {
int x = 3; // 定义成员变量x
public static void main(String[] args) {
Demo d = new Demo();
d.x = 9; // 改变x的值
show(d);
System.out.println(d.x);
} // 输出结果为4
public static void show(Demo d) {
d.x = 4; // 改变传入的变量的值
}
}
[8]匿名对象
匿名对象：是对象的简化格式。也就是没有名字
1，当对象对方法仅进行一次调用的时候，就可以简化成匿名对象。
2 ， 你们对象可以作为实际参数进行传递。
3 ，只在堆内存开辟空间，使用过以后自动销毁
new Car();//匿名对象。其实就是定义对象的简写格式。 Car c = new Car(); new Car().run(); ------------------等同于-----------------c.run();
[9]构造函数
构造函数：用来构造类的实例（每一个类都默认有一个无参的构造方法）
作用： 给类中的对象进行初始化，创建对象必须要通过构造函数初始化。
特点： 方法名与类名相同 （return可以省略，但是存在）
注意： 1，一般函数不能直接调用构造函数。
--------2，构造函数如果前面加了void就变成了一般函数。
-------3，构造函数中是有return语句的
-------4 ， 如果类里面有有参构造函数，那么系统默认的无参构造函数将不存在
[10]构造函数与一般函数的区别
构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。
一般函数：对象创建后，需要函数功能时才调用。
构造函数：对象创建时，会调用只调用一次。
一般函数：对象创建后，可以被调用多次。
[11] 代码块
1，普通代码块。直接在方法或语句中定义的代码块
2 ，构造代码块直接写在类中的代码块
构造代码块优于构造方法执行，并且每次实例化对象都会执行
3， 静态代码块
class Demo {
{System.out.println("1，构造代码块") }；
static｛System.out.println("0，静态代码块") ｝
public Demo{System.out.println("2，构造方法") } ;
public class CodeDemo {
public static void main(String[] args)｛
static｛System.out.println("主方法体中的静态代码块") ｝
new Demo(); new Demo();
｝
/*结果：主方法体中的静态代码块---0，静态代码块----1，构造代码块----2，构造方法----1，构造代码块----2，构造方法
[12] static 关键字----用于修饰成员（成员变量和成员函数）
修饰之后的特点:
1，static修饰的成员被所有的对象所共享。
2，随着类的加载而加载，static优先于对象存在
3，修饰之后可以直接被类名所调用 。 类名.静态成员 。
5，static修饰的数据是共享数据，对象中的存储的是特有数据。
使用注意：---------
1，静态方法只能访问静态成员 ，但是非静态成员可以访问静态成员;
2，静态方法中不可以使用this，super关键字
3，主方法（main）是静态的
[13]成员变量和静态变量的区别
1，两个变量的生命周期不同。
成员变量随着对象的创建而存在，随着对象的被回收而释放。
静态变量随着类的加载而存在，随着类的消失而消失。
2，调用方式不同。
成员变量只能被对象调用。
静态变量可以被对象调用，还可以被类名调用。
3，数据存储位置不同。
成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据.
静态变量数据存储在方法区(共享数据区)的静态区，所以也叫对象的共享数据.
[14]静态成员的使用
1，静态变量。
对象中所具备的成员变量的值都是相同的 。 这时这个成员就可以被静态修饰。
如果是相同的数据，对象不需要做修改，不需要存储在对象中，定义成静态的。
2，静态函数。
函数是否用静态修饰，就参考该函数功能是否有访问到对象中的特有数据。
[15]this 关键字
特点：this代表当前对象。（this是所在函数所属对象的引用）
当前对象 ←→ 正在调用实例成员的对象 （谁调用方法谁就是当前对象）
this也可以用于在构造函数中调用其他构造函数。
注意：只能放在构造函数的首行 ，因为初始化动作要先执行。
------this不能用在static修饰的方法里和static修饰的代码块里;
[16]面对对象--------封装
封装、继承、多态为面向对象的三大特性。
封装的两个含义：
1，把对象的状态和行为看成一个整体，将二者存放在一个独立的类中；
2，隐藏对象的属性和实现细节，仅对外提供公共的访问方式
好处：1，将变化隔离
-------2，提高使用性
-------3，提高重用性
-------4，提高安全性
class Person1 {
private String name;
private int age;
private int sal;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
[17]访问修饰符-------------
权限 --------类内部-------同一个包----不同包子类-------任何地方
private-------可以
default-------可以------- --可以
protected---- 可以----------可以-----------可以
public--------可以----------可以----------可以------------可以
[18] 父类中的构造
1，对象的属性：属性必须私有化，通过getter和setter设置和获取
2 ，按需求可以加入若干构造函数
3 ，按需求可以添加相应方法，但是不要之间输出，交给调用者输出
[19]面对对象-----------继承
继承的概述：多个类（子类）中存在相同的属性和行为，可以将这些内容抽取到一个单独的类中（父类），多个类就不需定义那些属性和方法，只要继承即可。
子类可以访问 父类中非私有的属性和方法。
class SubDemo extends Demo{}
1、提高了代码的复用性。
2、让类与类之间产生关系，有了这个继承关系才有了多态的特性。
3、Java类中中只支持单继承。因为多继承会出现调用不确定性
4 , java支持多层继承。
class A{}//称为父类或基类
class B{} extends A{}//称为子类或拓展类
class C{} extends B{}
5 , 父类与子类之间是所属关系。
函数两个特性：------------------------------------------
1，重载。同一个类中。overload
2，覆盖。子类中。覆盖也称为重写，覆写。override
3 , 两者的异同？
方法的重写Overriding和重载Overloading是Java多态性的不同表现。
重写Overriding是父类与子类之间多态性的一种表现，
重载Overloading是一个类中多态性的一种表现。
如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写
子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。
如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。
Overloaded的方法是可以改变返回值的类型。
方法覆写时应遵循的原则： --------------------------------
1 : 方法名必须相同;
2：子类方法的返回值类型比父类方法的返回值类型更小或相等
----子类方法声明抛出的异常应比父类方法申明抛出的异常更小或相等;
3 : 子类方法的访问权限应比父类方法更大或相等;
4，静态只能覆盖静态，或被静态覆盖。
5 ，一个类想进行功能的扩展时，就需要定义个子类覆盖（保留）父类的功能，并定义子类中特有的功能时，就使用覆盖操作完成.
6 ， java.lang.Object是所有类的父类， Object是直接父类或是间接父类。
注意------------this和super基本类似
当本类的成员和局部变量同名用this区分。
当子父类中的成员变量同名用super区分父类。
this:代表一个本类对象的引用。
super：代表一个父类空间。
[20]单例模式-----饿汉式和懒汉
单例设计模式：就是可以保证一个类在内存中的对象唯一性。
如何保证对象唯一性呢？
1，不允许其他程序用new创建该类对象（私有化该类构造函数）
2，在该类创建一个本类实例（通过new在本类中创建一个本类对象）
3，对外提供一个方法让其他程序可以获取该对象。（定义一个公有的方法，将创建的对象返回）
//饿汉式
public class Single1 {// 类一加载，对象就已经存在了。
private static Single1 s = new Single1();
private Single1() {
}
public static Single1 getInstance() {
return s;
}
}
class Single {// 懒汉式
// 类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象。
------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------
// 延迟加载形式。
private static Single s = null;
private Single() {
}
public static Single getInstance() {
if (s == null)
s = new Single();
return s;
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
