java编程基础

类的定义

public class HelloWorld{//定义一个公开的类
    //类体
    
    /*
    main是一个方法，固定写法，是程序的入口；
    其中
    public是公开的
    static表示静态
    void main 方法的返回值
    String[] args:方法的参数列表
    */
    public static void main(String[] args){
        //方法体
        //由Java语句组成，任何一个语句以；结束
        System.out.println("Hello world!");
        System.out.println("我是中国人");
        
    }
    //类体内不能直接写java语句
    //System.out.println("hello");
}

/*
在一个.java文件中可以定义多个class，并且一个class会生成一个.class文件
一个.java文件中可以没有public的class
public的class定义的类名必须和.Java文件名一致
如果要定义public的class，那么这个public的class只能有一个
*/
public class A{
    public static void main(String[] args){
        System.out.println("A的main方法在执行")
    }
}
class B{
    public static void main(String[] args){
        System.out.println("B的main方法在执行！");
    }
}

方法的定义

/*
什么是方法？
*/
public class Method1{
public static void main(String[] args) {
//在main中调用定义好的方法SumInt
//注意：加有static的方法，调用的时候必须采用"类名."的方式调用
Method1.SumInt(100, 200);
Method1.SumInt(1, 2);
}
//定义一个方法，两个整数求和。
public static void SumInt(int a,int b) {
int c = a + b;
System.out.println(a + "+" + b +"=" + c);
}
}
/*
定义方法的语法
[方法的修饰符]方法的返回值类型 方法名（方法的形式参数列表）{
	java语句；
}

*/
public class Method{
    public static void main(String[] args){
        Method2.println("hello china!");
        Method22.m1();
        int a = Methode22.m2(5,6);
        System.out.println("计算机结果",+a);
    }
    public static void println(String msg){
        System.out.println(msg);
    }
}
class Method22{
    public static void m1(){
        System.out.println("Method22的m1的方法被调用");
    }
    public static int m2(int i,int j){
        int k = i+j;
        return k;
    }
}

方法重载

//关于方法重载
//以下程序不用方法重载
/*
在该程序中，要记住三个不同的方法名
*/
public class Method3{
    public static void main([String[] args){
        System.out.println(Computer.SumInt(10,20));
        System.out.println(Computer.SumDouble(10.0, 20.0));
        System.out.println(Computer.SumLong(10L, 20L));
    }
}
class Computer{
    public static int SumInt(int a,int b){
        return a + b;
    }
    public static double SumDouble(double a,double b){
        return a + b;
    }
    public static long SumLong(long a,long b){
        return a + b;
    }
}
//什么时候会发生重载
//关于方法重载
//以下程序使用方法重载
/*
什么时候会发生重载
1.发生在同一类中
2.方法名相同，参数列表不同（类型，个数，顺序）
*/
//方法重载和返回值类型无关
//方法重载和修饰符列表无关
public class Method4{
    public static void main(String[] args){
        System.out.println(Compute.Sum(10, 20));
	System.out.println(Compute.Sum(10.0, 20.0));
	System.out.println(Compute.Sum(10L, 20L));
	System.out.println(3);
	System.out.println("aasd");
	System.out.println('a');
	System.out.println(true);
	System.out.println(5.46);
    }
}
class Compute{
	public static int Sum(int a, int b) {
		return a + b;
}
	public static double Sum(double a, double b) {
		return a + b;
    }
	public static long Sum(long a, long b) {
		return a + b; 
    }
}

方法重写

类与对象

//定义一个学生类，概念上的一个定义，现实世界中不存在
public class Student{
    //属性
    //选号
    int id;//id是成员变量，对象级别
           //必须先由对象才能访问，不能用类来直接访问
    //姓名
    String name;
    //性别
    boolean sex;
    //年龄
    int age;
    //住址
    String address;
    //方法
    //study()
}

/*
对象如何创建和使用
*/
public class OOStudenttest1{
    public static void main(String[] args){
        //1.创建对象，stu1是一个局部变量，属于student类型，也就是一个引用类型
        Student stu1= new Student();
        //一个类型可创建多个对象
        //student stu2 = new Student();
        //2.使用对象
        //访问成员变量，必须使用“”，
        //读取对象的数据
        System.out.println("id=" + stu1.id);
		System.out.println("name=" + stu1.name);
		System.out.println("age=" + stu1.age);
		System.out.println("sex=" + stu1.sex);
		System.out.println("address" + stu1.address);
        //赋值过程
        stu1.id = 11;
        stu1.name = "zhang san";
        stu1.age = 20;
        stu1.sex = true;
        stu1.address = "福建福州";
        //读取结果
        //读取对象的数据
        System.out.println("id=" + stu1.id);
		System.out.println("name=" + stu1.name);
		System.out.println("age=" + stu1.age);
		System.out.println("sex=" + (stu1.sex? "男":"女"));
		System.out.println("address" + stu1.address);
    }
}

封装性

/*
	面向对象的封装性
	*/
public class OOtest2{
    public static void main(String[] args){
        //创建customer类型的对象c
        customer c = new Customer();
        //读取
        //System.out.println(c.age);
        //赋值
        //c.age=10;
        //c.age = -10;
        //读取
        //System.out.println(c.age);
        c.setAge(20);
        c.setAge(-10);
        int age = c.getAge();
        System.out.println(age);
    }
}

/*
定义一个顾客类型
面向对象封装性是指：
1.属性私有化
2.对我提供公开的setter，getter
注:set方法和get方法应该遵循规范
*/
public class Customer{
    //属性
    String name;
    //int age;
    private int age;
    public void setAge(int_age){
        if(_age<0||_age>150){
            System.out.println("年龄不合法！");
            return;
        }
        age = _age;
    }
    //get
    public int getAge(){//少了static，非静态的，成员方法，实例方法要访问必须要”“访问
        return age;
    }
}

构造函数/构造方法/构造器

public class ConstructorTest1{
    public static void main(String[] args){
        User user1 = new User();
        User user2 = new User("Tome");
        User user3 = new User(20);
        User user4 = new User("Mary",18);
        System.out.println(user1.name + ":" + user1.age);
        System.out.println(user2.name + ":" + user2.age);
        System.out.println(user3.name + ":" + user3.age);
        System.out.println(user4.name + ":" + user4.age);
    }
}

关于java类的构造函数

/*
关于 java 类的构造函数
1.构造方法语法：
[修饰符列表] 构造方法名(形式参数列表){
方法体；
}
----构造方法没有返回值，但也不能添加修饰符 void，加上它那就不是构造方法了
2.构造方法的方法名与类名一致
3.构造方法的作用是什么？
(1)创建对象
(2)可以对成员变量初始化
4.构造方法应如何调用？
new 构造方法名（实参）；//在堆开辟空间存储对象
5.如果一个类没有提供任何构造方法，系统默认提供无参构造方法。
6.如果一个类已经手动提供了构造方法，你们系统不会再自动提供如何构造方法。
7.成员变量到底什么时候赋值？
----只有调用构造方法的时候，才会给成员变量赋值。
*/
public class User{
    //定义构造方法
    String name;
    int age;
    User(){
        System.out.println("user's constructor without args invoke!");
    }
    User(String_name){
        name = _name;
        System.out.println("user's constructor without args invoke!");
    }
    User(int_age){
        name = _name;
        age = _age;
    }
}

this关键字

/*
this 关键字：
1.this 是什么？
this 是一个引用类型，保存了内存地址，在堆中的每一个对象上都有 this，this 保存内存
地址指向本身。
2.this 能用在什么地方？
this 用在成员方法中，
this 用在构造方法中。
是在一个构造方法调用另一个构造方法。如：
Mydate(){
this(1970,1,1);
}
this 不能用在静态 static 中。
----因为静态方法的执行不需要 java 对象的存在。直接使用类名访问
而 this 代表的是当前对象。静态方法中根本就没有 this。
*/

//定义一个日期类Mydate,来验证构造方法中使用this
class Mydate{
    int year;
    int month;
    int day;
    Mydate(){}
    Mydate(int _year,int _month,int _day){
        year = _year;
        this.year = _year;
        month = _month;
        day = _day;
    }
}

public class ThisTest{
    public static void main(String[] args){
        Mydate t1 = new Mydate(2018,8,18);
        System.out.println(t1.year+"年"+t1.month+"月"+t1.day+"日");
        Mydate t2 = new Mydate(2010,1,10);
        System.out.println(t2.year+"年"+t2.month+"月"+t2.day+"日");
        
        Employee worker1 = new Employee("Smith",10);
        worker1.work();
        Employee worker2 = new Employee("Tom",10);
        worker2,work();
    }
}

//定义一个雇员类Employee 来演示在成员方法中使用this
class Employee{
    int empno;
    String ename;
    Employee(){};
    Employee(String _ename,int _empno){
        ename = _ename;
        empno = _empno;
    }
    //员工工作的方法
    //this用在成员方法中，谁调用了该方成员方法，this就代表谁
    public void work(){
        System.out.println(this.ename + " is going to work.");
// System.out.println(ename + " is going to work.");
    }
}

继承关系

/*
引入类的继承最基本的作用是：代码重用
语法：
[修饰符列表] class 子类名 extends 父类名{
类体；
}
java 语言中，类和类之间只支持单继承。
*/
public class lnheritTest1{
    public static void main(String[] args){
        Sub sub1 = new Sub();
        sub1.method1();
        sub1.method2();
        sub1.method3();
    }
}
class Super{
    public void method1(){
        System.out.println("method1....");
    }
    public void method2(){
        System.out.println("method2.... ");
    }
    public void method3(){
        System.out.println("method3....");
    }
}
class Sub extends Super{
	public void method3(){
		System.out.println("method3......")
	}
}

多态性

package polymorphosm;
public class Animal{
public void eat() {
System.out.println("animal is eating .....");
}
}
package polymorphosm;
public class Cat extends Animal{
public void eat() {
System.out.println("cat is eating fish.....");
}
//cat 特有的方法
public void move() {
System.out.println("cat is jumping forword....");
}
}
package polymorphosm;
public class Dog extends Animal{
public void eat() {
System.out.println("dog is eating meat.....");
}
}
package polymorphosm;
public class PolyTest{
public static void main(String[] args) {
Animal animal1 = new Animal();
animal1.eat();
Cat cat1 =new Cat();
cat1.eat();
Dog dog1 = new Dog();
dog1.eat();
}
}
package polymorphosm;
/*
关于 JAVA 语言中向上转型和向下转型
1.向上转型：子----->父
2.向下转型：父----->子
注意：无论是向上还是向下转型，两个类之间必须存在继承关系。
*/
public class PolyTest1{
public static void main(String[] args) {
//向上转型又被称作：自动类型转换；
//父类型的引用指向子类型对象
//程序分两个阶段：编译阶段，运行阶段
//程序编译阶段只知道 a1 中是一个 animal 类型
//程序在运行阶段，堆中的实际对象是 cat 类型，从而 cat 重写了 eat 方法
Animal a1 = new Cat();//Animal a1 在编译阶段做“静态绑定”
//new Cat()--->a1 在运行阶段做“动态绑定”
a1.eat();
//向下转型：强制类型转换
Animal a2 = new Cat();//向上转型
//如果要 a2.move();
//无法执行 move（），因为编译阶段 a2 是 animal 类型
// a2.move() //那要执行 move，怎么做？只能强制类型转换
//cat c1 = a2;//不行
Cat c1 = (Cat)a2;
c1.move();
//判断一下程序运行的时候会出现什么问题？
//Animal a3 = new Dog();//向上转型
//强制类型转换
//Cat c2 = (Cat)a3;// java.lang.ClassCastException
//为了避免 java.lang.ClassCastException 发生，java 引入 instanceof
/*
instanceof 用法：
1.instanceof 运算符的运算结果是 boolean 类型
例如：a instanceof Cat
如果结果是 true 表示：a 引用指向堆中的 java 对象是 cat 类型
*/
Animal a3 = new Dog();
System.out.println(a3 instanceof Cat);//false
//推荐：在做向下转型的时候要使用 instanceof 运算符来判断，避免异常发生。
System.out.println(a3 instanceof Dog);
if (a3 instanceof Cat) {
Cat c2 = (Cat) a3;
}
}
}

抽象类

/*
* 1.如何定义抽象类？
* class关键字前加abstract
* 2.抽象类无法实例化
* 3.虽然抽象类没有办法实例化，但是抽象类也有构造方法，该构造方法是给子类创建对象用的。
* 4.抽象类中可以定义抽象方法
* 抽象方法的语法：在方法的修饰符列表中加abstract关键字，并且抽象方法应该以“；”结束，
不能带“{}”。
* 5.抽象类中不一定有抽象方法，但抽象方法必须出现在抽象类中。
* 6.一个非抽象的类继承抽象类，必须将抽象类中的抽象方法覆盖，实现，重写。
*
*/
public abstract class A{
A(){
System.out.println("A........");
}
public abstract void m1();
public static void main(String[] args) {
//可以直接用抽象类来创建对象吗？
//A a = new A();//抽象类无法创建对象
//多态
A a = new B();
}
}
class B extends A{
B(){
//super();
System.out.println("B........");
}
public void m1() {
}
}

接口

//关于接口，及其定义，实现
/*
接口也是一种引用类型，可以等同看作类
1.如何定义接口，语法：
[修饰符] interface 接口名{ }
2.接口中只包括：常量、抽象方法
3.接口实际上就是一个特殊的抽象类，特殊在接口是完全抽象的。
4.接口中没有构造方法，无法被实例化
5.接口与接口之间可以多继承
6.一个类可以实现多个接口。（这里“实现”等同于“继承”）
7.一个非抽象类实现接口，需要将接口中的所有方法实现/重写/覆盖。
*/
public interface AInterface{
//常量（必须用public static final修饰）
public static final String Succ = "success";
public static final double PI = 3.14;
// public static final可以省略的
byte MAX = 127;
//抽象方法（接口中所有的抽象方法都是public abstract修饰）
public abstract void m1();
// public abstract可以省略的
void m2();
//不可以用void m3(){}
}
interface B{
void m1();
}
interface C{
void m2();
}
interface D{
void m3();
}
interface E extends B,C,D{
void m4();
}
//implements是实现的意思，是一个关键字，和extends意义相似。
class Myclass implements B,C{
public void m1() {
}
public void m2() {
}
}
class F implements E{
public void m1() {}
public void m2() {}
public void m3() {}
public void m4() {}
}