java中面向对象的特征-jsp java对象 js对象

Java面向对象——封装与继承（访问权限控制、static关键字）

1、什么是封装2、访问权限控制访问修饰符同类同包子类(不同包)其它总结

private

V

X

X

X

除了类内，其它都不可以访问，子类不可以继承

默认修饰符

V

V

X

X

包访问权限，即在同一个包内都是可以访问的

protected

V

V

V

X

在同类，同包都可以访问java中面向对象的特征，继承的子类也可以访问

public

V

V

V

V

对任何对象都是可访问的

        package ooday04;
        //访问控制修饰符的演示
        public class Coo {
            public int a;    //任何类
            protected int b; //本类、派生类、同包类
            int c;           //本类、同包类
            private int d;   //本类
    
            void show(){
                a = 1;
                b = 2;
                c = 3;
                d = 4;
            }
        }
    
        class Doo{ //----------------------演示private
            void show(){
                Coo o = new Coo();
                o.a = 1;
                o.b = 2;
                o.c = 3;
                //o.d = 4; //编译错误
            }
        }
    
        package ooday04_vis;
        import ooday04.Coo;
        public class Eoo { //-----------------演示同包的
            void show(){
                Coo o = new Coo();
                o.a = 1;
                //o.b = 2; //编译错误
                //o.c = 3; //编译错误
                //o.d = 4; //编译错误
            }
        }
      
        class Foo extends Coo{ //跨包继承-------演示protected
            void show(){
                a = 1;
                b = 2;
                //c = 3; //编译错误
                //d = 4; //编译错误
            }
        }

3、static关键字

       //演示静态变量
      class Goo{
           int a;
           static int b;
           Goo(){
               a++;
               b++;
           }
           void show(){
               System.out.println("a="+a+",b="+b);
           }
       }
       
       public class StaticDemo {
           public static void main(String[] args) {
               Goo o1 = new Goo();
               o1.show();
               Goo o2 = new Goo();
               o2.show();
               Goo o3 = new Goo();
               o3.show();
               System.out.println(Goo.b); //常常通过类名点来访问
           }
       }

       //演示静态方法
       class Hoo{
           int a; //实例变量(由对象来访问)
           static int b; //静态变量(由类名来访问)
       
           void show(){ //有this
               System.out.println(this.a);
               System.out.println(Hoo.b);
           }
           static void test(){ //没有this
               //静态方法中没有隐式this传递
               //没有this就意味着没有对象
               //而实例变量a是必须由对象来访问的
               //所以如下代码发生编译错误
               //System.out.println(a); //编译错误
               System.out.println(Hoo.b);
           }
       }
       
       //演示何时设计为静态方法
       class Ioo{
           int a; //对象的属性
       
           //在show()中访问了对象的属性，意味着show()方法与对象有关，不能设计为静态方法
           void show(){
               System.out.println(a);
           }
           //在plus()中没有访问对象的属性，意味着plus()方法与对象无关，可以设计为静态方法
           static int plus(int num1,int num2){
               int num = num1+num2;
               return num;
           }
       }
       
       public class StaticDemo {
           public static void main(String[] args) {
               Hoo.test(); //常常通过类名点来访问
           }
       }

       //演示静态块
       class Joo{
           static{
               System.out.println("静态块");
           }
           Joo(){
               System.out.println("构造方法");
           }
       }
       
       public class StaticDemo {
           public static void main(String[] args) {
               Joo o4 = new Joo();
               Joo o5 = new Joo();
               Joo o6 = new Joo();
               //输出静态块
               //构造方法
              //构造方法
              //构造方法
           }
       }

4、继承的用法5、子类可以继承父类的内容6、何时使用继承

1）是否存在is-a的关系java中面向对象的特征，存在就可以用

2）继承的使用条件

子类是特殊的类型，不代表是父类的角色

子类是父类的扩展，可以包含子类特有的属性和方法，且不能让父类的功能失效