Java：梦开始的地方

低  ------------------------------------>  高

byte,short,char—> int —> long—> float —> double 

public class ZiDongLeiZhuan{
		public static void main(String[] args){
    		char c1='a';//定义一个char类型
        int i1 = c1;//char自动类型转换为int
        System.out.println("char自动类型转换为int后的值等于"+i1);
        char c2 = 'A';//定义一个char类型
        int i2 = c2+1;//char 类型和 int 类型计算
        System.out.println("char类型和int计算后的值等于"+i2);
    }
}

/* 
运行结果
char自动类型转换为int后的值等于97
char类型和int计算后的值等于66
*/

public class QiangZhiZhuanHuan{
    public static void main(String[] args){
        int i1 = 123;
        byte b = (byte)i1;//强制类型转换为byte
        System.out.println("int强制类型转换为byte后的值等于"+b);
    }
}

/* 
运行结果
int强制类型转换为byte后的值等于123
*/

public class Variable{
    static int allClicks=0;    // 类变量
    String str="hello world";  // 实例变量
    public void method(){
        int i =0;  // 局部变量
    }
}

public class Test{ 
   public void pupAge(){
      int age = 0;
      age = age + 7;
      System.out.println("小狗的年龄是: " + age);
   }
   public static void main(String[] args){
      Test test = new Test();
      test.pupAge();
   }
}

/* 
运行结果
小狗的年龄是: 7
*/

import java.io.*;
public class Employee{
   // 这个实例变量对子类可见
   public String name;
   // 私有变量，仅在该类可见
   private double salary;
   //在构造器中对name赋值
   public Employee (String empName){
      name = empName;
   }
   //设定salary的值
   public void setSalary(double empSal){
      salary = empSal;
   }  
   // 打印信息
   public void printEmp(){
      System.out.println("名字 : " + name );
      System.out.println("薪水 : " + salary);
   }
 
   public static void main(String[] args){
      Employee empOne = new Employee("BOBO");
      empOne.setSalary(1000.0);
      empOne.printEmp();
   }
}

/* 
运行结果
$ javac Employee.java 
$ java Employee
名字 : BOBO
薪水 : 1000.0
*/

import java.io.*;
public class Employee {
    //salary是静态的私有变量
    private static double salary;
    // DEPARTMENT是一个常量
    public static final String DEPARTMENT = "开发人员";
    public static void main(String[] args){
    salary = 10000;
        System.out.println(DEPARTMENT+"平均工资:"+salary);
    }
}

/* 
运行结果
开发人员平均工资:10000.0
*/

typeName... parameterName

public class VarargsDemo {
    public static void main(String args[]) {
        // 调用可变参数的方法
        printMax(34, 3, 3, 2, 56.5);
        printMax(new double[]{1, 2, 3});
    }
    public static void printMax( double... numbers) {
        if (numbers.length == 0) {
            System.out.println("No argument passed");
            return;
        }
        double result = numbers[0];
        for (int i = 1; i <  numbers.length; i++){
            if (numbers[i] >  result) {
                result = numbers[i];
            }
        }
        System.out.println("The max value is " + result);
    }
}

/* 
运行结果
The max value is 56.5
The max value is 3.0
*/

// 一个简单的构造函数
class MyClass {
  int x;
 
  // 以下是构造函数
  MyClass() {
    x = 10;
  }
}

//静态变量的例子
private static int count;
public static String str;
public static final String DB_USER = "myuser"

//静态方法的例子
public static void setCount(int count) {
    if(count > 0)
    StaticExample.count = count;
}

//静态工具方法
public static int addInts(int i, int...js){
    int sum=i;
    for(int x : js) sum+=x;
    return sum;
}

static{
    //在类被加载的时候用于初始化资源
    System.out.println("StaticExample static block");
    //仅能访问静态变量和静态方法
    str="Test";
    setCount(2);
}

import static java.lang.Math.random;

// 首选的方法
dataType[] arrayRefVar;  
//或
// 效果相同，但不是首选方法 
// 来自 C/C++ 语言 
dataType arrayRefVar[];  

//直接为每一维分配空间
//type 可以为基本数据类型和复合数据类型，typeLength1 和 typeLength2 必须为正整数，typeLength1 为行数，typeLength2 为列数
type[][] typeName = new type[typeLength1][typeLength2];
//或
//为最高维分配引用空间
//再为其每个数组元素单独分配空间
String[][] s = new String[2][];
s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String("Good");
s[0][1] = new String("Luck");
s[1][0] = new String("to");
s[1][1] = new String("you");
s[1][2] = new String("!");

public int[][] sparseMatrix(int[][] array){
  int sum = 0;
  for(int i = 0;i < array.length; i++){
    for(int j = 0; j < array[i].length){
      if(array[i][j] != 0)
        sum++;
    }
  }
  System.out.println("有效值的个数：" + sum);
  
  //创建一个稀疏数组
  int[][] sparse = new int[sum + 1][3];
  sparse[0][0] = array.length;
  sparse[0][1] = array[0].length;
  sparse[0][2] = sum;
  
  //遍历二维数组，将非零的值，存放数组中
  int count = 0;
  for(int i = 0 ; i < array.length ; i++){
    for(int j = 0 ; j < array[0].length ; j++){
      if(array[i][j] != 0){
        count++;
        sparse[count][0] = i;
        sparse[count][1] = j;
        sparse[count][2] = array[i][j];
      }
    }
  }
  return sparse;
}

Scanner s = new Scanner(System.in);

import java.util.Scanner; 
 
public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        // 从键盘接收数据
 
        // next方式接收字符串
        System.out.println("next方式接收：");
        // 判断是否还有输入
        if (scan.hasNext()) {
            String str1 = scan.next();
            System.out.println("输入的数据为：" + str1);
        }
        scan.close();
    }
}

/* 
运行结果
$ javac ScannerDemo.java
$ java ScannerDemo
next方式接收：
bobo com
输入的数据为：bobo
*/

import java.util.Scanner;
 
public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        // 从键盘接收数据
 
        // nextLine方式接收字符串
        System.out.println("nextLine方式接收：");
        // 判断是否还有输入
        if (scan.hasNextLine()) {
            String str2 = scan.nextLine();
            System.out.println("输入的数据为：" + str2);
        }
        scan.close();
    }
}

/* 
运行结果
$ javac ScannerDemo.java
$ java ScannerDemo
nextLine方式接收：
bobo com
输入的数据为：bobo com
*/

class Circle {
    double radius = 0;
    public Circle(double radius) {
        this.radius = radius;
    }
    class Draw {     //内部类
        public void drawSahpe() {
            System.out.println("drawshape");
        }
    }
}

外部类.this.成员变量
外部类.this.成员方法

class Circle {
    private double radius = 0;
    public Circle(double radius) {
        this.radius = radius;
        getDrawInstance().drawSahpe();   //必须先创建成员内部类的对象，再进行访问
    }
    private Draw getDrawInstance() {   //创建成员内部类的对象
        return new Draw();
    }
    class Draw {     //内部类
        public void drawSahpe() {
            System.out.println(radius);  //外部类的private成员
        }
    }
}

public class Test {
    public static void main(String[] args)  {
        //第一种方式：
        Outter outter = new Outter();
        Outter.Inner inner = outter.new Inner();  //必须通过Outter对象来创建
         
        //第二种方式：
        Outter.Inner inner1 = outter.getInnerInstance();
    }
}
class Outter {
    private Inner inner = null;
    public Outter() {
         
    }
    public Inner getInnerInstance() {
        if(inner == null)
            inner = new Inner();
        return inner;
    }
    class Inner {
        public Inner() {    
        }
    }
}

class People{
    public People() {
    }
}
class Man{
    public Man(){    
    }   
    public People getWoman(){
        class Woman extends People{   //局部内部类
            int age =0;
        }
        return new Woman();
    }
}

new OnClickListener() {
    @Override
    public void onClick(View v) {
        // TODO Auto-generated method stub
    }
}

scan_bt.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View v) {
        // TODO Auto-generated method stub
    }
});
 
history_bt.setOnClickListener(new OnClickListener() {
     
    @Override
    public void onClick(View v) {
        // TODO Auto-generated method stub
    }
});

public class Test {
    public static void main(String[] args)  {
        Outter.Inner inner = new Outter.Inner();
    }
}
class Outter {
    public Outter() {
         
    }
    static class Inner {
        public Inner() {
             
        }
    }
}

/**
 * 外部类，不能声明为 static
 */
public class OuterClass {
    private int ab = 1;
    private static int sab = 2;
    /**
     * 普通内部类
     */
    public class NormalInnerClass {
        // private static int age = 22;
        private int age = 22; // 不能声明为static
        public NormalInnerClass() {
            // 可以访问外部类静态与非静态成员
            System.out.println(ab);
            System.out.println(sab);
        }
    }
    /**
     * 静态内部类
     */
    public static class StaticInnerClass {
        // 定义静态与非静态成员都是可以的
        private static int age = 22;
        private int age2 = 22;
        private void echo() {
            // System.out.println(ab);
            System.out.println(sab);// 只能访问外部类的静态成员
        }
    }
} 

public class Test{
    public static void main(String[] args){
           // 初始化Bean1
           (1)
           bean1.I++;
           // 初始化Bean2
           (2)
           bean2.J++;
           //初始化Bean3
           (3)
           bean3.k++;
    }
    class Bean1{
           public int I = 0;
    }
 
    static class Bean2{
           public int J = 0;
    }
}
 
class Bean{
    class Bean3{
           public int k = 0;
    }
}

Test test = new Test();    
Test.Bean1 bean1 = test.new Bean1();
---------------------------------------
Test.Bean2 b2 = new Test.Bean2();
Bean bean = new Bean();     
---------------------------------------
Bean.Bean3 bean3 =  bean.new Bean3();

public class Test {
    public static void main(String[] args)  {
        Outter outter = new Outter();
        outter.new Inner().print();
    }
}
 
 
class Outter
{
    private int a = 1;
    class Inner {
        private int a = 2;
        public void print() {
            int a = 3;
            System.out.println("局部变量：" + a);
            System.out.println("内部类变量：" + this.a);
            System.out.println("外部类变量：" + Outter.this.a);
        }
    }
}

/*
局部变量：3
内部类变量：2
外部类变量：1
*/

class WithInner {
    class Inner{
         
    }
}
class InheritInner extends WithInner.Inner {
      
    // InheritInner() 是不能通过编译的，一定要加上形参
    InheritInner(WithInner wi) {
        wi.super(); //必须有这句调用
    }
  
    public static void main(String[] args) {
        WithInner wi = new WithInner();
        InheritInner obj = new InheritInner(wi);
    }
}

interface 接口名称 [extends 其他的接口名] {
  // 声明变量
  // 抽象方法
}

...implements 接口名称[, 其他接口名称, 其他接口名称..., ...] ...

package java.util;
public interface EventListener
{}

public class Demo {
    public static void main(String[] args) {
        int b =20;
        change(b);// 实参 实际上的参数
        System.out.println(b);
    }
    public static void change(int a){//形参 形式上的参数
        a=100;
    }
}

public class Demo {
    public static void main(String[] args) {
        int [] a={1,2,3};
        System.out.println(a[0]);
        change(a);
        System.out.println(a[0]);
    }
   //实参和形参在内存上指向了同一块区域
    public static void change(int[] a ){
        a[0]=100;  //形参的修改会影响实参
    }
}

//类的继承格式
class 父类 {
}
class 子类 extends 父类 {
}

class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}
 
class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // super 调用父类方法
  }
}
 
public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.eat();
    Dog d = new Dog();
    d.eatTest();
  }
}

/*
输出结果为：
animal : eat
dog : eat
animal : eat
*/

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

public class Employee {
   private String name;
   private String address;
   private int number;
   public Employee(String name, String address, int number) {
      System.out.println("Employee 构造函数");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   public void mailCheck() {
      System.out.println("邮寄支票给： " + this.name
       + " " + this.address);
   }
   public String toString() {
      return name + " " + address + " " + number;
   }
   public String getName() {
      return name;
   }
   public String getAddress() {
      return address;
   }
   public void setAddress(String newAddress) {
      address = newAddress;
   }
   public int getNumber() {
     return number;
   }
}
-------------------------------------------------------------
public class Salary extends Employee
{
   private double salary; // 全年工资
   public Salary(String name, String address, int number, double salary) {
       super(name, address, number);
       setSalary(salary);
   }
   public void mailCheck() {
       System.out.println("Salary 类的 mailCheck 方法 ");
       System.out.println("邮寄支票给：" + getName()
       + " ，工资为：" + salary);
   }
   public double getSalary() {
       return salary;
   }
   public void setSalary(double newSalary) {
       if(newSalary >= 0.0) {
          salary = newSalary;
       }
   }
   public double computePay() {
      System.out.println("计算工资，付给：" + getName());
      return salary/52;
   }
}
-------------------------------------------------------------
public class VirtualDemo {
   public static void main(String [] args) {
      Salary s = new Salary("员工 A", "北京", 3, 3600.00);
      Employee e = new Salary("员工 B", "上海", 2, 2400.00);
      System.out.println("使用 Salary 的引用调用 mailCheck -- ");
      s.mailCheck();
      System.out.println("\n使用 Employee 的引用调用 mailCheck--");
      e.mailCheck();
    }
}
-------------------------------------------------------------
/*
Employee 构造函数
Employee 构造函数
使用 Salary 的引用调用 mailCheck -- 
Salary 类的 mailCheck 方法 
邮寄支票给：员工 A ，工资为：3600.0

使用 Employee 的引用调用 mailCheck--
Salary 类的 mailCheck 方法 
邮寄支票给：员工 B ，工资为：2400.0
*/

public class ZiDongLeiZhuan{
		public static void main(String[] args){
    		int a = 10;
      	int b = 20;
      	System.out.println("" + a + b);
      	System.out.println(a + b + "");
    }
}
/* 
运行结果
1020
30
*/

//主启动类
public class Application{
  public static void main(String[] args){
    //调用静态方法时 方法的调用只和  左边  定义的数据类型有关
    A a = new A();
    a.test();
    //父类的引用指向了子类
    B b = new A();  //子类重写了父类的方法  只和非静态方法有关
    b.test()
  }
}  

---非静态方法---
//父类
public class B{
  public void test(){
    System.out.println("B=>test()");
  }
}
//子类
public class A extends B{
  public void test(){
    System.out.println("A=>test()");
  }
}
/*
A=>test()
A=>test()
*/
---静态方法---
//父类
public class B{
  public static void test(){
    System.out.println("B=>test()");
  }
}
//子类
public class A extends B{
  public static  void test(){
    System.out.println("A=>test()");
  }
}
/*
A=>test()
B=>test()
*/