面向对象程序设计

// if-else
if (condition) {

} else if (condition) {

} else {

}

// switch-case
switct (var) {
  case 1:
  break;
  case 2:
  break;
  default:
}

// while
while (condition) {

}

// do-while
do {

} while (condition);

// for
for (int i = 0; i < 10; i++) {

}

// foreach
for (int i : array) {

}

// 数据类型[ ] 数组名;
int[] a;
// 数据类型[ ] 数组名 = new 数据类型[数组大小];
int[] a = new int[5];
// 数据类型[ ] 数组名 = {值 1,值 2, …值N} ；
int[] a = {1, 2, 3};

class Student {
  // 属性
  String name;
  int age;

  // 无参数构造方法
  Student(){
  }
  // 带参数构造方法，用于对属性赋值
  Student(String name, int age){
    this.name = name;
    this.age = age;
  }

  /**
  方法的命名规则:
  不能为 Java 中的关键字
  不能包含空格或点号“.”
  可以下划线“_”、字母或“$”符号开头
  实例方法可使用对象名加上圆点符号来访问
  对象名.方法名
  例如：obj.method();
  方法的参数既可以是基本数据类型（如 int n）,也可以是对象(如：Student stu)
  **/
  String getName () {
    return name;
  }

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

  int getAge() {
    return age;
  }

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


// 无参数实例化
Student student = new Student();

// 有参数实例化
Student student = new Student("张三", 12);

// 方法调用
student.setName("李四");
student.getName();

// 定义包
package 包名; // 该程序的第一语句

// 导入包
import 包名.类名; // import swing.*;

public class DisplayNumber {
  /** 无参数的显示方法 **/
  void display() {
    System.out.println("无参数可显示！");
  }

  /** 带参数的显示方法 **/
  void display(int num, int num1) {
    System.out.println("两个整数是:" + num + " " + num1);
  }

  public static void main(String [ ] arg) {
    int count = 25;
    DisplayNumber dispObj = new DisplayNumber();

    dispObj.display();
    dispObj.display(10 , 20);

    /* 不存在具有一个 int 型参数的方法，
    *int 型值自动转化为 double 型值
    */
    System.out.println(
    "调用 display(double) 方法，"
    + "使用 int 变量: " + count
    );

    dispObj.display(count);
    dispObj.display(25.5);
  }


  /** 带双精度参数的显示方法 **/
  void display(double count) {
    System.out.println("在 display(double)方法内:" + count);
  }
}

class Rectangle {
  int length;
  int width;
  //父类无参构造方法
  Rectangle(){

  }

  //父类带参数构造方法
  Rectangle(int len , int wid) {
    length = len;
    width = wid;
  }
  /* 计算矩形的周长. */
  void getPerimeter() {
    System.out.println("矩形的周长为" + (2 * (length + width)));
  }
}

class Square extends Rectangle {
  Square(int len) {
    length = len;
  }

  /* 方法重写，计算正方形周长. */
  void getPerimeter() {
    System.out.println("正方形的周长为" + (4 * length));
  }
}

class InchesToFeet{
  public static double convert(double in) {
    return (in / inches);
  }
}

class Test {
  public static void main(String [] arg) {
    /**初始化变量*/
    double inch = 66;
    double feet = InchesToFeet.convert(inches); // 调用静态方法
    System.out.println(inch + "英寸为" + feet + "英尺。");
  }
}

abstract class ClassName {

}

abstract class Shape {
  protected double length;
  protected double width;
  abstract double area();
}

class Square extends Shape {
  /** 构造方法 */
  Square(final double num, final double num1) {
    super(num, num1);
  }

  /**
  *** 父类的抽象方法在子类中被重写
  ***	计算正方形的面积
  **/
  double area() {
    System.out.println("正方形的面积为：");
    return length * width;
  }
}

// 定义方法的接口
public interface MyInterface {
  // 接口里的方法没有方法体，也不用abstract修饰，默认是public和abstract的
  void add(int x, int y);
  void volume(int x, int y, int z);
}

// 定义程序使用的常量的接口
public interface MyConstants {
  // 接口里的属性默认是static和final的
  double price = 1450.00;
  int counter = 5;
}

// 实现接口
class demo implements MyInterface {

}

class Test {
  public static void main(String[] args) {
    try {
      // 被监控的代码执行片段
      doSomething();

      // 由方法抛出异常
      throwException();

      // 抛出异常
      throw new Exception("手动抛出异常");

      // try-catch 异常可嵌套
      try {
        doSomething();
      } catch (Exception e) {

      }
    } catch (ArrayIndexOutOfBoundsException e) {
      // catch 可多个连用，且子类必须在父类前捕获
    } catch (Exception e) {
      // 以合理方式捕获和处理异常
    } finally {
      // 释放资源
    }
  }

  public static void throwException() throws Exception {
    // 由方法抛出异常
    // 若重写父类的方法时，throws 出的异常不能比父类抛出的异常大
  }
}

// 自定义异常类必须是Exception类的子类或Exception子类的子类
class CustomException extends Exception {
  /** 构造方法。 **/
  CustomException () {
    super("自定义异常");
  }
}

// 以当前系统时间获得一个Calendar日历对象:
Calendar c = Calendar.getInstance();

// GregorianCalendar：是 Calendar 的子类，实现 Gregorian 形式的日历
GregorianCalendar gc = new GregorianCalendar();

// 设置月份的起始日期为1
gc.set(Calendar.DAY_OF_MONTH, 1);

// 获取一周中的第几天
int weekday = gc.get(Calendar.DAY_OF_WEEK);

Random random = new Random();

// 返回下一个随机整数，有2^32个可能。
random.nextInt();

// 返回一个在 [0, n) 区间的随机整数
random.nextInt(n);

// 返回一个随机双精度浮点数
random.nextDouble();

HashMap map = new HashMap();
map.put("name", null);

ArrayList<String> collection = new ArrayList<String>();
Iterator it = collection.iterator();

while(it.hasNext()) {
  String string = it.next();
  System.out.println(string);
}

class Student implements Comparable {
  String name;

  // 重写比较方法
  public int compareTo(Object obj) {
    // 按姓名升序排列;
    Student s = (Student) obj;
    return this.name.compareTo(s.name);
  }
}

//实现Comparator接口，比较学生的姓名
class NameComparator implements Comparator{
  //重写Comparator接口中的compare方法
  public int compare(Object o1, Object o2){
    Student s1 = (Student) o1;
    Student s2 = (Student) o2;
    return s1.name.compareTo(s2.name);
  }
}

class Test {
  public static void main (String[] args) {
    ArrayList<Student> students = new ArrayList<Student>();

    students.add(new Student("张三"));
    students.add(new Student("李四"));

    NameComparator nameComparator = new NameComparator();
    // 排序
    Collections.sort(students, nameComparator);
  }
}

public class GenericList <T> {
  private T item;
  // 泛型方法，只有在调用参数时才确定参书类型。。
  public <T> setItem(T obj) {

  }

  /* 若有返回值类型，则 <T> 需放在返回值类型前面
    public <T> T setItem(T obj) {
    return true;
  }
  */

  // 返回 T 类型的值
  public T getItem(){

  }
}

// 参数 T 是一个类型形参，在使用该泛型类时才指定具体类型参数。
GenericList<String> list = new GenericList<String>(); // 此时 T 为 String 类型。

// 表示该泛型类只可以传递Number类型或其子类
public class Point<T extends Number>{

}

class Person{

}
class Student extends Person{

}
public class GenericDemo {
  public static void main (String[] args) {
    //编译报错:不兼容的类型
    Vector<Person> v=new Vector<Student>();
  }
}

// 表示该方法只可以接受Number类型或其子类的对象的泛型参数
public void show(Vector<? extends Number> v){

}

public void show(Vector<? super Number> v){
}

import java.io.File;

class Test {
  public static void main(String[] args) {
    File file = new File(args[0]);
    System.out.println("文件或目录是否存在:" +  file.exists());
    System.out.println("是文件吗:" +  file.isFile());
    System.out.println("是目录吗:" +  file.isDirectory());
    System.out.println("名称:" +  file .getName());
    System.out.println("路径: " + file.getPath());
    System.out.println("绝对路径: " + file.getAbsolutePath());
    System.out.println("最后修改时间:" + file.lastModified());    
    System.out.println(“文件大小:” + file.length() + “ 字节”);
  }
}

class Test {
  public static void main (String[] args) {
    // 使用 FileInputStream 读取文件
    try{
      int size;
      // 创建文件输入流
      InputStream fis = new FileInputStream("text.txt");

      // 获取文件大小
      System.out.println("可读取的字节数: " +
      (size = fis.available()));

      char[] text = new char[200];

      for (int count = 0; count < size; count++) {
        // read() 每次读取一个字符
        text[count] = ((char) fis.read());
        System.out.print(text[count]);
      }

      // 关闭流
      fis.close();
    }catch(IOException e){
      System.out.println (e.getMessage());
    }

    // 使用 FileOutputStream 写入文件
    try {                 
      String str ="好好学习Java";
      byte[] words  = str.getBytes();
      OutputStream fos = new FileOutputStream("Text.txt");

      // 将内容写入文件
      fos.write(words, 0, words.length);
      System.out.println("Text文件已更新!");

      // 关闭流
      fos.close();
    } catch (IOException e) {
      System.out.println("创建文件时出错!");
    }

    // 使用 BufferedReader 读取文件
    try {
      FileReader fr = new FileReader("mytest.txt");

      // 创建一个 BufferedReader 对象
      BufferedReader br = new BufferedReader(fr);

      // 读取一行数据.
      String line = br.readLine();

      // 读到文件尾
      while(line! = null){
        System.out.println(line);
        line = br.readLine();
      }

      // 流的关闭
      br.close();
      fr.close();
    } catch(Exception e) {

    }

    // 使用 BufferedWriter 读取文件
    try {
      // 创建一个FileWriter 对象
      FileWriter fw = new FileWriter("mytest.txt");

      // 创建一个BufferedWriter 对象
      BufferedWriter bw = new BufferedWriter(fw);
      bw.write("大家好！");
      bw.write("我正在学习BufferedWriter。");
      bw.newLine();
      bw.write("请多多指教！");
      bw.newLine();
      bw.write("email: [email protected]");
      bw.flush();
      fw.close();
    } catch (Exception e) {

    }
  }
}

PrintWriter pw = new PrintWriter("demo.txt");
// 写字符串：
pw.println("将信息写入文件");
pw.write("将信息写到文件中\r\n");
// 根据ASCII码写字符
pw.write(65);
// 带格式输出:
pw.printf(“%f”,3.14159263423); //输出3.141593
pw.printf("%.2f",3.14159263423); //输出3.14

import java.sql.*;

class Test {
  public static void main(String[] args) {
    try {
      Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");

      // 连接数据库
      String url = "jdbc:sqlserver://127.0.0.1:1433;databaseName=DB";
      String dbUser = "sa";
      String dbPassword = "1234";
      Connection conn = DriverManager.getConnection(url, dbUser, dbPassword);

      Statement stmt = conn.createStatement();

      // executeQuery 只可执行查询语句
      ResultSet rs = stmt.executeQuery("select * from friends");

      while (rs.next()) {
        System.out.print(rs.getString(1) + "\t");
      }

      // excuteUpdate 用来执行 insert、update、delete 等语句。
      // 返回影响行数。
      String sql = "INSERT INTO Student (id, name, address) VALUES ('001', '朱八', '深圳')";
      int rowCount = stmt.executeUpdate(sql);

      rs.close();
      stmt.close();
      conn.close();
    } catch (Exception e) {
      System.out.println(e.getMessage());
    }
  }
}

class class Test {
  public static void main (String[] args) {
    try {
      Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");

      // 连接数据库
      String url = "jdbc:sqlserver://127.0.0.1:1433;databaseName=DB";
      String dbUser = "sa";
      String dbPassword = "1234";
      Connection conn = DriverManager.getConnection(url, dbUser, dbPassword);

      String sql = "INSERT INTO Student (id, name, address) VALUES (?, ?, ?)";
      PreparedStatement pstmt = conn.prepareStatement(sql);

      //对？参数进行赋值
      pstmt.setString(1, "001");
      pstmt.setString(2, "朱八");
      pstmt.setString(3, "深圳");

      //执行插入,返回受影响的行数
      int rowCount = pstmt.executeUpdate();

      pstmt.close();
      conn.close();
    } catch (Exception e) {
      System.out.println(e.getMessage());
    }

  }
}

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import java.awt.*;

public class BorderLayoutDemo
{
  public static void main(String[] agrs)
  {
    JFrame frame=new JFrame("BorderLayout Demo");    //创建Frame窗口
    frame.setSize(400,200);
    frame.setLayout(new BorderLayout());    //为Frame窗口设置布局为BorderLayout
    JButton button1=new JButton ("上");
    JButton button2=new JButton("左");
    JButton button3=new JButton("中");
    JButton button4=new JButton("右");
    JButton button5=new JButton("下");
    frame.add(button1,BorderLayout.NORTH);
    frame.add(button2,BorderLayout.WEST);
    frame.add(button3,BorderLayout.CENTER);
    frame.add(button4,BorderLayout.EAST);
    frame.add(button5,BorderLayout.SOUTH);
    frame.setBounds(300,200,600,300);
    frame.setVisible(true);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
}

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import java.awt.*;
public class FlowLayoutDemo
{
  public static void main(String[] agrs)
  {
    JFrame jFrame=new JFrame("FlowLayout Demo");    //创建Frame窗口
    JPanel jPanel=new JPanel();    //创建面板
    JButton btn1=new JButton("1");    //创建按钮
    JButton btn2=new JButton("2");
    JButton btn3=new JButton("3");
    JButton btn4=new JButton("4");
    JButton btn5=new JButton("5");
    JButton btn6=new JButton("6");
    JButton btn7=new JButton("7");
    JButton btn8=new JButton("8");
    JButton btn9=new JButton("9");
    jPanel.add(btn1);    //面板中添加按钮
    jPanel.add(btn2);
    jPanel.add(btn3);
    jPanel.add(btn4);
    jPanel.add(btn5);
    jPanel.add(btn6);
    jPanel.add(btn7);
    jPanel.add(btn8);
    jPanel.add(btn9);
    //向JPanel添加FlowLayout布局管理器，将组件间的横向和纵向间隙都设置为20像素
    jPanel.setLayout(new FlowLayout(FlowLayout.LEADING,20,20));
    jPanel.setBackground(Color.gray);    //设置背景色
    jFrame.add(jPanel);    //添加面板到容器
    jFrame.setBounds(300,200,300,150);    //设置容器的大小
    jFrame.setVisible(true);
    jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
}

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import java.awt.*;

public class GridLayoutDemo
{
  public static void main(String[] args)
  {
    JFrame frame=new JFrame("GridLayout Demo");
    JPanel panel=new JPanel();    //创建面板
    //指定面板的布局为GridLayout，4行4列，间隙为5
    panel.setLayout(new GridLayout(4,4,5,5));
    panel.add(new JButton("7"));    //添加按钮
    panel.add(new JButton("8"));
    panel.add(new JButton("9"));
    panel.add(new JButton("/"));
    panel.add(new JButton("4"));
    panel.add(new JButton("5"));
    panel.add(new JButton("6"));
    panel.add(new JButton("*"));
    panel.add(new JButton("1"));
    panel.add(new JButton("2"));
    panel.add(new JButton("3"));
    panel.add(new JButton("-"));
    panel.add(new JButton("0"));
    panel.add(new JButton("."));
    panel.add(new JButton("="));
    panel.add(new JButton("+"));
    frame.add(panel);    //添加面板到容器
    frame.setBounds(300,200,200,150);
    frame.setVisible(true);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
}

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JPasswordField;
import javax.swing.JTextField;

public class SwingLoginExample {

  public static void main(String[] args) {    
    // 创建 JFrame 实例
    JFrame frame = new JFrame("Login Example");
    // Setting the width and height of frame
    frame.setSize(350, 200);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    /* 创建面板，这个类似于 HTML 的 div 标签
    * 我们可以创建多个面板并在 JFrame 中指定位置
    * 面板中我们可以添加文本字段，按钮及其他组件。
    */
    JPanel panel = new JPanel();    
    // 添加面板
    frame.add(panel);
    /*
    * 调用用户定义的方法并添加组件到面板
    */
    placeComponents(panel);

    // 设置界面可见
    frame.setVisible(true);
  }

  private static void placeComponents(JPanel panel) {

    /* 布局部分我们这边不多做介绍
    * 这边设置布局为 null
    */
    panel.setLayout(null);

    // 创建 JLabel
    JLabel userLabel = new JLabel("User:");
    /* 这个方法定义了组件的位置。
    * setBounds(x, y, width, height)
    * x 和 y 指定左上角的新位置，由 width 和 height 指定新的大小。
    */
    userLabel.setBounds(10,20,80,25);
    panel.add(userLabel);

    /*
    * 创建文本域用于用户输入
    */
    JTextField userText = new JTextField(20);
    userText.setBounds(100,20,165,25);
    panel.add(userText);

    // 输入密码的文本域
    JLabel passwordLabel = new JLabel("Password:");
    passwordLabel.setBounds(10,50,80,25);
    panel.add(passwordLabel);

    /*
    *这个类似用于输入的文本域
    * 但是输入的信息会以点号代替，用于包含密码的安全性
    */
    JPasswordField passwordText = new JPasswordField(20);
    passwordText.setBounds(100,50,165,25);
    panel.add(passwordText);

    // 创建登录按钮
    JButton loginButton = new JButton("login");
    loginButton.setBounds(10, 80, 80, 25);

    // 绑定事件监听器
    loginButton.addActionListener(new ButtonClickListener());

    panel.add(loginButton);
  }

  // 定义时间监听器
  private class ButtonClickListener implements ActionListener {
    public void actionPerformed(ActionEvent e) {
      System.out.click("登录！");
    }
  }
}