面向对象(Object Oriented)
Eg:大象装进冰箱
面向过程：
-
打开冰箱
-
存储大象
-
关上冰箱
对于面向对过程的思想，强调的是过程（动作）【C语言】
面向对象:
-
冰箱打开
-
冰箱存储
-
冰箱关闭
对于面下对象思想，强调的是对象（实体）【C++、Java、C#】
Java支持面向对象三大特性：封装、继承、多态，Java提供了private、protected、public三个访问控制修饰符来实现良好的封装。
面向对象核心：类和对象
Java用new关键字来创建对象：Person p =new Person();
Example（简单的类创建与调用）CarDemo
1 //类的简单举例 2 /*描述小汽车 3 1，属性:轮胎数、颜色 4 2，行为：运行 5 */ 6 class Car 7 { 8 int num=4; 9 String color; 10 void run() 11 { 12 //成员变量与局部变量同名时，优先访问局部变量。 13 int num=10; 14 System.out.println("轮胎数="+num+" 颜色="+color);//num=10 15 } 16 } 17 class CarDemo 18 { 19 public static void main(String[] args) 20 { 21 //在计算机中创建一个Car实例 关键new创建 22 Car c=new Car();//c是一个类 类型的引用变量，指向该类对象。 23 c.color="blue"; 24 c.run();//调用run方法 => [对象.成员] 25 } 26 } 27 /* 28 Car c=new Car(); 29 c.run(); 30 new Car().run();//匿名对象 简写形式 31 */
1.2 类与对象的关系
用Java语言对现实生活中的事物进行描述；通过类的形式来体现。
描述：属性和行为
对象：该事物的实实在在存在的实体。
类与对象之间关系？
类：事物的描述
对象：该类的实例（用关键字new来创建对象）
成员：成员变量 <=> 属性，成员函数 <=> 行为
成员变量与局部变量区别：
1，成员变量定义在类中（整个类可访问）
局部变量定义在函数中、语句、局部代码块中（所属的区域有效）
2，成员变量存在于堆内存的对象中
局部变量存在于栈内存的方法中
3，成员变量随着对象创建而存在，随着对象的消失而消失
局部变量随着所属区域的执行而存在，随着所属区域的结束而释放
4，成员变量都有默认初始化值（int类型 0；String 类型:null）
局部变量没有默认初始化值（编译会报错）
5，成员变量与局部变量同名时，优先访问局部变量。
基本数据类型和引用数据类型参数传递：TestDemo
1 //基本数据类型参数传递 2 class TestDemo 3 { 4 public static void main(String[] args) 5 { 6 int x=3; 7 show(x); 8 System.out.println("x="+x);//x=3 9 } 10 public static void show(int x) 11 { 12 x=4; 13 } 14 } 15 16 //引用数据类型参数传递 17 /*class TestDemo 18 { 19 int x=3; 20 public static void main(String [] args) 21 { 22 TestDemo d=new TestDemo(); 23 d.x=6; 24 show(d); 25 System.out.println(d.x);//x=4 26 } 27 public static void show(TestDemo d) 28 { 29 d.x=4; 30 } 31 }*/
小插曲：类类型参数（CarDemo2）
1 //类类型参数 2 class Car 3 { 4 int num; 5 String color; 6 } 7 class CarDemo2 8 { 9 public static void main(String[] args) 10 { 11 Car c1=new Car(); 12 Car c2=new Car(); 13 Car c3=new Car(); 14 //调用show方法 15 show(c1); 16 show(c2); 17 show(c3); 18 } 19 //代码抽取封装成功能(实例的属性共性) 20 public static void show(Car c)//类 类型的变量一定指向对象(否则:null) 21 { 22 c.num=3; 23 c.color="black"; 24 System.out.println("num="+c.num+" color="+c.color); 25 } 26 }
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。（private关键字修饰）
好处：
将变化隔离。
便于使用。
提高重用性。
提高安全性。
封装原则：
将不需要对外提供的内容都隐藏起来。
把属性都隐藏，提供公共方法对其访问（对外提供set ，get方法对其进行访问）
私有关键字[Private]
a,是一个权限修饰符。
b,用于修饰成员(成员变量和成员函数)
c,被私有化的成员只在本类中有效。
Example（PersonDemo）
1 //封装(Encapsulate) 2 class Person 3 { 4 //私有化age 关键字[private] 5 private int age; 6 /* 7 public void show(int a) 8 { 9 if (a>0 && a<120) 10 { 11 age=a; 12 speak(); 13 } 14 else 15 System.out.println("数据异常..."); 16 }*/ 17 //提供公共的方法获取值 18 public void setAge(int a) 19 { 20 //判断年龄是否合法 21 if (a>0 && a<120) 22 { 23 age=a; 24 speak(); 25 } 26 else 27 System.out.println("数据异常..."); 28 } 29 public int getAge() 30 { 31 return age; 32 } 33 34 void speak() 35 { 36 System.out.println("age="+age); 37 } 38 } 39 class PersonDemo 40 { 41 public static void main(String[] args) 42 { 43 Person p=new Person(); 44 p.setAge(-20); 45 } 46 }
//构造函数：构建创造对象时调用的函数。作用：可以给对象进行初始化
1.4.1 特点:
1，函数名与类名相同
2，不用定义返回值类型
3，没有具体返回值
1.4.2 默认构造函数：
类中若没有定义构造函数，该类会有一个默认的空参数的构造函数；
类中定义了指定的构造函数，默认的空参数构造函数就不存在了。
Example（ConsDemo）
1 //构造函数 2 class Person 3 { 4 private String name; 5 private int age; 6 //定义一个Person 类构造函数 7 Person() 8 { 9 //进行对象初始化 10 name="ConsDemo"; 11 age=12; 12 System.out.println("person run!"); 13 } 14 15 public void speak() 16 { 17 System.out.println("name="+name+" age="+age); 18 } 19 } 20 class ConsDemo 21 { 22 public static void main(String[] args) 23 { 24 Person p=new Person(); 25 p.speak(); 26 } 27 }
1.4.3 构造函数与一般函数的区别:
1，构造函数：对象创建时，调用与之对应的构造函数，对对象进行初始化；
一般函数：对象创建后，需要函数功能时才调用。
2，构造函数：对象创建时（调用一次）
一般函数：对象创建后（调用多次）
1.4.4 构造函数的重载（参数个数，参数类型）
一个类中出现多个构造函数是以重载的形式体现，可给不同的对象进行不同初始化属性值。
Example（ConsDemo2）
1 //构造函数的重载 2 class Person 3 { 4 private String name; 5 private int age; 6 //定义一个Person 类构造函数 7 Person() 8 { 9 //进行对象初始化 10 name="ConsDemo"; 11 age=12; 12 } 13 14 Person(String n) 15 { 16 name=n; 17 //age属性值虚拟机默认初始化为0 18 } 19 20 Person(String n,int a) 21 { 22 name=n; 23 age=a; 24 } 25 public void speak() 26 { 27 System.out.println("name="+name+" age="+age); 28 } 29 } 30 class ConsDemo2 31 { 32 public static void main(String[] args) 33 { 34 Person p=new Person(); 35 p.speak(); 36 Person p1=new Person("fuck"); 37 p1.speak(); 38 Person p2=new Person("fuck",20); 39 p2.speak(); 40 41 } 42 }
1.5 this关键字
this关键字:当成员和局部变量重名，this关键字区分；
this代表对象（当前对象）
this：所在函数所属对象的引用；
this关键字必须放在第一行（Java虚拟机先初始化值）
example(ThisDemo)
1 //this关键字 2 class Person 3 { 4 private String name; 5 private int age; 6 //定义Person 类构造函数 7 Person(String name) 8 { 9 this.name=name; 10 //age属性值虚拟机默认初始化为0 11 } 12 13 Person(String name,int age) 14 { 15 // this.name=name; 16 this(name);//必须放在第一行 17 this.age=age; 18 } 19 public void speak() 20 { 21 System.out.println("name="+this.name+" age="+this.age); 22 } 23 } 24 class ThisDemo 25 { 26 public static void main(String[] args) 27 { 28 Person p1=new Person("fuck"); 29 p1.speak(); 30 Person p2=new Person("fuck",20); 31 p2.speak(); 32 } 33 }
static特点：
1， static是一个修饰符，用于修饰成员；
2， static修饰的成员被所有的对象所共享；
3， static优先于对象存在，static的成员随着类的加载就已存在；
4， static修饰的成员可直接被类名所调用【类名.静态成员】；
5， static修饰的数据是共享数据，对象中存储的是特有数据；
成员变量跟静态变量的区别：
1，生命周期不同
成员变量随着对象创建而存在，随着对象的回收而释放；
静态变量随着类的加载而存在，随着类的消失而释放。(虚拟机消失)
2，调用方式不同
成员变量只能被对象调用；
静态变量可以被对象调用，也可被直接被类名调用。
3，别名不同
成员变量也称实例变量；
静态变量也称类变量
4，数据的存储位置不同
成员变量数据存储在堆内存的对象中，也叫对象的特有数据；
静态变量数据存储在方法区（静态区），也叫对象的共享数据。
example(StaticDemo )
1 class Person 2 { 3 String name;//成员变量[实例变量(堆内存中)] 4 //static 数据共享 5 static String country="CN";//静态变量[类变量] 6 public void sop() 7 { 8 System.out.println(country+":"+name); 9 } 10 } 11 class StaticDemo 12 { 13 public static void main(String[] args) 14 { 15 Person p=new Person(); 16 p.name="小明"; 17 p.sop(); 18 //类名调用 19 System.out.println(Person.country); 20 //对象调用 21 System.out.println(p.country); 22 } 23 }
Static使用注意事项：
1， 静态方法只能访问静态成员；（非静态既可以访问静态，又可访问静态）
2， 静态方法中不可以使用this或者super关键字；
3， 主函数是静态的。
example(StaticMain)
1 //static只能调用静态成员或者方法 2 /* 3 class StaticMain 4 { 5 static int num=5; 6 public static void main(String[] args) 7 { 8 show(); 9 } 10 public void show() 11 { 12 System.out.println(num); 13 } 14 } 15 */ 16 17 /* 18 ---------- javac ---------- 19 StaticMain.java:7: 错误: 无法从静态上下文中引用非静态 方法 show() 20 show(); 21 ^ 22 1 个错误 23 24 输出完成 (耗时 1 秒) - 正常终止 25 */ 26 /* 27 class StaticMain 28 { 29 int num=5; 30 public static void main(String[] args) 31 { 32 show(); 33 } 34 public static void show() 35 { 36 System.out.println(num); 37 } 38 } 39 */ 40 /* 41 ---------- javac ---------- 42 StaticMain.java:36: 错误: 无法从静态上下文中引用非静态 变量 num 43 System.out.println(num); 44 ^ 45 1 个错误 46 47 输出完成 (耗时 1 秒) - 正常终止 48 */ 49 50 //可解决问题，存在局限性 51 /* 52 class StaticMain 53 { 54 static int num=5; 55 public static void main(String[] args) 56 { 57 show(); 58 } 59 public static void show() 60 { 61 System.out.println(num); 62 } 63 } 64 65 */ 66 67 class StaticMain 68 { 69 int num=5; 70 public static void main(String[] args) 71 { 72 //创建对象调用 73 new StaticMain().show(); 74 } 75 public void show() 76 { 77 System.out.println(num); 78 } 79 }
注：学习之用；共享与道友。