Java对象基本语法1(对比c++)

对象的使用

        /*
            创建对象
        */
        Student s=new Student();
        s.name = "张三";
        s.age = 23;
        s.gender = '男';

传递对象参数

class Test1{
    public void run(Student s){
        System.out.println("run");
        s.sleep();
    }
}

成员函数的声明

每个成员函数都要加上封装声明

class Student{

    private String name;
    private int age;
    private char gender;    
    public void study(){
        System.out.println(name+"在学习");
    }
    public void sleep(){
        System.out.println(name+"在睡觉");
    }
    public Student print()
    {
        Student s= new Student();
        return s;
    }
    public void setAge(int nAge){
        age=nAge;
    }
    public int getAge(){
        return age;
    }
}

私有性封装

每个私有变量也要加上封装声明

class Student{

    private String name;
    private int age;
    private char gender;    
    public void study(){
        System.out.println(name+"在学习");
    }
    public void sleep(){
        System.out.println(name+"在睡觉");
    }
    public Student print()
    {
        Student s= new Student();
        return s;
    }
    public void setAge(int nAge){
        age=nAge;
    }
    public int getAge(){
        return age;
    }
}

继承

• 类继承的关键字是extends

class Person {
    private String name;
    private int age;

    /*public Person() {

    }*/

    public Person(String name,int age) {
        this.name = name;
        this.age = age;
    }

}

class Student extends Person {

• java中只支持单继承

class DemoA {
    public void show1() {
        System.out.println("DemoA");
    }
}

class DemoB extends DemoA {
    public void show2() {
        System.out.println("DemoB");
    }
}

• 使用super访问父类的成员

class Fu {
    int num1 = 10;
    int num2 = 30;
}

class Zi extends Fu {
    int num2 = 20;

    public void show() {                //就近原则,自己有就不用父类的
        System.out.println(super.num1);
        System.out.println(this.num2);
        //System.out.println(super.num2);   //super可以调用父类的成员变量
    }
}

• 父类的构造需要调用super

class Person {
    private String name;
    private int age;

    /*public Person() {

    }*/

    public Person(String name,int age) {
        this.name = name;
        this.age = age;
    }

}

class Student extends Person {
    public Student() {
        //super("李四",24);                   //构造函数中有super没this,有this没super
                                            //this和super语句必须放在构造函数的第一行
                                            //无论如何子类必须要访问父类的构造函数
        this("李四",24);                  //调用本类其他的构造方法
    }

    public Student(String name,int age) {   //name 李四,age 24
        super(name,age);
    }

}

Final修饰符，对比const

• final修饰的类,不可以被继承

final class Fu {
    public  void method() {
        System.out.println("访问底层文件");
    }
}

class Zi extends Fu {//错误
    final double PI = 3.14;
    public void method() {
        System.out.println("哈哈,被我干掉了");
    }
}

• 修饰的方法,不可以被重写

final class Fu {
    public finnal  void method() {
        System.out.println("访问底层文件");
    }
}

• 修饰变量，变量就变成了常量，只能被赋值一次.这个和c++是一样的。

多态

Java中的多态不需要加任何关键字，直接子类复写父类的方法就可以实现多态，没有关键字virtual.

class Animal { 
    public void eat() {
        System.out.println("吃饭");
    }
}

class Cat extends Animal {
    public void eat() {
        System.out.println("吃鱼");
    }

    public void catchMouse() {
        System.out.println("抓老鼠");
    }
}

Abstact关键字

abstact修饰的是抽象类或者抽象方法，如果一个类中有抽象方法那么一定是抽象类，但是抽象类不一定有抽象方法。抽象类不能    
被实例化就和c++中有virtual void func()=0的类是一个效果。

abstract class Employee { 
    private String name;
    private String id;
    private double pay;

    public Employee(){}

    public Employee(String name,String id,double pay) {
        this.name = name;
        this.id = id;
        this.pay = pay;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setId(String id) {
        this.id = id;
    }

    public void setPay(double pay) {
        this.pay = pay;
    }

    public String getName() {
        return name;
    }

    public String getId() {
        return id;
    }

    public double getPay() {
        return pay;
    }

    public abstract void work();
}

接口Interface

• 接口内容
  接口就是c++中的纯虚类，接口中的成员变量都必须是静态并且是public final修饰的。接口中的函数都是纯虚函数。

• 接口可以继承接口

interface DemoF extends DemoA,DemoB{        //接口和接口直接是继承关系,既可以单继承也可以多继承

}

• 一个类可以实现多个接口

class Dog implements Jump,Eat {}

• 一个类可以继承一个类实现多个接口

class Dog extends Animal implements Jump {
    public Dog(){}

    public Dog(String name,int age) {
        super(name,age);
    }

    public void eat() {
        System.out.println("吃肉");
    }

    public void sleep() {
        System.out.println("趴着睡");
    }

    public void jump() {
        System.out.println("跳高");
    }
}

包

• 包的定义

  package必须放在代码的第一行

package com.heima;
public class Person {
    private String name;
    private int age;

    public Person() {}

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    protected void speak() {
        System.out.println(name+","+age);
    }
}

• 包的编译
  使用-d选项选择包的编译路径，然后就会在指定路径下面生成相应的包文件夹。

javac -d . helloworld.java
java 包.helloworld

• 包的使用

  导入包就和c++中的include是一样的，并且导出的类必须要使用public修饰。

package com.baidu;
import com.heima.Person;
public class Student extends Person {
    public Student(){}

    public Student(String name,int age) {
        super(name,age);
    }

    public void print() {
        speak();
    }
}

内部类

• 一般内部类的使用

  注意这里有一般内部类和静态内部类

class Demo2 {
    public static void main(String[] args) {
        Outer.Inner2 oi = new Outer.Inner2();
        Outer.Inner oi = new Outer.new Inner();
    }
}

class Outer {
    class Inner {
        public void print() {
            System.out.println("Hello World!");
        }
    }

    static class Inner2 {
        public static void method() {
            System.out.println("Hello World!");
        }
    }

    public void run() {
        int num = 10;
        class Inner3 {
            public void print() {
                System.out.println(num);
            }
        }
    }
}

• 匿名内部类
  匿名内部类在new的时候就实现了方法，一般都是实现某个接口。

class Demo4InnerClass {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

interface Inter {
    public void print();
}

class Outer {
    public void method() {
        new Inter(){
            public void print() {
                System.out.println("print");
            }
        }.print();
    }
}