复习1

一、Java面向对象
Java的类由两部分组成：1，静态的属性，2、动态的方法
访问权限：public private protected
构造方法：作用是实例化 、new的时候调用
普通方法：（有参、无参、访问权限、返回值类型）
一、访问权限

package com.example.demo.studyone;

import javax.servlet.http.Cookie;

/**
 * 参数
 * 静态的属性
 * public private  protected 访问权限
 * 访问权限不写默认是protected
 * 1.public，接口访问权限。
 * 使用public，意味着public之后的成员声明对每个人都是有用的。
 * 2.private，别人无法访问的权限
 * 即便是处于同一个包内的其他类也是不可以访问private成员的，通俗说就是自己隔离了自己。
 * 3.protected：继承访问权限
 * protected处理的是继承的概念。只有继承他的类才可以访问他的方法。
 * 我们可以把一个文件夹当作一个社区，把每一个类当作每一个人。被public修饰的人是这个社区的民警，当有人遇到困难时，都可以向他寻求帮助；
 * 被protect修饰的人可以看作是一个家庭的父亲，只有他的儿子（后代）遇到困难时，他才可以伸出援手；
 * 被private修饰的人就是这个社区最自私的人，不管谁都不可以从他那得到任何东西。
 */
public class parameter {
    public parameter(){
        System.out.println("-----public-----");
    }
    void bite(){
        System.out.println("----默认protected-----");
    }
    protected void bite1(){
        System.out.println("------protected------");
    }
    public void bite2(){
        System.out.println("--------public2------");
    }
}

package com.example.demo.studyone;

public class Testone {
    public static void main(String[] args) {

        parameter p = new parameter();
        p.bite();
        p.bite1();
        p.bite2();
        /**
         * -----public-----
         * ----默认protected-----
         * ------protected------
         * --------public2------
         */
    }
}

package com.example.demo.studyone;

public class parameter2 {
    public parameter2(){
        System.out.println("===public====");
    }
    protected void bite(){
        System.out.println("====protected=====");
    }
}

package com.example.demo.studyone;

public class Testtwo extends parameter2{
   public Testtwo(){
       System.out.println("---Testtwo----");
   }
   public void sc(){
       bite();
   }

    public static void main(String[] args) {
        Testtwo t = new Testtwo();
        t.sc();
    }
}

二、参数（有参、无参、普通方法）

package com.example.demo.studyone;

//类中属性和方法的声明，和对方法的调用

/**
 * 类的构造方法：
 * (1)构造方法的名字和类名相同，并且没有返回值。
 *（2）构造方法主要用于为类的对象定义初始化状态。
 *（3）不能直接调用构造方法，必修通过new关键字来自动调用，从而创建类的实例。
 *  
 * new关键字的作用：
 *（1）为对象分配内存空间。
 *（2）引起对象构造方法的调用
 *（3）为对象返回一个引用
 */
class parameter3 {
    int x;      //属性
    int y;
    void output(){    //方法
       System.out.println(x);
       System.out.println(y);
    }
}
class Test{
    public static void main(String[] args) {
        parameter3 p = new parameter3();
        p.x = 10;
        p.y = 10;
        p.output();       //方法调用
        /**
         * 10
         * 10
         */
    }
}

//无参构造方法：
class parameter4{
    int x;
    int y;
    parameter4(){     //无参数构造方法，方法名与类名相同
        x = 15;
        y = 15;
    }
    void output(){
        System.out.println(x);
        System.out.println(y);
    }
}
class Test2{
    public static void main(String[] args) {
        parameter4 p1 = new parameter4();
        p1.output();
        /**
         * 15
         * 15
         */
    }
}

//有参构造方法：
class parameter5{
    int x;
    int y;
    parameter5(int a,int b){
        x=a;
        y=b;
    }
    void output(){
        System.out.println(x);
        System.out.println(y);
    }
}
class Test3{
    public static void main(String[] args) {
        parameter5 p2 = new parameter5(9, 9);
        p2.output();
        /**
         * 9
         * 9
         */
    }
}

//缺省构造方法的用法
class parameter6{
    int x;
    int y;
    parameter6(){       //缺省构造方法，方法名与类名相同
    }
    void output(){
        System.out.println(x);
        System.out.println(y);
    }
}
class Test4{
    public static void main(String[] args) {
        parameter6 p3 = new parameter6();
        p3.output();
        /**
         * 0
         * 0
         */
    }
}