一张图片 -----by李杰

对面向对象的认识

首先是对于面向对象中类的认识,使用类将事物抽象化,其中包涵了对象和方法,对象好比事物的属性而方法在我眼中更像是让事物去做的事。


对数据封装

然后是对数据的封装(private),其将类的属性和实现细节隐藏,防止了随意修改属性的发生,同时将复杂的细节隐藏,只保留了简洁的接口。 附上四种访问控制符作用级别: 访问控制符 同一类中 同一包中 同一子类中
private 是 否 否
default 是 是 否
protected 是 是 是
public 是 是 是


static和final的区别

接着是关于static和final区别:static在我本来的理解中他的存在使得变量不能够被改变,然而我的想法是错误的,static是将变量的值保存在固定的地址中,随时可以调用 提高了运行效率。 final关键字则体现出我之前对static关键字的认识,表示了‘不可变’的含义,可以修饰类,方法,变量。final使变量更为安全,同时 有助于编译器的优化。(下面是书上的)final的成员变量是不可变的,但对于对象引用变量,虽然其值的对象不能发生改变,但指向对象本身 的一些属性还是可以发生改变。final的局部变量只能初始化一次。


多态例子:
       public static void main(String[] args) {              
        // TODO Auto-generated method stub
        animal o=new animal();
        animal b=new dog();
        animal j=new cat();
        dog h=new dog();
        o.style();
        b.style();
        j.style();
        h.eat();
//dog类中的eat方法是dog子类独有的方法不是继承来的,所以要为其单独创建对象
        h.style();
    }

public class dog extends animal {  
    public  void style(){
        System.out.println("狗是犬科动物");
    }
    public void eat(){
        System.out.println("狗吃肉");
    }
//dog类中独有的方法,不是从父类继承
}
public class cat extends animal {  
    public void style(){
        System.out.println("猫是猫科动物");
    }
}
public class animal {  
    public void style(){
        System.out.println("动物有不同的分类");
    }
}

让一个子类对象继承一个父类对象,此时可以直接用父类对象来指向一个子类中从父类继承的对象并且 能够运行,而子类中独有的方法通过这个方式却不能运行。


自己对接口的一些心得
  1. 接口中的方法为抽象的不能用final关键字。(方法均为共有的抽象的)
  2. 接口中放置常量,不能将其值随意修改。
  3. 通过接口引用可以指向其访问的对象实现接口的方法。

多线程的例子
class Thread1 extends Thread{  
    //继承一个thread类,实现多线程
    private String name;
    public Thread1(String name) {
       this.name=name;
    }
    public void f1(){
        System.out.println(this);//此处与下一个f2中的this代表的地址不同
        //synchronized关键字实现了多个线程在执行该语句时以排队的方式执行
        synchronized (this) {
        //这里的this体现为一把锁 
        for (int i = 0; i < 5; i++) {
         System.out.println(name + "第一次运行  :  " + i);
         try {
              sleep((int) Math.random() * 10);//Math.random()是系统随机抽取0.1到1.0中的double类型的数,此处强制转化为int形,sleep()是程序延迟运行多长时间
                  //此处体现该程序在运行中随机性               
             } catch (InterruptedException e) {
              e.printStackTrace();//抛出一个特定的异常检查
         }
     }
    }
    public void f2(){
        System.out.println(this);
        synchronized (this){
        //与f1中的this构成了两把不同的锁
        for (int i = 0; i < 5; i++) {
            System.out.println(name + "第二次运行  :  " + i);
            try {
                sleep((int) Math.random() * 10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    }
}

public class Main {

    public static void main(String[] args) {


        final Thread1 mTh1=new Thread1("A");
        final Thread1 mTh2=new Thread1("B");

        new Thread(new Runnable() {
            public void run() {
                mTh1.f1();//实现了f1
            }
        }).start();//new Thread().start()要用到原本的线程需要加final
        //thread实现runnable接口的对象,new则是实现了runnable下的对象

        new Thread(new Runnable() {public void run() {
            mTh2.f2();}}).start();
}
  1. 实现多线程的方法:继承thread类或者实现runnable接口
  2. 多线程可以实现多个不相关的事物以不同的方式同时运行。
  3. 如果多个线程运行相同的任务锁的存在可以避免形成资源竞争。

zbyte

Read more posts by this author.

分享一下

查看评论