Java语言基础

Java语言基础

1、Java语言规范

public class HelloWord {
	public static void main(String[] args) {
		System.out.println("Hello,Word!");
	}
}

详解：

关键字public表示访问说明符，表面该类是一个公共类，可以控制其他对象对类成员的访问。
关键字class用于声明一个类，其后所跟的字符串是类的名称。
关键字HelloWord是类名。
关键字 static 表示该方法是一个静态方法，允许调用 main() 方法，无须创建类的实例。
关键字 void 表示 main() 方法没有返回值。
main() 方法是所有程序的入口，最先开始执行。

2、逻辑运算符

运算符用法	含义
a&&b	a与b
a || b	a或b
!a	非a

3、基本语句

for循环

根据循环次数限制做多少次重复操作
for(条件表达式1；条件表达式2；条件表达式3){
语句块；
}

例：for(int i=1;i<=5;i++){
		int result i*= i;
}

while循环

当满足什么条件的时候，才做某种操作
while(条件表达式){
语句块；
}

例：while(i<=10){
		int n=n*i;
		i++;
	}

while(ture){
//无限循环
//可用System.exit(0)停止
}

if-else语句

根据条件判断之后再做处理
if(条件表达式){
语句块;
} else{
语句块;
}

if (score >= 60) {
       System.out.println("通过");
   } else if (score >= 80) { 
       System.out.println("不合格");

switch-case语句

判断一个变量与一系列值中某个值是否相等
switch(变量){
//变量类型可以是： byte、short、int 或者 char。
case value :
case value :
default : //如果参数num不满足任何 case，则>执行 default 后的语句
}

4、输入与输出

通过 Scanner 类来获取用户的输入。
然后用print和println控制输出。print不会将光标移动到下一行，println会将光标移动到下一行。

例题：编写程序，实现两数之积的功能。提示用户输入两个整数，然后输出两数的乘积。循环执行程序，当用户输入两个数都为零时，退出程序。

import java.util.Scanner;
public class B {
	public static void main(String[] args) {
		for(;;) {
		Scanner input1 = new Scanner(System.in);
		System.out.print("请输入整数a：");
		int a = input1.nextInt();
		Scanner input2 = new Scanner(System.in);
		System.out.print("请输入整数b：");
		int b = input2.nextInt();
		if(b==0 && a==0) {
			System.exit(0);
		}
		int result = a*b;
		System.out.println("两数乘积结果为"+ result);	
	}

}
}

4、数组

一维数组

数组的下标起始值为0

1、声明一维数组：
type[] arrayName; // 数据类型[] 数组名;
例：
int[] score; // 存储学生的成绩，类型为整型
double[] price; // 存储商品的价格，类型为浮点型
String[] name; // 存储商品名称，类型为字符串型
2、分配空间：
arrayName = new type[size]; // 数组名 = new 数据类型[数组长度];
例：
score = new int[10];
price = new double[30];
name = new String[20];
3、对数组进行赋值
例：
int[] number = new int[5];
number[0] = 1;
number[1] = 2;
number[2] = 3;
number[3] = 5;
number[4] = 8;
也可以直接赋值：
int[] number = new int[]{1, 2, 3, 5, 8};

二维数组及多维数组

就是多加个中括号……

5、面向对象

(1)认识类和对象

类是构造面向对象程序的基本单位。
类是对象的抽象，对象是类的具体。
类是描述了一组有相同特性（属性）和相同行为（方法）的一组对象的集合。
对象执行的操作称为类的方法
三大核心特性

定义类所需关键字：class
其完整语法如下

[public][abstract][final]class<class_name>     [extends<class_name>]
[implements<interface_name>]{
			//定义属性部分
		    <property_type><property1>;
		    <property_type><property2>;
		    <property_type><property3>;
		    ···
		    //定义方法部分
		    function1();
		    function2();
		    function3();
		    ···
}
//提示：上述语法中，中括号“[]”中的部分表示可以省略，竖线“|”表示“或关系”，例如 abstract|final，说明可以使用 abstract 或 final 关键字，但是两个关键字不能同时出现。

• public：表示“共有”的意思。如果使用 public 修饰，则可以被其他类和程序访问。每个 Java 程序的主类都必须是public 类，作为公共工具供其他类和程序使用的类应定义为 public 类。
• abstract：如果类被abstract 修饰，则该类为抽象类，抽象类不能被实例化，但抽象类中可以有抽象方法（使用 abstract修饰的方法）和具体方法（没有使用abstract修饰的方法）。继承该抽象类的所有子类都必须实现该抽象类中的所有抽象方法（除非子类也是抽象类）。 抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口
• final：如果类被 final修饰，则不允许被继承。
• class：声明类的关键字。
• class_name：类的名称。
• extends：表示继承其他类。
• implements：表示实现某些接口。
• implements：表示实现某些接口。
• property_type：表示成员变量的类型。
• property：表示成员变量名称。
• function()：表示成员方法名称。
  例：

public class Student {     //声明一个Students的类
//以下为类的属性，即类的数据成员
    public String Name;    // 学生姓名
    public int Age;    // 学生年龄
    private boolean Sex;    // 学生性别

public boolean isSex() { //定义一个布尔型的方法
    return Sex;
}
public void setSex(boolean sex) {
    this.Sex = sex;//让类中一个方法，访问该类里的另一个方法或实例变量。可用于任何实例方法内指向当前对象.调用此方法的那个对象，谁调用指向谁。
}
public static void main(String[] args) {
    Student zhang = new Student(); // 创建第一个实例即对象
    zhang.Name = "张子同";
    String isMan = zhang.isSex() ? "女" : "男";
    System.out.println("姓名：" + zhang.Name + "性别：" + isMan + "年龄：" + zhang.Age);
    Student li = new Student(); // 创建第二个实例
    li.Name = "李子文";
    li.Sex = true;
    li.Age = 15;
    String isWoman = li.isSex() ? "女" : "男";
    System.out.println("姓名：" + li.Name + "性别：" + isWoman + "年龄：" + li.Age);
}
}
}
public class Student {
    public StringBuffer printInfo(Student st) {
        StringBuffer sb = new StringBuffer();
        sb.append("学生姓名："+st.Name+"\n 学生年龄："+st.Age+"\n 学生性别："+st.isSex());
        return sb;
    }
}

//类的创建
public class Student implements Cloneable {   
    // 实现 Cloneable 接口
    private String Name;    // 学生名字
    private int age;    // 学生年龄
    public Student(String name,int age) {    
        // 构造方法
        this.Name = name;
        this.age = age;
    }
    public Student() {
        this.Name = "name";
        this.age = 0;
    }
    public String toString() {
        return"学生名字："+Name+"，年龄："+age;
    }
    public static void main(String[] args)throws Exception {
        System.out.println("---------使用 new 关键字创建对象---------");
       
        // 使用new关键字创建对象
        Student student1 = new Student("小刘",22);
        System.out.println(student1);
        System.out.println("-----------调用 java.lang.Class 的 newInstance() 方法创建对象-----------");
       
        // 调用 java.lang.Class 的 newInstance() 方法创建对象
        Class c1 = Class.forName("Student");
        Student student2 = (Student)c1.newInstance();
        System.out.println(student2);
        System.out.println("-------------------调用对象的 clone() 方法创建对象----------");

        // 调用对象的 clone() 方法创建对象
        Student student3 = (Student)student2.clone();
        System.out.println(student3);
    }
}

public class Demo1_Abstract {
	public static void main(String[] args) {
		//Animal a = new Animal();			//错误: Animal是抽象的; 无法实例化
		Animal a = new Cat();				//父类引用指向子类对象
		a.eat();
	}
}

abstract class Animal {						//定义抽象类
	public abstract void eat();				//定义抽象方法
}

class Cat extends Animal {
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

继承性

程序中的继承性是指子类拥有父类的全部特征和行为，这是类之间的一种关系。Java 只支持单继承。
将多个类的通用属性和方法提取出来，放在它们的父类中，然后只需要在子类中各自定义自己独有的属性和方法，并以继承的形式在父类中获取它们的通用属性和方法即可。

封装性

封装的目的在于保护信息

多态性

多态性体现在父类中定义的属性和方法被子类继承后，可以具有不同的属性或表现方式。多态性允许一个接口被多个同类使用

Get/Set方法
比如，你有一个private String name;这个属性
由于它是 private 私有属性，不能被外部访问到
所以需要提供一个setName(String name)方法来设置它的值，即给对象赋值。
也需要提供一个getName()方法来得到它的值，即获得一个属性的值。
为什么一定要是set和get呢？其实你用其他的方式命名也是可以的
但这样的话，其他的程序员要看懂就有困难了
还有，它有另外的好处
比如你有个字段是name 是可以被设置的 但别人get它的时候 你又不希望提供给他真实的值
你可以这样来写get方法
public String getName(){
return “我的名字是”+this.name+"！";
}

接口中的方法声明只能写成抽象方法的形式
`interface 接口名称{
全局常量声明;
抽象方法声明;
}
举例：

//接口
//InterfaceA.java
public interface InterfaceA{
	public void start();//抽象方法声明
	public void stop();//抽象方法声明
	
}

//实现类
//MovingDisk.java
public class MovingDisk implements InterfaceA{
	//方法实现
	public void start(){
		System.out.println("开始");
	}
	public void stop(){
		System.out.println("结束");
	}
}

//测试类
//Test.java
public class Test{
	public static void main(String[] args){
		InterfaceA a1=new MovingDisk();//将移动硬盘插入到接口A
		a1.start();//开启移动硬盘
		a1.stop();//关闭移动硬盘
	}
}