------- android培训、java培训、期待与您交流！ ----------
目录：1、类和对象的关系，2、 面对对象的三大特征（封装，继承，多态），3、面向对象(单例设计模式)，
1、类和对象的关系
类就是对现实生活中事物的描述
对象就是这类事物实实在在存在的个体
例如：描述汽车 其实描述事物就是在描述事物的属性和行为！
class Car {
//汽车颜色
String color="红色";
//汽车轮胎数
int num =4;
//运行行为
void run(){
System.out.println(color+"...."+num);
}
}对汽车进行操作
class CarDemo
{
public static void main(String[] args)
{
//生产汽车，在java中通过new操作符或关键字来完成。
//怎么生产？其实就是在堆内存中产生个实体对象
Car c = new Car ();
//通过Car类建立的对象，所以new Car然后产生了一个对象，这个对象里已经具备了轮胎数和颜色
//为了好运算，所以给生产汽车起个名字，为Car c，这个时候c就是一个类类型变量，因为Car是一个类
//记住： 类类型变量指向对象，类类型变量一定指向该类所产生的实体对象。
//Car c = new Car();这个时候C为类类型变量，而类型为Car类型。
/*需求： 将已有的车改成蓝色，就需要指挥该对象做事情，在java当中的指挥方式是： 对象.对象成员
比如：要改变车的颜色，语句就是 c.color = "要更改颜色";
想让车运行起来，就要调用车的运行方法
*/
c.run();
Car c1 = new Car;
c1.run();
}}
匿名内部类：当对象的方法只调用一次时可以使用匿名内部类 这样比较简便，当进行多次调用时必须取个名字。
new Car.run();
2、 面对对象的三大特征（封装，继承，多态）
一.封装：
封装其实就是在隐藏对象的属性和实现细节，仅对外提供公共的访问方式
好处： 将变化隔离
便于使用
提高重用性
提高安全性
封装原则：
将不需要对外提供的内容都隐藏起来
将属性隐藏，提供公共方法对其访问
函数就是java中最小的封装体
封装--private
private:私有的（最小权限），权限修饰符：用于修饰类中的成员（成员变量，成员方法）
私有只在本类中有效。
注意：私有仅仅是封装的一种变现形式
一个方法属性对应两个访问方式，一个是设置变量(set设置)
另一个是获取变量（获取用get+变量名)
之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句
对访问的数据进行操作，提高代码的健壮性。
封装原则：①、将不需要对外提供的内容都隐藏起来
②、把属性都隐藏，提供公共方法对其访问
class Persion
{
private int age;
public static void getAge(int a)
{
age = a;
}
public void setAge(int a);
{
age = a;
}
public int getAge()
{
return age;
}
void speak()
{
System.out.println("age="+age);
}
class personDemo
{
public static void main(String[] args)
{
Person p = new Person
p.setAge(20);
p.speak();
}
}
}
3、面向对象(单例设计模式)
设计模式：解决某一类问题最行之有效的方法。
(单例设计模式,纯偏思想模式,java中有23种设计模式，称为jom设计模式)
单例设计模式:解决一个类在内存中只存在一个对象。
单例设计模式的写法：
对于事物该怎么描述，还是怎么描述，当需要将该事物的对象保证在内存中唯一时，用单例设计模式
有三部分写法：
1 将构造函数私有化
2 在类中创建一个本类对象
3 提供一个方法,可以获取该对象
想要保证对象唯一
1 为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象
2 还为了让其他程序可以访问到该类对象，只好在本类中自定义一个对象
3 为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式
这三部怎么用代码体现呢?
1 将构造函数私有化
2 在类中创建一个本类对象
3 提供一个方法，可以获取该对象
方法被调用访问只有两种方式,一种是对象，另一种是类名，但是在单例模式中，只能存在一个对象，不能在new对象了
所以只能通过类名来调用，如果要通过类名要调用，单例模式中的成员方法要静态,静态方法要访问类中的成员
在此例中对象就是成员，所以成员也要静态
单例设计模式分两种（模式饿汗式，懒汉式）
饿汉式特点：
类一进内存，就已经创建好了对象
在开发中，一般用恶汉式,因为饿汉式安全且简单
class Single
{
//在本类中创建本类对象
private static Single s = new Single();
//将构造函数私有化
private Single(){}
//提供一个对外访问的方法
public static Single getInstance()
{
return s;
}
}
懒汉式：对象调用方法时，才初始化，也叫做对象的延迟加载，称为懒汉式，先执行getInstance方法，当方法一运行，才在内存中建立对象，
对象就会把地址值返回到方法区里的类变量，存在安全隐患。
class Single
{
private static Single s = null;
private Single(){};
public static Single getInstance()
{
if (s==null)
{
s = new Single();
return s;
}
}
}
二 继承
继承的特点：
1 提高了代码的复用性
2 让类与类之间产生了关系，有了这个关系，才有了多态的特性.
3 在java中只有一个父类，多个子类
千万不要为了获取其他类的功能，简化代码而继承，必须是类与类之间有所属关系才可以继承
所属关系是:：is a(谁是谁中的一员)
父类是子类的共性不断抽取而来的，所以先有子类。
什么时候考虑继承关系?
研究某种事物的时候，是不是另一个事物中的一种那个，使用继承关系
如果一个事物，继承了另一个事物，发现子事物中不应该具有，父类事物中的内容该继承无效
class Person
{
String name;
int age;
}
//学生是子类,Person为父类
class Student extends Person
{
private String name;
private int age;
public static void study()
{
System.out.println("good study");
}
}
class Worker extends Person
{
private String name;
private int age;
public static void work()
{
System.out.println("good work");
}
}
在java语言当中，只支持单继承，不支持多继承。
因为多继承容易带来安全隐患，当多个父类中定义了相同功能，内容不同时，子类对象不确定运行哪一个
但是java保留这种机制，并用另一种体现形式来完成表示，叫做多实现。
查阅父类功能,创建子类对象使用功能
class C
{
private void demo1(){};
}
class A
{
private void demo1(){};
private void demo2(){};
}
//当B继承A的时候,他继承A的同时,同时也继承了demo2,所以B和A没有继承关系.
class B extends A
{
private void demo1(){};
private void demo3(){};
}
子父类中的变量的特点
类中成员包含三个部分：
1 成员变量 (如果子父类中出现了，非私有的同名变量时，子类要访问本类中的变量用this
那么子类要访问父类中的同名变量时，用super关键字，this关键字字和super关键字的引用是一样的)
2 成员函数
3 构造函数
super：关键字
this：代表的是本来对象的引用
super：代表的是父类对象的引用
父类中私有的部分，不被子类所继承
class Fu
{
int num1 = 4;
}
class Zi extends Fu
{
int num2 = 5;
void show()
{
System.out.println(num);
}
}
class ExtendsDemo2
{
public static void mani(String[] args)
{
Zi z = new Zi();
z.show();
//System.out.println(z.num1+"---"+zi.num2);
}
}
子父类中函数的特点-覆盖
当子类中出现了和父类一模一样的方法时，看上去好像是被覆盖一样
这个也是方法的特性，叫做子类重写(覆盖)父类方法，覆盖要保证方法一模一样
子类覆盖父类必须保证子类权限大于等于父类权限
Public protected default private
同一类中 是 是 是 是
同一包中 是 是 是 否
子类 是 是 否 否
不同包中 是 否 否 否
重载和覆盖的区别：
方法要一模一样，包括返回值类型都要一模一样! 重载是只看同名函数的参数列表。
覆盖：
静态覆盖静态，非静态覆盖非静态，只有方法才有覆盖!!!会运行子类函数的内容，如同父类的函数被覆盖一样。
这种情况就叫做重写，或者叫做覆盖！
当子类继承了父类，沿袭了父类的功能，到子类中，但是子类虽具备该功能，但是子类的功能内容却和父类不一致
这时，没有必要定义新功能,而是使用覆盖特性，保留父类的功能复用，并重写功能内容。
重写还可用于扩展
子父类构造函数特点：
在运行子类构造方法之前，先运行父类构造方法，再运行子类构造方法！
在对子类对象进行初始化时，父类的构造函数也会运行
那是因为子类的构造函数默认第一行有一条隐式的语句 super()
super()语句：会访问父类中空参数的构造函数，而且子类中所有的构造函数
默认第一行都是super()；
注意：
1 super()语句要写到子类构造函数的第一行，因为先去父类初始化。
2 构造函数里要么有this语句，要么有super语句，两者只有其一！
结论：(这个结论其实是：子类的实例化过程 )
子类所有的构造函数，默认都会访问父类中空参数的构造函数，
因为每一个子类构造函数内的第一行，都有一句隐式的super()；
当父类中没有空参数的构造函数时，子类必须手动通过super或者this语句形式指定要访问父类中的构造函数
当然子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数,子类中至少会有一个构造函数
会父类中的构造函数。
class Fu
{
Fu()
{
System.out.println("fu run1");
}
//如果下面再写一个有参数的构造函数,在子类对象调用的时候,跟它关系,因为没调用到.
Fu()
{
System.out.println("fu"+"run2");
}
}
class Zi extends Fu
{
//在子类的构造函数前有一个隐身的语句叫做,super()
Zi()
{
System.out.println("zi run");
}
}
class ExtendsDemo
{
public static void main(String[] args)
{
Zi z = new Zi();
}
}
//-------------------------------------------------------
class Person
{
private String name;
Person(String name)
{
this.name = name;
}
void show(){}
}
class Student extends Person
{
Student(String name)
{
super.name = name;
//也可以这样写 super(name);
}
void method()
{
super.show();
}
}
final：最终，是一个修饰符
1 final关键字可以修饰类，方法，和变量
2 final修饰的类不可以被继承(为了避免被继承，被子类复写功能，所以将类final)
3 final修饰的方法不可以被覆盖
4 final修饰的变量是一个常量，只能被赋值一次，既可以修饰成员变量，
又可以修饰局部变量(final锁定的成员变量显示值，
而不是成员变量默认值!)
(当在描述事物时，一些数据的出现，值是固定的，这时为了增强阅读性都给这些值都给这些值起个名字方便于阅读
而这个值不需要改变，所以加上final修饰，作为常量：常量的书写规范所有字母都大写，如果由多个单词组成，单词间通过下划线连接
以后在开发的时候，但凡数值是不变的，也要起个名字，加上final
5 内部类定义在类中的局部位置上时，只能访问被final修饰的局部变量
6 加上final后的变量，可以在构造函数内赋值，但是在一般函数中不能赋值！
当常量final没赋值的时候，可以在构造方法中给final变量赋值！可以为final赋显示值，final修饰的变量只能修饰一次
被final修饰的变量已变成常量,常量存在于方法区的常量池!
继承的优点是减少了代码量，而弊端在于是打破了封装
387
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
