------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------
面向对象概念
面向对象是相对面向过程而言,面向对象和面向过程都是一种思想。
强调的是功能行为。代表语言:C语言。
面向对象:
将功能封装进对象,强调具备了功能的对象。代表语言:Java、C++、C#。
1.冰箱打开。
2.冰箱存储。
3.冰箱关闭。
"关上"的行为功能,我们只需要让冰箱执行它具备的功能就可以了。这就是一种面向对象的以执行功能的对象为
主体的思想体现。
是一种符合人们思考习惯的思想,可以将复杂的事情简单化,将程序员从执行者转换成了指挥者。
1.先要去找具有所需功能的对象来用。
2.如果该对象不存在,那么创建一个具有所需功能的对象。
这样可以简化开发并提高复用。
开发的过程:
其实就是不断的创建对象,使用对象,指挥对象做事情。
设计的过程:
其实就是在管理和维护对象之间的关系。
封装(encapsulation)
继承(inheritance)
多态(polymorphism)
类的定义
生活中描述事物无非就是描述事物的属性和行为。
如:人有身高,体重等属性,有说话,打球等行为。
Java中用类class来描述事物也是如此。
属性:对应类中的成员变量。
行为:对应类中的成员函数。
定义类其实在定义类中的成员(成员变量和成员函数)。
成员变量和局部变量的区别?
成员变量:
1.成员变量定义在类中,在整个类中都可以被访问。
2.成员变量随着对象的建立而建立,随着对象的消失而消失,存在于对象所在的堆内存中。
3.成员变量有默认初始化值。
局部变量:
1.局部变量只定义在局部范围内,如:函数内,语句内等,只在所属的区域有效。
2.局部变量存在于栈内存中,作用的范围结束,变量空间会自动释放。
3.局部变量没有默认初始化值。
创建对象,使用对象
/**
* 描述小汽车
* 分析:
* 1.属性:轮胎数,颜色
* 2.行为:运行.
* 定义类契税就是在定义类中的成员.
* 成员:成员变量<-->属性
* 成员函数<-->行为
*/
//对Car这类事物经行描述
class Car{
//成员变量
String color = "red";
int num = 4;
//成员方法
void show(){
//临时变量
int num = 10;
//输出临时变量的值
System.out.println("color="+color +" num"+num);
}
public static void run(){
System.out.println("function run is running");
}
}
public class CarDemo {
public static void main(String[] args) {
//fun1();
//匿名对象:对象的简化形式.
//两种使用情况:1.当对对象方法仅进行一次调用时;
//2.匿名对象可以作为实际参数进行传递.
new Car().run();
show(new Car());
}
public static void show(Car c){
c.num = 3;
c.color = "black";
System.out.println("function show is running!");
System.out.println(c.num + "..." + c.color);
}
public static void fun1() {
//通过new关键字,建立对象
//c就是一个类类型的引用变量,指向了该类的对象
Car c = new Car();
c.show();
//对对象的属性进行修改
c.color = "black";
//输出成员变量的默认值
System.out.println(c.num);
//通过对象.成员的形式来使用对象的功能
c.show();
}
}
运行结果:
function run is running
function show is running!
3...black
public class DuixiangDemo {
int x = 3;
public static void main(String[] args) {
/*int x = 3;
System.out.println("x=" + x);
show(x);
System.out.println("x=" + x);*/
DuixiangDemo d = new DuixiangDemo();
d.x = 9;
System.out.println(d.x);
show(d.x);
System.out.println(d.x);
}
public static void show(int x){
/**
* 基本数据类型参数传递
*/
//x = 4;
}
public static void show(DuixiangDemo d){
d.x = 4;
}
}
运行结果:
9
9
封装:是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。
好处:
1.将变化隔离。
2.便于使用。
3.提高重用性。
4.提高安全性。
封装原则:
1.将不需要对外提供的内容都隐藏起来。
2.把属性都隐藏,提供公共方法对其访问。如,getXXX,setXXX。
package cn.fuxi.zhabaotan;
/**
* 人:
* 属性:年龄
* 行为:说话
*/
class Person{
//private:私有,是一个权限修饰符,用于修饰
//不希望别人直接访问赋值,需要通过私有化把属性进行隐藏
private int age ;
//通过提供set get 公共方法对其访问
public void setAge(int a){
if(a > 0 && a < 130){
this.age = a;
}else{
System.out.println("错误的数据,请输入1~129内的整数");
}
}
public int getAge(){
return age ;
}
void speak(){
System.out.println("我的年龄是"+age);
}
}
public class PersonDemo {
public static void main(String[] args) {
Person p = new Person();
//通过其他方式访问
p.setAge(10);
p.speak();
//赋值不合法,set方法就不允许成功赋值
p.setAge(-20);
System.out.println(p.getAge());
}
//1.私有仅仅是封装的一种体现而已.
//2.private 关键字:是一个权限修饰符,用于修饰成员(成员变量和成员函数),被私有化的成员之在本类中有效.
//3.常用场景之一:将成员变量私有化,对外提供对应的set get方法对其经行访问,提高对数据访问的安全性.
}
输出结果:
我的年龄是10
错误的数据,请输入1~129内的整数
10
package cn.fuxi.zhabaotan;
public class HanSu {
/**
* 根据考试成绩获取学生分数对应的等级。
90~100 A
80~89 B
70~79 C
60~69 D
60以下 E
*/
public static void main(String[] args) {
String s = score(57);
System.out.println(s);
}
public static String score(int i){
if(i>=90 && i<=100){
return "A";
}else if(i>=80 && i<90){
return "B";
}else if(i>=70 && i<80){
return "C";
}else if(i>=60 && i<70){
return "D";
}else if(i>=0 && i<60){
return "E";
}else {
return "您的输入有误,请数值为输入0~100以内的整数:";
}
}
}
输出结果:
E
package cn.fuxi.zhabaotan2;
/**
*通过this在构造函数中调用其他构造函数的时候
*只能定义在构造函数的第一行
*因为初始化动作要先执行,否则就会报错.
*/
class Cat{
private String name;
private int age;
Cat(String name, int age){
this.name =name;
this.age = age;
}
public boolean compare(Cat c){
return this.age == c.age;
}
}
public class ThisDemo2 {
public static void main(String[] args) {
Cat c1 = new Cat("咪咪",10);
Cat c2 = new Cat("喵喵",10);
System.out.println(c1.compare(c2));
}
}
输出结果:
true
package cn.fuxi.zhabaotan2;
/**
* static 关键字:用于修饰成员(成员变量和成员函数).
* 特点:
* 1.随着类的加载而加载.
* 2.优先于对象存在.
* 3.被所有对象所共享.
* 4.可以被类名直接调用.
*/
class Cat2{
//成员变量 = 实例变量
String name;
//静态变量 = 类变量
//所有对象共享的属性用static修饰
static String country = "China";
public void show(){
System.out.println(country +":"+name);
//等效语句:System.out.println(Cat2.country + ":" + this.name);
}
}
public class StaticDemo {
public static void main(String[] args) {
//可以在创建对象之前使用
Cat2.country = "中国";
System.out.println(Cat2.country);
Cat2 c1 = new Cat2();
c1.country = "北京";
method_1();
System.out.println(Cat2.country);
System.out.println(c1.country);
}
public static void method_1(){
Cat2 c2 = new Cat2();
c2.country = "江西";
}
}
/*
* 静态变量和成员变量的区别
* 1.生命周期:
* 静态变量:随着类的加载存在,随着类消失,可以不创建对象用类名调用
* 成员变量:随着对象的创建存在,在栈内存中,随着对象消失而消失
* 2.调用方式不同
* 静态变量:可以被对象调用,也可以被类名调用
* 成员变量,只能被对象调用
* 3.存储位置不同
* 静态变量:存储在方法区(共享数据区)的静态区,所以也叫对象的共享数据
* 成员变量:存储在堆内存的对象中.所以也叫对象的特有数据
* 4.别名不同
* 静态变量 = 类变量
* 成员变量 = 实例变量
*
* 注意事项:
* 1.静态方法只能访问静态成员,如果访问非静态成员,就会报错!
* 原因:静态方法和变量存在的时候,对象还不存在,非今天变量也不纯在,肯定无法访问.
* 所以只有在创建对象之后,通过对象调用该变量,就不会有生命周期的问题
* 2.静态方法中不可以写this,super关键字
* 原因:生命周期不同,this代表的就是调用方法的那个对象,但是有静态时还没有对象出现
* 3.主函数是静态的
* 特点:1--格式固定的
* 2--被jvm所识别和调用
*
*/
输出结果:
中国
江西
江西
package cn.fuxi.zhabaotan2;
/**
* 静态什么时候用?
* 1.静态变量
* 当分析对象中具备的成员变量的值都是相同时,这时这个成员就可以被静态修饰.
* 只要数据在对象中都是不同的,就是对象的特有数据,必须存储在对象中,是非静态的.
* 如果是相同的数据,对象不需要做修改,只需要使用即可,不需要存储在对象中,定义成静态的.
* 2.静态函数
* 函数是否用静态修饰,就参考一点,就是该函数功能是否需要访问到对象中的特有数据.
* 从源代码来看,该功能是否需=需要访问非静态的成员变量,如果需要,该功能就是非静态的.
* 如果不需要,就可以将该功能定义成静态的.当然,也可以定义成非静态,但是非静态需要被对象调用.
* 如果没有访问特有数据的方法,该对象的创建时没有意义.
*/
class Demo2{
int age;
static int num = 9;
public static void speak(){
System.out.println(num);
}
public void show(){
System.out.println(age);
}
}
public class StaticDemo2 {
public static void main(String[] args) {
Demo2.speak();
new Demo2().show();
}
}
输出结果:
9
0
/**
* 静态代码块
* 随着类的加载而执行,而且只执行一次.
* 作用:用于给类进行初始化.
*/
class StaticCode{
static int num;
static{
num = 10;
}
static void show(){
System.out.println(num);
}
}
public class StaticDemo3 {
public static void main(String[] args) {
StaticCode.show();
}
}
输出结果:
10