快捷搜索:

您的位置:澳门新葡4473网站 > 澳门新葡4473网站 > Java学习 (十)、面向对象编程(二)封装,ja

Java学习 (十)、面向对象编程(二)封装,ja

发布时间:2020-01-16 20:31编辑:澳门新葡4473网站浏览(114)

    1.使用new+构造方法创建一个对象

    Java学习 (十)、面向对象编程(二)封装,java面向对象编程

    面向对象三大特点:封装、继承、多态

    封装概念

    ①   将东西包装在一起,然后以新的完整形式呈现出来:

    将方法和字段一起包装到一个单元中,单元以类的形式实现;

    ②   信息隐藏,隐藏对象的实现细节,不让外部直接访问到;

    ③   将数据和方法包装进类中,加上具体实现的隐藏,共同被称作封装,其结果是一个同时带有特征和行为的数据类型;

    ④   定义类,定义其属性、方法的过程称为封装类;

     

    信息隐藏式OOP最重要的功能之一,也是使用访问修饰符的原因;

    信息隐藏的原因包括:

    ①   对模块的任何实现细节所作的更改不会影响使用该模块的代码;

    ②   防止用户意外修改数据;

    ③   是模块易于使用和维护;

     

    访问修饰符

    ①   public:该类或非该类都均可访问;

    ②   private:只有该类可以访问;

    ③   protected:该类及其子类的成员可以访问,同一个包中的类也可以访问;

    ④   默认:同一包中的类可以访问;

     

    属性封装的实现

    ①   修改属性的可见性来限制对属性的访问;

    ②   为每个属性创建一对赋值(setter)方法和取值(getter)方法,用于公开对这些属性的访问接口;

    ③   在setter和getter方法中,根据需要加入对属性操作的限制;

    要点:除非必须公开底层实现细节,否则应该将所有属性指定为private加以封装;使用属性封装,通过增加数据访问限制,增强了类的可维护性;

     

    封装方法的目的

    ①   隐藏方法实现细节(方法体),向外部提供公开接口(方法头),以供安全;

    ②   简化调用,方便修改维护;

    ③   根据需要,可以私有化方法以供类内部使用----帮助方法help;

    图片 1 1 public class TeacherDemo 2 { 3 public static void main(String []agrs){ 4 Teacher t=new Teacher(); 5 //t.name="张三";//不能直接赋值 6 t.setName("张三"); 7 System.out.println(t.getName()); 8 t.setAge(10); 9 System.out.println(t.getAge()); 10 } 11 } 12 13 class Teacher 14 { 15 private String name; 16 private int age; 17 public void setName(String tname){ 18 name=tname; 19 } 20 public String getName(){ 21 return name; 22 } 23 public void setAge(int tage){ 24 if(tage<25) 25 { 26 System.out.println("年龄太小了"); 27 age=25; 28 } 29 else 30 { 31 age=tage; 32 } 33 } 34 public int getAge(){ 35 return age; 36 } 37 } View Code

     

    类的构造方法的概念和作用

    ①   构造方法负责对象初始化工作,为对象的属性赋合适的初始值;

    ②   创建对象时,其类的构造方法确保在用户操作对象之前,系统保证初始化的进行;

    构造方法的语法规则

    ①   构造方法名与类名相同

    ②   没有返回类型

    ③   方法实现主要为字段赋初值

    构造方法的调用和特别:new操作符(返回新建实例的引用)

    无参构造方法

    图片 2 1 public class ConstructorDemo 2 { 3 public static void main(String []agrs){ 4 Person p=new Person();//实例化的时候是有初始值的int默认0,String默认null 5 p.setName("张三"); 6 p.setAge(10); 7 System.out.println(p.toString()); 8 } 9 } 10 11 //当一个类没有显示声明一个构造方法时,系统会有一个默认的无参构造方法 12 class Person 13 { 14 private String name; 15 private int age; 16 private String city; 17 18 //默认的构造方法,实例化时候会调用,此处不写也可以,系统已默认写好 19 public Person(){ 20 System.out.println("Person"); 21 } 22 23 24 public void setCity(String pcity){ 25 city =pcity; 26 } 27 public String getCity(){ 28 return city; 29 } 30 31 public void setName(String pname){ 32 name=pname; 33 } 34 public String getName(){ 35 return name; 36 } 37 38 public void setAge(int page){ 39 age=page; 40 } 41 public int getAge(){ 42 return age; 43 } 44 45 public String toString() 46 { 47 return "名字:"+name+",今年"+age+"岁,家住"+city; 48 } 49 } View Code

    带参构造方法

    图片 3 1 public class ConstructorDemo 2 { 3 public static void main(String []agrs){ 4 //带参调用,若不写参数会报错,因为Person中只有一个带参的构造方法 5 Person p=new Person("张三",10,"杭州"); 6 //1、在堆中开辟空间,给属性分配默认的初始值 7 //2、假设属性一开始就赋值了,就进行赋值工作 8 //3、调用构造方法对属性进行初始化 9 System.out.println(p.toString()); 10 } 11 } 12 13 class Person 14 { 15 private String name="李四"; 16 private int age; 17 private String city; 18 19 //带参数的构造方法 20 public Person(String pname,int page,String pcity ){ 21 name=pname; 22 age=page; 23 city=pcity; 24 } 25 26 public void setCity(String pcity){ 27 city =pcity; 28 } 29 public String getCity(){ 30 return city; 31 } 32 33 public void setName(String pname){ 34 name=pname; 35 } 36 public String getName(){ 37 return name; 38 } 39 40 public void setAge(int page){ 41 age=page; 42 } 43 public int getAge(){ 44 return age; 45 } 46 47 public String toString() 48 { 49 return "名字:"+name+",今年"+age+"岁,家住"+city; 50 } 51 } View Code

     

    this关键字

    特点:

    ①在类的方法中使用的this关键字代表的是调用此方法的对象的引用;

    ②this可以看作是一个变量,它的值是当前对象的引用;

    ③使用this可以处理方法中的成员变量和形参同名的问题;

    ④当方法内需要用到调用该方法的对象时,就可以用this;

    ⑤在类的构造方法中可以调用this([参数列表])来调用该类的指定构造方法。

    图片 4 1 public class ConstructorDemo 2 { 3 public static void main(String []agrs){ 4 Person p=new Person("张三",10,"杭州"); 5 System.out.println(p.toString()); 6 } 7 } 8 9 10 class Person 11 { 12 private String name="李四"; 13 private int age; 14 private String city; 15 16 //构造方法 17 public Person(){ 18 System.out.println("无参构造方法"); 19 } 20 21 //带参数的构造方法 22 public Person(String name,int age,String city ){ 23 24 this();//表示调用当前对象的无参构造方法,必须写在第一句 25 26 //此处将形参名称写成age与属性名相同 27 //age=age;//此处不会对属性重新赋值age=0 28 this.age=age;//此处对属性重新赋值age=10,this代表p 29 this.name=name; 30 this.city=city; 31 32 } 33 34 public void setCity(String city){ 35 this.city=city; 36 } 37 public String getCity(){ 38 return city; 39 } 40 41 public void setName(String name){ 42 this.name=name; 43 } 44 public String getName(){ 45 return name; 46 } 47 48 public void setAge(int age){ 49 this.age=age; 50 } 51 public int getAge(){ 52 return age; 53 } 54 55 public String toString() 56 { 57 //默认前面都是有this的,可写可不写 58 System.out.println(this.getAge()); 59 return "名字:"+this.name+",今年"+age+"岁,家住"+city; 60 } 61 } View Code

     

    static关键字

    特点:

    ①用来修饰类的成员----修饰成员变量的称之为类变量(静态变量),修饰成员方法的称之为类方法(静态方法);

    ②当类被加载时就会被加载,优先于对象的存在;

    ③用来修饰语句块----称之为静态代码块。先于构造方法之前执行,只会执行一次,用来对静态成员做初始化;

    ④静态修饰的成员被所有的对象共享;

    ⑤调用的时候可以直接通过类名.成员来进行访问

    static关键字注意事项

    ①   静态方法中只能访问外部的静态成员;

    ②   静态方法中不能出现this;

     

    非静态

    图片 5 1 public class StaticDemo 2 { 3 public static void main(String []agrs){ 4 Account acc1=new Account(); 5 acc1.number1++; 6 acc1.showNumber1(); 7 acc1.showNumber2(); 8 9 Account acc2=new Account(); 10 acc2.showNumber1(); 11 acc2.showNumber2(); 12 } 13 } 14 15 class Account 16 { 17 public int number1=1; 18 public int number2=2; 19 public void showNumber1() 20 { 21 System.out.println(number1); 22 } 23 public void showNumber2() 24 { 25 System.out.println(number2); 26 } 27 } View Code

    静态1

    图片 6 1 public class StaticDemo 2 { 3 public static void main(String []agrs){ 4 Account acc1=new Account(); 5 acc1.number1++; 6 acc1.showNumber1(); 7 //acc1.showNumber2(); 8 9 10 Account acc2=new Account(); 11 acc2.showNumber1(); 12 //acc2.showNumber2(); 13 } 14 } 15 16 class Account 17 { 18 public static int number1=1;//静态变量(类变量),它不属于任何一个对象,被多个对象共享 19 public int number2=2; 20 public void showNumber1() 21 { 22 System.out.println(number1); 23 } 24 public void showNumber2() 25 { 26 System.out.println(number2); 27 } 28 } View Code

    静态2

    图片 7 1 public class StaticDemo 2 { 3 public static void main(String []agrs){ 4 Account.number1++; 5 System.out.println(Account.number1); 6 Account.showNumber1(); 7 8 Account acc1=new Account(); 9 acc1.showNumber2(); 10 11 Account acc2=new Account(); 12 acc2.showNumber2(); 13 } 14 } 15 16 class Account 17 { 18 public static int number1=1;//静态变量(类变量),它不属于任何一个对象,被多个对象共享 19 public int number2=2; 20 //静态方法中不能使用非静态的变量 21 //静态方法中不能使用this 22 public static void showNumber1() 23 { 24 //showNumber2();//报错 25 System.out.println(number1); 26 //System.out.println(this.number2);//报错 27 } 28 29 //非静态的方法可以访问静态的内容和非静态的属性和方法 30 public void showNumber2() 31 { 32 showNumber1(); 33 System.out.println(number2); 34 System.out.println("非静态方法访问静态变量:"+number1); 35 } 36 37 //构造方法 38 public Account(){ 39 System.out.println("constructor"); 40 } 41 42 //static语句块 43 //在类被加载时就会执行,只会执行一次,用来对静态的变量赋值 44 //优先于构造方法执行 45 static{ 46 System.out.println("static"); 47 number1=100; 48 } 49 } View Code

     

    方法重载

    多数程序设计语言要求为每个方法(函数)提供一个独一无二的方法名,不存在方法重载的概念

    在Java中,规定方法签名是解析方法的规则而不是方法名,为方法重载开创了条件

    方法重载使得在一个类中,方法名相同而参数列表不同的方法可同时存在,代表相似的行为和功能

     

    重载overload概念:同一类中,同名不同参的方法称为重载方法

    注意:仅有返回类型不同的方法不能称为重载,即方法重载必须方法签名不同

    图片 8 1 public class OverloadDemo{ 2 public static void main(String []agrs){ 3 Printer p=new Printer(2000); 4 p.print("hello"); 5 p.print(10); 6 p.print("hello",10); 7 } 8 } 9 10 class Printer{ 11 private String brand="联想"; 12 private double price; 13 14 public Printer(double price){ 15 this.price=price; 16 } 17 18 public Printer(String brand,double price){ 19 this.brand=brand; 20 this.price=price; 21 } 22 23 public void print(String content){ 24 System.out.println("字符串"+content); 25 } 26 27 public void print(int content){ 28 System.out.println("整型"+content); 29 } 30 31 public void print(String str,int content){ 32 System.out.println(str+"--"+content); 33 } 34 35 public int print(int content,double d){ 36 return content; 37 } 38 } View Code

     

    (十)、面向对象编程(二)封装,java面向对象编程 面向对象三大特点:封装、继承、多态 封装概念 ① 将东西包装在一起,然后...

        Student one = new Student();//后面的Stu就是一个构造方法

    E:

    class Cat{

        private String name;

        private int age;

        Cat(String name ,int age){//这是一个构造器

            this.name = name;//关键词 this 讲解 

            this.age =age;

        }    

        public String toString(){

            return "名字:"+name+"年龄:"+age;

            

        }

    }

    public class A_1{

        public static void main(){

            Cat one = new Cat("Jhon",12);//利用构造器创建一个新的对象   

            Syso(one); //默认调用toString();方法,即one.toString();,但是建议重写

        }

    }

    注:toString();方法 :

    在java中,所有对象都有toString()这个方法

    创建类时没有定义toString()输出对象时默认输出此对象的哈希码值(即内存地址)

    它通常只是为了输出方便,比如syso(xx);里的xx如果不是String类型的话,就自动调用xx的toString()方法

    它只是sun公司在开发java的时候为了方便所有类的字符串操作而特意加入的一个方法

        this关键字:

    在类的方法定义中使用this关键字代表使用该方法的对象的引用

    有时候用this可以处理方法中成员变量和形参的重名问题

    this可以看作一个变量,它的值是当前对象的引用

    2.构造函数是定义在java类中的一个用来初始化对象的函数

    3.构造函数与类同名而且没有返回值

    4.构造方法也可以重载 比如一个无参数 一个有参数 (形参)

    注:没有写构造方法时系统自动给出

        e:Cat(){

        }

        什么也不做,new时直接创建一个这样的方法

    但是一旦给出了构造方法 系统便不在给默认的构造方法!!!

    扩:a.类中的成员变量直接输出为:0 null 或者 flase,定义为 static的输出也如此(可以不赋值);但是局部变量的话必须要赋值

    b.return2个作用:1返回 2.结束方法的执行 e:if(a==0) return;这个是结束此方法的执行

    本文由澳门新葡4473网站发布于澳门新葡4473网站,转载请注明出处:Java学习 (十)、面向对象编程(二)封装,ja

    关键词:

上一篇:生活备忘录

下一篇:没有了