简单复习java历程

一：主要特性：

java语法是简单的

抛弃“指针”，使用“引用”，提供废料收集，免除内存困扰

面向对象

提供类、继承和接口的特性，类只能实现单继承，而接口可以实现接口之间的多继承（implements）。

分布式

在基本的java编程接口中有一个网络应用接口（java net）

健壮的

java的强类型、异常处理、垃圾的自动收集机制保证java运行的畅通。

安全的

具有许多的安全特性，有一个安全防范类(ClassLoader)，提供安全机制（SecurityMananger）。

体系结构是中立的

java程序被编译为体系结构中立的字节码格式(.class文件)，可以实现在java平台的任何系统中运行

可移植性

高性能

多线程

通常用两种方法来创建线程，

一，使用型构为Thread（Runnable）的构造子讲一个实现了Runnable接口的对象包装成一个线程。

二，从Threa类派生出子类并重写run方法，使用该子类创建的对象即为线程。

java语言支持多个线程同时执行，并提供多个线程之间的同步机制（synchronized）

动态的

java语言设计目标之一就是适应动态变化的环境，需要的类可以动态加载然后载入到运行环境，也可通过网络载入所需类，能够时刻进行代码检查。

二：基本语法

java大小写敏感：

意味着hello和Hello的是不同的。

类名：

所有类名首字母必须大写。

方法名：

所有方法名首字母小写开头，若干个单词组成，每个单词首字母大写

原文件名：

原文件名必须和类名相同，保存用类名作为文件名保存，文件后缀为.java

主方法入口：

所有Java程序有public static void main(String []args){}开始执行

三：java变量

局部变量

类变量（静态变量）

成员变量(动态变量)

四：java数组

五：java对象和类

代码阐述：

• 对象：对象是类的一个实例（对象不是找个女朋友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
• 类：类是一个模板，它描述一类对象的行为和状态。

   public class ObjectClass {

        public static void main(String[] args) {
            // TODO Auto-generated method stub
            Person person = new Person();
            System.out.println("The Person's attribute:");
            person.walk();
            person.talk();
        }

    }
    //新建一个Person类
    class Person{
      //具有的属性
        String name;
        int age;
        double height;

        void walk(){
            System.out.println("The Person can Walk");
        }
        void talk(){
            System.out.println("The Person is talking");
        }
    }

创建对象：

 public class Puppy {

        public Puppy(String name) {
            //构造方法
            System.out.println("the dog's name:"+name);
        }

        public static void main(String[] args) {
            System.out.println("请输入的小狗的名字：");
            Scanner input = new Scanner(System.in);
            String getInput = input.nextLine();
            Puppy puppy = new Puppy(getInput);

        }

    }

访问实例变量和方法

   public class Puppy2 {

        int puppyAge;
        public Puppy2(String name) {
            //构造方法，用来初始化
            System.out.println("the dog's name:"+name);
        }   

        public int getPuppyAge() {
            System.out.println("The dog's age:"+puppyAge);
            return puppyAge;
        }


        public void setPuppyAge(int puppyAge) {

            this.puppyAge = puppyAge;
        }

        public static void main(String[] args) {
            //创建对象
            Puppy2 puppy = new Puppy2("tommy");
            //调用setAge方法设定age
            puppy.setPuppyAge(2);
            //调用getAge方法获取age
            puppy.getPuppyAge();
        }
    }

六：java继承

 public class Inherit {
        /**
         * 子类继承父类的方法和属性
         * 避免代码的重复性，提高编码效率，益于后期维护
         * @param args
         */
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            Dog dog = new Dog("tommy");
            System.out.println("调用父类的方法：");

            dog.eat();
            Cat cat = new Cat("mike");
            cat.sleep();
        }

    }
    class Animal{
        String name;
        public Animal(String name) {
            this.name = name;
        }
        void eat(){
            System.out.println(name+"正在吃");
        }
        void sleep(){
            System.out.println(name+"正在睡");
        }
    }
    class Dog extends Animal{
        public Dog(String name) {
            super(name);
        }
    }
    class Cat extends Animal{

        public Cat(String name) {
            super(name);

        }

    }

七：java多态

概念：多态就是同一个行为具有多个不同的表现形式

   多态就是同一个接口，使用不同的实例而执行不同的操作

优点：

1、消除类型之间的耦合关系

2、可替换

3、可扩充

4、接口性

5、灵活性

6、简化性

  public class Inherit2 {
        /**
         * 子类继承父类的方法和属性
         * 避免代码的重复性，提高编码效率，益于后期维护
         * @param args
         */
        public static void main(String[] args) {
            show(new Cat1());
            show(new Dog1());

            Animal1 a = new Cat1();
            a.eat(); //向上转型，调用cat1的eat
            Cat1 c = (Cat1)a;
            c.work(); //向下转型，调用Cat1的work

        }
      //同一种方法的不同表现形式
        public static void show(Animal1 a){
            a.eat();
            if(a instanceof Cat1){
                Cat1 c = (Cat1)a;
                c.work();
            }
            else if(a instanceof Dog1){
                Dog1 d = (Dog1)a;
                d.work();
            }
        }
    }
    abstract class Animal1{
        abstract void eat();
    }
    class Cat1 extends Animal1{
        void eat(){
            System.out.println("吃鱼");
        }
        void work(){
            System.out.println("抓老鼠");
        }
    }
    class Dog1 extends Animal1{
        void eat(){
            System.out.println("吃骨头");
        }
        void work(){
            System.out.println("看家");
        }
    }

java抽象类

java封装

java接口