面向对象_01

Posted 2020-10-16

概述：程序中使用对象来映射现实中的事物，使用对象的关系来描述事物之间的联系，这种思想称面向对象。

三大特性：封装性、继承性、多态性
封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式
原则：将不需要的对外提供的内容隐藏
属性都隐藏，提供公共方法对其访问
好处：将变化隔离
便于使用
提高复用性
提高安全性

通俗理解：用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 }