java01

//java和类
//java基本数据类型
//变量类型
//java修饰符
//java运算符
//java循环结构

package com.company;
import java.io.*;
//主要对类和接口分类
//import语句.用来给编译器提供一个合理路径，找到类


/*
源文件声明规则：
一个源文件中只能有一个public类，但是可以有多个非public类
源文件名称应该与public类名保持一致、
如果类定义在某一个包中。那package语句应该在源文件的首行
import语句和package语句对中所有定义的类都有效，在同一个源文件中不能给不同的类不同的包声明
*/

//枚举
class Juice{
    enum JuiceSize{ small,medium,big};
    JuiceSize
            size;
        }

//定义一个汽车类
class Car{
    private String name;//将类的属性私有化
    public  String  Getname(String name){//通过公共方法访问类
        System.out.println(name);
        return name;};
    private int age;
    public int Getage(int age){
        System.out.println(age);
        return age;};
}
//定义一个新类继承Car
class Laotoule extends Car{};

//方法重载
//在一个类中可以有多个同名方法，但参数不同
class AddTest{
    int Add(int a,int b){return a+b;};
    double Add(double a,double b){return a+b;};
}
//构造方法
//在创建实例时会调用类的构造方法，如果没有显性的为类定义构造方法，那编译器会为类提供一个默认的构造方法
class Puppy{
    //成员属性
    private int age;
    private String name;
    //构造方法、、获取姓名
     Puppy(String name){
         this.name=name;
      //   System.out.println(name);
    };
     //获取年龄
    void Setage(int age){
        this.age=age;
    };
    //返回姓名
    String Getname()
    {
       return name;
    }
    //返回年龄
    int Getage(){
       return age;
    };
    //输出姓名
    void Putname(String name)
    {
        System.out.println(name);
    }
    //输出年龄
    void Putage(int age){
        System.out.println(age);
    };
}

/*
变量就是申请空间来存储值，在创建变量时需要申请内存，根据申请的变量的数据类型来分配空间，分配的空间存储该数据类型
数据类型分为内置数据类型和引用数据类型

*/

class RunoobTest {
    // 成员变量
    private int instanceVar;
    // 静态变量
    private static int staticVar;

    public void method(int paramVar) {
        // 局部变量
        int localVar = 10;

        // 使用变量
        instanceVar = localVar;
        staticVar = paramVar;


        System.out.println("成员变量: " + instanceVar);//10
        System.out.println("静态变量: " + staticVar);//20
        System.out.println("参数变量: " + paramVar);//20
        System.out.println("局部变量: " + localVar);//10
    }

    public static void main(String[] args) {
        RunoobTest v = new RunoobTest();
        v.method(20);
        RunoobTest v1= new RunoobTest();
        v1.method(10);
        System.out.println(v1.staticVar);
    }
}
//局部变量试用前要初始化
class LocalVariablesExample {
    public static void main(String[] args) {
        int a = 10; // 局部变量a的声明和初始化
        int b;     // 局部变量b的声明
        b = 20;    // 局部变量b的初始化

        System.out.println("a = " + a);
        System.out.println("b = " + b);

        // 如果在使用之前不初始化局部变量，编译器会报错
        // int c;
        // System.out.println("c = " + c);
    }
}

//静态变量
//java中胡静态变量椒指在类中定义的一个变量，无论创建多少个类的实例，静态变量在内存中只有那一份拷贝，被所有实例共享
class MyClass {
    public static int count = 0;//通常用static关键字修饰
    // 其他成员变量和方法

    //访问静态变量通常通过类名、实例名来访问
    // MyClass.count = 10; // 通过类名访问
    // MyClass obj = new MyClass();
    // obj.count = 20; // 通过实例名访问
}
/*
静态变量和常量的区别：
常量是用final进行修饰的，一旦被赋值就不能被修改。静态变量在的值可以在运行时改变
常量通常来存储一些固定的值，而静态变量通常用于存储可以改变的数据
 */


/*
抽象类
抽象类不能用来实例化对象，声明抽象类的唯一方法是为了将来对该类进行扩充
抽象类不能同时被abstract和final修饰，如果一个类包含抽象方法，那么这个类一定要被定义成抽象类

抽象方法：
抽象方法是一种没有任何实现的方法，该方法的实现是由子类提供的
任何抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类
如果一个类包含抽象方法，那么该类一定是抽象类，但是抽象类不一定要吧包含抽象方法
抽象方法的声明以分号结尾
public abstract sample();
 */


/*
synchronized 修饰符
synchronized 修饰的方法统一时间内只能被一个线程访问，可以应用于四个访问修饰符
 */

/*
volatile 修饰符
volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。
而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。
这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
 */

/*

java运算符：
算数运算符
加减乘除自增自减取余
public class selfAddMinus{
    public static void main(String[] args){
        int a = 5;//定义一个变量；
        int b = 5;
        int x = 2*++a;
        int y = 2*b++;
        System.out.println("自增运算符前缀运算后a="+a+",x="+x);
        System.out.println("自增运算符后缀运算后b="+b+",y="+y);
    }
}
关系运算符
==   ！=   >  <  >=  <=
关系运算符结果为真假
public class Test {

  public static void main(String[] args) {
     int a = 10;
     int b = 20;
     System.out.println("a == b = " + (a == b) );
     System.out.println("a != b = " + (a != b) );
     System.out.println("a > b = " + (a > b) );
     System.out.println("a < b = " + (a < b) );
     System.out.println("b >= a = " + (b >= a) );
     System.out.println("b <= a = " + (b <= a) );
  }
}
位运算符
A = 0011 1100
B = 0000 1101
&    如果相对应位都是1，则结果为1，反之为0
A&B = 0000 1100
|    如果对应位结果都为0，则结果为0，反之为1
A | B = 0011 1101
^    如果对应位值相同，则结果为0.否则为1
A ^ B = 0011 0001
~    按位取反，翻转每一位，0变1,1变0
（〜A）得到-61，即1100 0011
<<   按位左移
	A << 2得到240，即 1111 0000
>>   按位右移
A >> 2得到15即 1111
>>>  按位右移补零
A>>>2得到15即0000 1111

逻辑运算符
&&   ||    ！
赋值运算符
其它运算符

 */

//while循环


//主方法
public class Main01{
    public static void main(String[] args) {
        // System.out.println("hello");
        Juice juice=new Juice();
        juice.size=Juice.JuiceSize.big;
        // write your code here
        Car car=new Car();//实例化一个汽车对象
        car.Getname("小红");
        car.Getage(12);
        //继承
        Laotoule mylao=new Laotoule();
        mylao.Getage(66);
        //构造方法
        Puppy mypuppy=new Puppy("loopy");
        mypuppy.Setage(2);
        //访问实例变量和成员方法
        System.out.println(mypuppy.Getage());
        System.out.println(mypuppy.Getname());
        int age=mypuppy.Getage();
        System.out.println(age);
        //while循环
        int a=10;
        while(a>1)
        {
            System.out.println(a);
            a--;

        }
        //do while 循环
        int b=10;
        do{
            System.out.println(b);
            b--;
        }while(b>1);
    }
        //for循环

}