标签：安全 面向对象 使用 主函数 string 成员变量 多个 super关键字 共享
概述：程序中使用对象来映射现实中的事物，使用对象的关系来描述事物之间的联系，这种思想称面向对象。
三大特性：封装性、继承性、多态性
封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式
原则：将不需要的对外提供的内容隐藏
属性都隐藏，提供公共方法对其访问
好处：将变化隔离
便于使用
提高复用性
提高安全性
通俗理解：用Java对现实生活中的事物进行描述，通过类的形式来体现。
描述事物的关系：属性，行为
类：是对象的抽象，用于描述一组对象的共同特征和行为。
类中可定义成员变量和成员方法：成员变量<-->属性 ，成员方法<-->行为
1 class Person{ 2 int age; 3 String name; 4 //speak方法 5 void speak(){ 6 System.out.println("姓名:"+name+"\n"+"年龄："+age); 7 } 8 }
区分成员变量与局部变量?
定义在类中==>成员变量
定义在方法==>局部变量
注：局部变量与成员变量同名，则优先访问局部变量
1 package new_Object; 2 class Number{ 3 int n=2017;//类中定义称为成员变量 4 void show(){ 5 int n=2018;//方法中定义称为局部变量 6 System.out.println("访问局部变量："+n); 7 } 8 } 9 public class Example_Demo {//成员变量与局部变量 10 public static void main(String[] args) { 11 new Number().show(); 12 } 13 }
eclipse运行：
成员变量和局部变量得区别：
1，成员变量定义在类中，整个类中都可以访问，局部变量定义在函数，语句，局部代码块中，只在所属的区域有效。
2，成员变量存在于堆内存的对象中
局部变量存在于栈内存的方法中
3，成员变量随着对象的创建而存在，随对象的消失而消失
局部变量随着所属区域的执行而存在，随着所属区域结束而释放
4，成员变量都有默认初始化值
局部变量没有默认初始化值
类与对象关系：类=>事物的描述，对象=>该事物的实例.Java中通过关键字 new来创建对象 即：
对象创建与使用==v
类名 对象名称=new 类名 ();
Person p=new Person();
使用对象：通过对象.成员调用
1 package new_Object; 2 class Person_03{ 3 int age; 4 String name; 5 //speak方法 6 void speak(){ 7 System.out.println("姓名:"+name+"\n"+"年龄："+age); 8 } 9 } 10 public class Example_01 {//访问对象成员 11 public static void main(String[] args) { 12 //创建两个Person对象 13 Person_03 p1=new Person_03(); 14 Person_03 p2=new Person_03(); 15 //赋值 16 p1.name="小明"; 17 p1.age=12; 18 // 调用对象方法 19 p1.speak(); 20 p2.speak(); 21 } 22 }
eclipse run：
匿名对象[对象的简写格式]:Person p =new Person();<==>new Perosn.speak();
1，当对象对方法仅进行一次调用的时候，就可简化成匿名对象
2，匿名对象可作为实例参数进行传递
1 class Person{ 2 int age=12; 3 String name="小明"; 4 void speak(){ 5 System.out.println("姓名:"+name+"\n"+"年龄："+age); 6 } 7 } 8 public class Example_01 { 9 public static void main(String[] args) { 10 new Person().speak(); 11 } 12 }
类的封装：将类中的属性私有化，使用关键字private修饰，私有属性只能在它所属的类中被访问，外界访问则需要提供public修饰公有方法，例如:getXxx和 setXxx
1 package new_Object; 2 class Student{ 3 //创建私有化属性 4 private String name; 5 private int age; 6 //公有的getXxx()和getXxx()方法 7 public String getName() 8 { 9 return name; 10 } 11 public void setName(String stuName) 12 { 13 name=stuName; 14 } 15 public int getAge() 16 { 17 return age; 18 } 19 public void setAge(int stuAge) 20 { 21 //判断年龄数据是否合法 22 if (stuAge>0 && stuAge<=130) 23 { 24 age=stuAge; 25 }else 26 { 27 System.out.println("年龄数据不合法"); 28 } 29 } 30 void speak() 31 { 32 System.out.println("姓名："+name+"\n"+"年龄："+age); 33 } 34 } 35 public class EncapTest {//类的封装 36 public static void main(String[] args) { 37 Student stu =new Student(); 38 stu.setName("小明"); 39 stu.setAge(-23); 40 stu.speak(); 41 } 42 }
构造函数：1，函数名与类名一致
2，不用定义返回值类型
3，没有具体的返回值
作用：给对象进行初始化
一个类中如果没有定义过构造函数，该类会有一个默认的空参数构造函数，如果在类中定义了制定的构造函数，该类中默认构造函数就没有了。
一般函数和构造函数的区别？
构造函数：对象创建时，就会调用对应的构造函数，对对象进行初始化
一般函数：对象创建后，需要函数功能时才调用
构造函数：对象创建时，会调用只调用一次
一般函数：对象创建后，可以被调用多次
构造函数可以有多个，用于对不同的对象进行针对性初始化。
1 package new_Object; 2 class Person_02{ 3 private String name; 4 private int year; 5 //定义构造函数 6 Person_02(){ 7 name="迪丽热巴·迪力木拉提"; 8 year=9263; 9 //System.out.println(name+":"+year); 10 } 11 Person_02(String n,int data){ 12 name=n; 13 year=data; 14 } 15 public void speak(){ 16 System.out.println(name+":"+year); 17 } 18 } 19 public class Cons_Demo03 {//构造函数另一种写法,link-Cons_Demo/Cons_Demo01 20 public static void main(String[] args) { 21 Person_02 p1=new Person_02(); 22 p1.speak(); 23 Person_02 p2=new Person_02("胖迪",18); 24 p2.speak(); 25 } 26 }
多个构造函数在类中是以重载的形式来体现的。
重载:方法名相同，参数列表不一样且方法名与类名相同
1 package new_Object; 2 class Person_01{ 3 String name; 4 int age; 5 //定义两个参数的构造函数 6 Person_01(String Nname,int Aage){ 7 name=Nname; 8 age=Aage; 9 } 10 //定义一个参数的构造函数 11 Person_01(String Nname){ 12 name=Nname; 13 } 14 void show(){ 15 System.out.println("姓名："+name+age+"岁"); 16 } 17 } 18 public class Cons_Demo02 {//方法的重载 19 public static void main(String[] args) { 20 //创建p1,p2两个对象 21 Person_01 p1=new Person_01("小明",18); 22 p1.show(); 23 Person_01 p2=new Person_01("小红"); 24 //通过对象p1,p2调用show方法 25 p2.show(); 26 } 27 }
this关键字：
当成员变量和局部变量冲突，可用关键字this区分
this：代表对象，代表哪个对象？[当前对象]
this就是所在函数所属对象的引用
简单说：哪个对象调用了this所在的函数，this就代表哪个对象
1 package new_Object; 2 class Person_07{ 3 String name; 4 int age; 5 Person_07(String name){ 6 this.name=name; 7 } 8 Person_07(String name,int age){ 9 this.name=name; 10 this.age=age; 11 } 12 void speak(){ 13 System.out.println(this.name+":"+this.age);/*this可省略*/ 14 } 15 } 16 public class T_this01 {//this访问类中的成员变量，解决局部与成员变量名冲突 17 public static void main(String[] args) { 18 Person_07 p1=new Person_07("小红",13); 19 p1.speak(); 20 Person_07 p2=new Person_07("小强",10); 21 p2.speak(); 22 } 23 } 24 25 /* 26 * 当成员变量和局部变量冲突，可用关键字this区分 27 this：代表对象，代表哪个对象？[当前对象] 28 this就是所在函数所属对象的引用 29 简单说：哪个对象调用了this所在的函数，this就代表哪个对象 30 * */
this调用其他构造函数==>this.（参数1）
1 package new_Object;//构造函数之间的this 2 class Person_08{ 3 String name,Class; 4 int age; 5 Person_08(){ 6 name="小明"; 7 age=15; 8 } 9 Person_08(String name){ 10 this.name=name; 11 } 12 Person_08(String name,int age){ 13 /*对this的调用必须是构造函数中的第一个语句，因为初始化先执行*/ 14 this(name); 15 //this.name=name; 16 this.age=age; 17 } 18 void speak(){ 19 System.out.println(this.name+":"+this.age); 20 } 21 } 22 public class T_this02 { 23 public static void main(String[] args) { 24 new Person_08().speak(); 25 Person_08 p1=new Person_08("小红"); 26 p1.speak(); 27 Person_08 p2=new Person_08("小强",10); 28 p2.speak(); 29 } 30 }
注：对this的调用必须是构造函数中的第一个语句，因为初始化先执行
static 关键字：
用于修饰成员（成员变量和成员函数）
static特点: 1，static一个修饰符，用于修饰成员
2，static修饰的成员被所有对象共享
3，static优先于对象存在，因为static的成员随着类的加载而存在
4，static修饰的成员可直接被类名所调用==>类名.静态成员
5，static修饰的数据是共享数据，对象中的存储是特有数据
1 //static共享数据 2 package new_Object; 3 class Person_05{ 4 static String name;//成员变量【实例变量】 5 static String country="China";//静态变量【类变量】 6 public static void speak(){ 7 System.out.println(country+":"+name); 8 } 9 } 10 public class S_static01 { 11 public static void main(String[] args) { 12 //Person p=new Person(); 13 Person_05.speak(); 14 // p.name="小强"; 15 // p.speak(); 16 // System.out.println(p.country);/*被对象调用*/ 17 // System.out.println(Person.country);/*类名进行调用*/ 18 } 19 }
成员变量和静态变量区别？
1，两个变量生命周期不同。
-成员变量随着对象的创建而存在，随着对象被回收而释放
-静态变量对着类的加载而存在， 随着类的消失而消失[虚拟机结束]
2，调用方式不同
-成员变量只能被对象调用
-静态变量可被对象调用，也可被类名调用==>类名.静态成员
3,别名不同
-成员变量也称实例变量
-静态变量称类变量
4，数据存储位置不同
-成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据
-静态变量数据存储在方法区（数据共享区）的静态区，所以也叫对象的共享数据
静态使用的注意事项：
1，静态方法只能访问静态成员[变量，函数]（非静态既可访问静态，也可访问非静态）
2，静态方法中不可以使用this或super关键字(因为没有对象)
3，主函数是静态的
静态什么时候用？
1，静态变量
当分析对象中所具备的成员变量值都是相同的，这时这个成员可静态修饰，
只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。如果是相同的数据，对象不需要修改，只需要使用即可，不需要存储在对象，定义成静态的。
2，静态函数
函数是否用静态修饰，就参考一点，就是该函数功能是否有访问到对象中的特有数据。简单点说：从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的，不需要则是定义成静态的。
静态代码块：独立的代码区间，static代码块随着加载而执行且执行一次。
作用：用于给类进行初始化
1 //静态代码块 2 package new_Object; 3 class StaticCode{ 4 static int num; 5 static{ 6 num=2; 7 System.out.println("static静态代码块"); 8 } 9 void speak(){ 10 System.out.println(num); 11 } 12 } 13 public class S_static02 { 14 public static void main(String[] args) { 15 // StaticCode p=new StaticCode(); 16 // p.speak(); 17 new StaticCode().speak(); 18 new StaticCode().speak(); 19 /* 20 * static代码块随着加载而执行且执行一次 21 * 作用：用于给类进行初始化 22 * */ 23 } 24 }
代码块对所有相同对象的初始化
1 //构造函数代码块所有对象初始化 2 package new_Object; 3 class Person_06{ 4 private String name;/*私有化name属性*/ 5 //构造代码,所有对象初始化 6 { 7 Class();//调用封装 8 } 9 //创建两个Person构造函数 10 Person_06(){//对应对象进行针对性初始化 11 name="小红"; 12 //Class(); 13 } 14 Person_06(String name){ 15 this.name =name; 16 //Class(); 17 } 18 //打印方法 19 void speak(){ 20 System.out.println("姓名:"+name); 21 22 } 23 //统一属性进行封装 24 public void Class(){ 25 System.out.print("班级：软件工程\t"); 26 } 27 } 28 public class S_static03 { 29 public static void main(String[] args) { 30 Person_06 p1=new Person_06(); 31 p1.speak(); 32 Person_06 p2=new Person_06("小明"); 33 p2.speak(); 34 } 35 }
标签：安全 面向对象 使用 主函数 string 成员变量 多个 super关键字 共享
原文地址：http://www.cnblogs.com/cao-yin/p/7922188.html
