【无标题】

public class Helloword{
     public static void mian(String[] args){
    System.out.println('hello world');
  }
}

或者运算符：||
注释：

1. 单行注释： //
2. 多行注释：/* */

变量：
a. 声明变量，数据类型：变量名
变量类型：
a. 类变量：独立于方法之外的变量，用static修饰，
b. 实例变量：独立于方法之外的变量，不过没有static修饰，跟随对象实例化，实例变量随之确定。
c. 局部变量：类方法中的变量，声明在方法、构造方法或者语句块中，执行完成后，变量将会被销毁。访问修饰符不能用于局部变量

public class Variable{
      static int allClick=0; // 类变量
    String str ='hello world'; // 实例变量
      pubilc void method(){
      int i=0;       // 局部变量
    }
}
package com.runoob.test;
// 实例1 ： 局部变量
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();
  }
}

import java.io.*;

// 实例2: 实例变量
public class Employee{
  public String name;   // 对子类可见的实例变量
  private double salary;  // 私有变量，仅在该类中可见
  
  // 在构造器中对name赋值
  public Emploee( 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('runoob');
    empOne.setSalary(1000.0);
    empOne.printEmp();
  }
  
}


import java.io.*;

public class Employee{
  private static double salary;  //静态私有变量
  
  public static final String DEPARTMENT ='开发人员';
  
  public static void main(String[] args){
    salary=10000;
    System.out.println(DDEPARTMENT +'平均工资：'+salary)
  }
  
}

常量
在java中使用final关键字来修饰常量，声明方式和常量类似：（为了区分，常用大写字母来表示）
final double PI =3.1415926

强制类型转换：
格式： (type) value : type是要强制类型转换后的数据类型
修饰符
修饰符用来定义类、方法、变量，通常放在语句的最前端

1. 访问修饰符：
   a. default：
   b. pubilc : 使用对象，类、接口、变量、方法
   c. priviate：变量和方法
   d. protected
2. 非访问修饰符：
   a. static：用来修饰类方法和类变量
   i. 静态变量（类变量）：用于声明独立于对象的静态变量，无论一个类实例化了多少对象，它的静态变量只有一份拷贝。
   ii. 静态方法：独立于对象的静态方法，不能使用类的非静态变量。静态方法从参数列表中得到数据，然后计算这些数据。
   b. final
   c. abstract

运算符
字符串+操作，就是字符串的拼接操作。

1. 算数运算符：
   a. 自增： ++
   b. 自减：–
2. 条件运算符 (?😃
   条件运算符也为三元运算符，该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符主要是决定哪个值应该赋值给变量。

variable  x = (expression)? value1 if true : value2 if false
public class Test{
  public static void main(String[] args){
    int a,b;
    a= 10;
    b= (a==1)?20:30;  //如果a等于1成立，则设置b为20，否则为30
    System.out.println('Value of b is :' +b);
    
  }
}

3. instanceof 运算符：
   该运算符用于操作对象实例，检查该对象是否是一个特定类型

String name = 'James';
// 由于name是String类型，所以返回真
boolean result = name instanceof String; 

数据输入
// 导包

import java.util.Scanner;

//创建对象

Scanner sc = new Scanner(System.in);

// 接受数据

int i = sc.nextInt();

顺序语句

1. if语句：

public class Test{
  public static void main(String args[]){
    int x=30;
    
    if(x==10){
      System.out.print('Value of x is 10');
    }else if(x==20){
      System.out.print('Value of x is 20');
    }else if(x==30){
      System.out.print('Value of x is 30');
    }else{
      System.out.print('这是else 语句');
    }
  }

}

2. switch case 语句
   switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

public calss Test{
  public static void main(String[] args){
    char grade ='C';
    switch(grade){
      case "A":
        System.out.println('优秀');
        break;
      case 'B' or "C":
        System.out.println('良好');
        break;
      case "D":
        System.out.println('及格');
      defalult:
        System.out.println('未知等级');

    }
    System.out.println('你的等级是'+ grade);
  }
}

3. 循环语句
   // 1.while 循环

public class Test{
  public static void main(String[] args){
    int x= 10;
    while (x<20){
      System.out.print('value of x :'+x);
      x++;
      System.out.print('\n');
    }
  }
}
// 2. for 循环
public class Test{
  public static void mian(String[] args){
    for(int x=10;x<20;x=x+1){
      System.out.print('value of x: '+x+'\n');
    }
  }
}

// 用于数组的for循环

public class Test{
  public static void main(String[] args){
    int [] numbers={10,20,30,40,50};
    for (int x:numbers){
      System.out.println(x);
      System.out.print(',');
    }
    
    String.out.print('\n');
    String [] names={'james','larry','Tom','lucy'};
    for (String name: names){
      System.out.print(name);
      System.out.print(',');
    }
    
    for (int x:numbers){
      if(x==30){
        break; // continue
      }
      System.out.print(x);
      System.out.print('\n');
    }
  }
}

6. Random

import java.util.Random

Random r = new Random();   //创建对象

int number = r.nextInt(10)  // 获取随机数的范围[0,10)

7. 数组
8. 声明数组变量： dataType [] Var_name
   例如：double [] myLIst;
9. 创建数组 ：java使用new操作符来创建数组

 arrayVar = new dataTye [arraySize]

数组变量的声明，和创建数组可以用一条语句完成，如下所示：
// 动态初始化格式：数据类型[] 变量名 = new 数据类型[数组长度]
// 两个中括号：表示这是一个数组

dataType [] arrayVar = new dataType[arraySize]; // new 关键字：为数组申请内存空间
也可以通过一下方式创建数组：(数组的元素通过索引来访问)

//静态初始化方式：

dataType [] arrayVar = new int[] {value0,value1,.....,valueN};  //方法1
dataType [] arrayVar = {value0,value1,.....,valueN};  //方法2

3. 处理数组

public class TestArray{
  public static void main(String[] args){
    double [] mylist ={1.9,2.0,3.4,3.5};
    
    // 打印数组
    for(int i =0;i<mylist.length;i++){
      System.out.println(mylist[i]+' ');
    }
    // 计算所有元素的和
    double total=0;
    for (int i=0;i<mylist.length;i++){
      total +=mylist[i];
    }
       System.out.println("Total is " + total);
    double max=mylist[0];
    for (i=1;i<mylist.length;i++){
      if (mylist[i]>max) max=mylist[i];
    }
    System.out.println("max is "+max);
  }
}
// 注：新的循环类型：for-each
public class TestArray{
  public static void main(String[] args){
    double [] mylist={1.9,2.9,3.4};
    for(double element:mylist){
      System.out.println(element)
    }
  }
}

4. 数组作为函数的参数和返回值

// 作为函数的参数
public static void printArray(int [] array){
  for(int i=0;i<array.lenth;i++){
    System.out.print(array[i]+' ');
  }
}

printArray(new int[]{1,4,3,6,7});

// 数组作为函数的返回值

public static int[] reverse(int[] list){
  int [] result =new int[list.length];
  for (int i =0; j=result.lenth-1;i<list.length;i++,j--){
    result[j]=list[i];
  }
  return result;
}

5. 多维数组

String [][] str = new String[3][4]; // 3行4例
// 多维数组的访问
str[1][1];

6. Arrays类
   java.util.Arrays类能方便地操作数组，它提供的所有方法都是静态的。具有一下功能
   a. 给数组赋值：通过fill方法
   b. 对数组排序：通过sort方法，按升序；
   c. 比较数组：通过equals方法比较数组中元素是否相等
   d. 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找操作。

7. 方法

8. 方法的定义(不能嵌套定义)
   修饰符 返回值类型 方法名(参数类型 参数名){
   ‘’’
   方法体
   ‘’’
   return 返回值;
   }

public static int max(int num1,int num2){
  return num1>num2 ?num1 num2;
}

2. 方法调用
   java支持两种调用方法，根据方法是否有返回值来选择。
   // 1. 当方法返回一个值的时候，方法调用通常被当作一个值，例如

int larger =max(30,40);

// 2. 如果方法返回值是void，方法调用一定是一条语句，例如，方法println返回void

System.out.println('hello word');

// 实例

public class TestMax{
  // 主方法
  public static void main(String[] args){
    int i=5;
    int j =2;
    int k = max(i,j);
    System.out.println(i+'和'+j+'比较，最大的值是'+k);
    
  }

// 返回两个变量的最大值

  public static int max(int num1,int2){
    int result;
    if (num1>num2)
      result=num1;
    else
      result =num2;
    return result;
  }
}

3. 方法的重载
   上面的max只适用于int类型，如果是double类型，解决的办法就是创建一个相同名字参数不同的方法

public static double max(double num1, double2){
  if(num1>num2)
    return num1;
  else
    return num2;
}

注：如果调用max方法时，传递的时int型参数，int参数的max就会被调用，如果是double类型，则double型max方法，这叫做方法的重载。就是一个类的两个方法拥有相同的名字，但是有不同的参数列表。
4. 命令行参数的使用
有时候需要运行一个程序时候再传递给它消息，这要靠传递命令行参数给main() 函数实现。
5. 构造方法
当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名称相同，但构造方法没有返回值。通常会使用构造方法给一个类的实例变量赋初值。
//一个简单的构造函数

class MyClass{
  int x;
  // 以下时构造函数
  MyClass(int i){
    x=i;
  }
}

// 初始化对象
public class consDemo{
  public static void mian(String[] args){
    MyClass t1= new MyClass(19);
    MyClass t2 = new MyClass(50);
    System.out.printLn(t1.x+" "+t2.x);
  }
}

6. 可变参数
   在方法声明中，在指定参数类型后加一个省略号（…）。一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。

public class VaragsDemo{
  public static void main(String[] args){
    printMax(34,3,4,3,56.5);
    printMax(nre 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);
  }
}

9. 类和对象
   同一个包中的公共类可以相互直接使用
   类的hi定义步骤：
   a. 定义类
   b. 编写类的成员变量：变量类型+变量名。
   c. 编写类的成员方法。
10. 构造方法
    构造方法的名称必须与类同名，一个类可以有多个构造方法。

public class Puppy{
  public Puppy(){
    
  }
  public Puppy(String name){
    //这个构造器仅有一个参数
  }
}

2. 创建对象
   格式：类名 对象名 = new 类名();
   创建对象是可以对成员变量赋值，例如 myPuppy.age= 10;
   使用关键字new来创建一个新的对象，创建一个对象包含三步：
   ● 声明：声明一个对象，包括对象名称和对象类型
   ● 实例化：使用关键字new来创建一个对象
   ● 初始化：使用new创建对象时，会调用构造方法初始化对象。

public class Puppy{
  int puppyAge;
  public Puppy(String name){
    //这个构造器仅有一个参数name
    System.out.println('小狗的名字是：'+name);
  }
  public void setAge(int age){
    puppyAge=age;
  }
  public int getAge(){
    System.out.println('小狗的年龄为：'+puppyAge);
    return puppyAge;
  }
  public static void main(String[] args){
    /*创建 对象*/
    Puppy myPuppy =new Puppy('dudu');
    myPuppy.setAge(2);
    System.out.println('小狗的年龄为：'+myPuppy.getAge);
  }
}

3. 源文件声明规则
   a. 一个源文件中只能有一个public类，可以有多个非public类
   b. 源文件的名称应该和public类的名保持一致
   c. 如果一个类定义在某个包中，那么package语句应该在源文件的首行

4. java包：只要用来对类和借口进行分类。
   Employee.java （定义类）
   import java.io.;
   public class Employee{
   String name;
   int age;
   String designation;
   double salary;
   // 显示构造器
   public Employee(String name){
   this.name=name;
   }
   // 设置age的值
   public void empAge(int empAge){
   age=empAge;
   }
   //设置designation的值
   public void empDesignation(String empDesig){
   designation =empDesig;
   }
   //设置salary的值
   public void empSalary(double empSalary){
   salary=empSalary;
   }
   // 打印信息
   public void printEmployee{
   System.out.println(‘员工名字：’+name);
   System.out.println(‘员工年龄：’+age);
   System.out.println(‘员工职位：’+designation);
   System.out.println(‘员工薪资：’+salary);
   }
   }
   EmployeeTest.java（定义员工测试类，在测试类中调用员工类的成员变量和方法）
   import java.io.;
   public class EmployeeTest{
   public static void main(String [] args){
   Employee empOne = new Employee(‘name01’);
   empOne.empAge(26);
   empOne.empDesignation(‘高级程序员’);
   empOne.empSalary(10000);
   empOne.printEmployee();

   Employee empTwo = new Employee(‘name02’);
   empTwo.empAge(28);
   empTwo.empDesignation(‘高级程序员’);
   empTwo.empSalary(12000);
   empTwo.printEmployee();

}
}
5. private 关键字：是一个权限修饰符，可以修饰成员变量和成员方法，作用是包括成员不被别的类使用，被private修饰的成员只能在本类中才能访问。
a. 如果需要被其他类使用，提供get变量名()和set变量名，并用public修饰
6. this关键字 this.变量名= 变量名。
a. 第一个变量名指的是成员变量， 第二个变量名指的是局部变量，这里的意思就是将局部变量的值复制给成员变量。
b. this修饰的变量用于指代成员变量
i. 方法的形参如果于成员变量同名，不带this修饰的变量值的是形参，而不是成员变量。
ii. 方法的形参没有与成员变量同名，不带this修饰的变量值的是成员变量
iii. 什么时候使用this？解决局部变量与成员变量同名。
7. 封装的原则：
a. 将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，提供对应的getXxx()/setXxx()方法。

8. 构造方法：
   a. 作用用于创建对象
   b. 功能：完成对象数据的初始化
   //格式
   public class 类名{
   修饰符 类名（参数）{ // 方法名和类名相同
   }
   }

9. 标准类的制作步骤：

10. 成员变量：
    使用private修饰

11. 构造方法：
    a. 提供一个无参构造方法
    b. 提供一个带多个参数的构造方法

12. 成员方法
    a. 提供每一个成员变量对应的getXxx()/setXxx()方法，使用public修饰
    b. 提供一个现实对象信息的show() 方法

13. 创建对象并为其成员变量赋值的两种方式
    a. 午餐构造方法创建对象使用setXxx
    b. 使用带参构造方法直接创建带属性的对象
    ctrl+alt+v 用于生成调用类方法返回值信息
    10 字符串String

14. 创建字符串：String s =“abc”

15. 字符串的长度：s.length() 数组长度：arrl.length

16. 连接字符串 string1.concat(string2)

17. 比较字符串：
    a. == ：比较两个字符串的地址是否相同
    b. 通过equal() 方法比较字符串的值是否相同s1.equals(s2)

18. StringBuilder
    是一个可变的字符串类，可以看成一个容器
    String：内容是不可变的，StringBuilder：内容是可变的。

19. 构造方法
    StringBuilder sb = new StringBuilder(); // 可以无参、有参初始化字符串

20. 添加方法：sb.append()

21. 反转字符串：sb.reverse()

22. StringBuilder和string的相互转换：toString() StringBuilder(String s)

23. 使用StringBuilder拼接字符串：s= sb.append(char).toString()

24. ArrayList
    提供一种储存空间可变的存储类型

25. ArrayList() 创建集合对象
    ArrayList array =new ArrayList();

26. array.add() 追加元素| array.add(1,“javase”)

27. 删除元素 remove

28. size返回元素个数

29. set 修改指定索引处的元素

30. 遍历集合元素：集合对象.get(i) // i为指定索引处的元素

31. 继承
    格式：public class 子类名 extends 父类名{}
    继承中变量的访问特点：
    在子类方法中访问一个变量：
    a. 子类局部范围中找
    b. 子类成员范围中找
    c. 父类成员范围找

32. 如果要访问类中的成员变量需要加this，如果要访问父类的成员变量需要使用super
    a. this：代表本类对象的引用
    b. super：代表负累储存空间的标识，可以理解为父类对象的引用。

33. 构造方法的访问特点
    a. 子类中所有的构造方法默认都会访问父类中的无参构造方法，子类继承一定会初始化父类构造方法

34. 方法重写（super，override关键字）
    子类中出现了和父类中一摸一样的方法声明，当子类需要父类的功能，而功能主体子类有足迹特有的内容时，可以重写父类的方法。
    // 当需要在子类中调用父类的被重写的方法时，需要用super关键字
    class Animal{
    public void move(){
    System.out.println(“动物可以移动”);
    }
    }

class Dog extends Animal{
@Override // 使用override关键字修饰表示下面的方法重写父类方法，，避免命名错误
// 帮助我们检查重写方法的方法声明的重要性
public void move(){
super.move(); // 使用super类的方法
System.out.println(“狗可以跑和走”);
}
}

public class TestDog{
public static void main(String[] args){
Animal b= new Dog();
b.move();
}
}
子类方法的访问权限不能更低（public>默认> 私有）

java类只支持单继承，不支持多继承，支持多层继承
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 void setName(String name){
this.name =name;
}

public int getAge(){
return age
}
public void setAge(int age){
this.age=age;
}
}

public class Teacher extends Person(){
// 无参构造方法
public Teacher(){

}
// 有参和无参构造方法均可自动生成
public Teacher(String name,int age){
super(name,age)
}
public void teach(){
System.out.println(“教学”)
}
}

public class TeacherDemo(){
public static void main(Strings [] args){
Teacher t1=new Teacher();
t1.setName(“么么桐”);
t1.setAge(24);
System.out.println(t1.getName+“,”+t1.getAge)
t1.teach;

// 有参初始化
Teacher t2 = new Teacher("zhuhongtao",29);

}
}

13. 包
    其实就是文件夹，对类进行分类管理，
    格式 package 包名;
    终端自动建包：javac -d.类名.java
14. 导包：import.包名.类名
    状态修饰符
    a. final 最终态：类不能继承，方法不能重写，变量不能再次被赋值，也即是被final修饰的变量是一种常量。
    b. static静态：定义变量，表示可以被所有对象共享的，只需要赋值一次即可
    public class Student{
    public String name;
    public int age;
    public static String school; //被所有类的对像共享
    }

public class StudentDemo{
public static void main(Strings[] args ){
Student.school=“jiaoda”; // 推荐使用类名调用赋值
Student s1=new Student();
s1.name=“tongtong”;
s1.age=24;
}
}
静态的成员方法：
a. 能访问静态的成员变量和成员方法

13. 多态
    同一个对像，再不同时刻变现出来的不同形态。
    多态的提前和体现：
    a. 有继承/实现关系
    b. 有方法重写
    c. 有父类引用指向子类对象 Animal a =new Cat();
14. 多态中成员访问特点：
    a. 成员变量：编译看左边，执行看左边，也就是父类中的变量
    b. 成员方法：编译看左边。执行看右边-------> 因为成员方法有重写

14 抽象类
在java中，一个没有方法体的方法应该被定义为抽象方法，而如果类中有抽象方法，该类必须定义为抽象类。
public abstract class Animal{
public abstract void eat(); //不同类的动物吃的东西应该不一样，所以定义为抽象方法
public void sleep(){
System.out.println(“睡觉”);
}
}

public class Cat extends Animal{
@override
public void eat(){
System.out.println(“猫吃鱼”);
}
}

public class AnimalDemo{
public static void main(Strings[] args){
Animal a = new Cat(); //抽象类通过多态的形式构建对象
a.eat(); //子类重写
a.sleep(); // 被子类继承
}
}

14 .接口
使用关键字：interface
类实实现接口用implements表示：public class 类名 implements 接口名{}
// 定义接口
public interface Jumpping{
public abstract void jump();
}

//定义抽象类
public abstract class Animal{
private String name;
private int age;
public Animal(){};
public Aninal(String name,int age){
this.name=name;
this.age=age;
}

public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
public String getAge(){
return age;
}
public void seAge(String age){
this.age=age;
}

// 定义抽象方法
public abstract void eat();
}

public class Cat extends Animal implements Jumping{
//生成构造方法
public Cat(){}
public Cat(String name,int age){
super(name,age);
}

// 重写eat方法
@override
public void eat(){
System.out.println(“猫吃鱼”);
}
// 重写接口的jump方法
@override
public void jump(){
System.out.println(“猫能跳9米高”);
}
}

public class AnimalDemo{
public static void main(Strings[] args){
Cat c =new Cat();
c.setName(“嘟嘟”);
c.setAge(2);
System.out.println(c.getAge()+“,”+c.getName());
c.eat();
c.junp();
}
}

接口可以多继承

类作为形参和返回值：其实需要的是该类的对象

内部类：格式
内部类可以直接访问外部类的成员，包括私有
外部类要访问内部类的成员，必须创建对象
public class Outer{
private int num =10;

public class Inner{
public void show(){
System.out.println(num);
}
}

public void method(){
Inner i= new Inner();
i.show();
}
}
15 常用API

1. Math