-
快捷键
package com.bjpowernode.javase;
//package机制是java语法的一部分
public class HelloWorld {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 快捷键
// ctrl + D 删除一行
// alt + / 自动补全
// ctrl + s 保存
// ctrl + 1 鼠标停留在红色下划线，2211自动纠错
// ctrl + shift + f 自动纠正格式
// ctrl + / 注释与取消注释
// ctrl + shift + / 多行代码的注释与取消注释
System.out.println("Hello World !");
}
}
-
构造函数
package com.bjpowernode.javase;
/**
* 构造函数/构造方法
* @author Wrapping
*
* 语法结构：
* [修饰符列表] 构造方法名(形参列表){
* 构造方法体;
* }
*
* 每个构造方法实际上执行结束后都有返回值，构造方法结束时java程序自动返回值。
* 并且返回值类型是构造方法所在的类的类型，由于构造方法的返回值类型就是类本身，所以返回值类型不需要缩写。
*
* 当一个类显式的将构造方法定义出来了，那么系统将不再为这个类提供缺省构造器，建议在实际应用中手动的为当前类提供无参构造器。
*
* this关键字指向本对象，引用存放于栈内存，new出来的对象与this一起存放于堆内存，而堆内存又指向new出来的对象
* 实际上，new出来的对象中包含this
* 带有static关键字的方法是通过类名的方式去访问的，没有对象，所以不存在this
*
* 可以使用static关键字定义 静态代码块
* 语法格式为：
* static{
* java语句;
* }
* 静态代码块在类加载时执行，并且只执行一次。
*
* 静态代码块在一个类中可以定义多个，并且遵循自上而下的顺序执行。
* 如果项目要求在类加载的时刻执行代码完成日志的记录，那么这段记录日志的代码可以写在静态代码块当中。
*
*
* 实例代码块，可以编写多个，遵循自上而下的顺序执行，在构造函数执行前执行，构造函数执行一次，实例代码块执行一次
*
*
*/
public class Constructor {
private int num;
static String country = "中国";//静态变量，类加载时直接分配内存，不用创建对象，该变量与.class关联，存储于方法区内存中
public void printNum() {
System.out.println(num + "出现了！！！");//this大多数情况下都可以省略不写
System.out.println(this.num + "又出现了！！！");
}
public Constructor() {
//默认构造函数
System.out.println("我是默认构造函数");
}
public Constructor(int i) {
//带参构造函数
System.out.println("我是带参构造函数");
num = i;
}
{
System.out.println("我是实例代码块，我在构造函数执行前执行1");
}
{
System.out.println("我是实例代码块，我在构造函数执行前执行2");
}
{
System.out.println("我是实例代码块，我在构造函数执行前执行3");
}
public void setNum(int a) {
num = a;
}
public int getNum() {
return num;
}
public static void main(String[] args) {
ConstructorTest.main();
ConstructorTest.main("哈哈哈哈");
}
}
package com.bjpowernode.javase;
/**
* 构造函数测试
* @author Wrapping
*
*/
public class ConstructorTest {
public static void main(String[] args) {
System.out.println("我是main函数，我在静态代码块后面执行");
Constructor u = new Constructor();
System.out.println(u.getNum());
u.setNum(50);
System.out.println(u.getNum());
Constructor v = new Constructor(100);
System.out.println(v.getNum());
u.printNum();
v.printNum();
System.out.println(Constructor.country);//静态参数，用类型.参数访问
}
static {
System.out.println("我是静态代码块,我执行后main函数才执行");
}
//main函数也可以重载,使用 类名.main(参数)调用
public static void main() {
System.out.println("我是main函数的无参重载");
}
public static void main(String x) {
System.out.println(x + "我是main函数有参重载");
}
}
-
封装
package com.bjpowernode.javase;
/**
* 学生类
* @author Wrapping
*
*/
public class Student {
//学号
int no;
//姓名
String name;
//年龄
private int age; //将age设置成私有，提高安全性
//住址
String addr;
//性别
String sex;
public static void testFun() {
System.out.println("我是有static关键字修饰的方法");
}
/*
* 封装、继承、多态
* 面向对象 封装性
* 提供两个接口函数，外部可以通过这两个接口来访问私有的age
* 想要修改age属性，就调用set方法
* 想要读取age属性，就调用get方法
*
* set方法命名规范
* public void setAge(int a){
* age = a;
* }
*
* get方法命名规范
* public int getAge(){
* return age;
* }
*/
public void setAge(int a) {
//编写业务逻辑代码进行安全控制
if(a < 0 || a > 150){
System.out.println("输入的年龄不合法");
return ;
}
//年龄合法
age = a;
}
public int getAge() {
return age;
}
/*
* 注意 set和get方法没有static关键字
* 有static关键字修饰的方法调用：类名.方法名(实参);
* 没有static关键字修饰的方法调用：引用.方法名(实参);
*/
}
package com.bjpowernode.javase;
/**
* 学生测试类
* @author Wrapping
*
*/
public class StudentTest {
// main方法自动补全
// 输入main，然后alt + /，回车
public static void main(String[] args) {
Student s = new Student(); // 后面的Student要加上();
System.out.println(s.no);
System.out.println(s.name);
System.out.println(s.addr);
System.out.println(s.sex);
//以下 测试有无static关键字的方法调用区别
s.setAge(22);//设置年龄 无static关键字修饰
System.out.println(s.getAge());
Student.testFun();//测试有static关键字修饰的函数
}
}
-
继承
package com.bjpowernode.javase;
/**
* 账户类
* @author Wrapping
*
* 一键生成构造函数
* 右键-> Source -> Generate Constructor using Fields -> Generate 生成有参构造函数
* 右键-> Source -> Generate Constructor using Fields -> 取消上面的对号 -> Generate 生成无参构造函数
* 一键生成set,get方法
* 右键-> Source -> Generate Getters and Setters Methods for the type's Fields -> Generate
*
*/
public class Account {
private String actno; //账户
private double balance; //余额
public String getActno() {
return actno;
}
public void setActno(String actno) {
this.actno = actno;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public Account(String actno, double balance) {
super();
this.actno = actno;
this.balance = balance;
}
public Account() {
super();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
}
}
package com.bjpowernode.javase;
/**
* 信用账户类
* @author Wrapping
*
*/
public class CreditAccount extends Account{
private double credit;
public double getCredit() {
return credit;
}
public void setCredit(double credit) {
this.credit = credit;
}
public CreditAccount(String actno, double balance, double credit) {
super(actno, balance);
this.credit = credit;
}
public CreditAccount() {
super();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
}
}
package com.bjpowernode.javase;
/**
* 测试用类
* @author Wrapping
*
* 关于java语法当中的 继承：主要是为了代码的复用
* 有了继承才会有 方法的覆盖 和 多态机制
*
* 继承 语法格式：
* [修饰符列表] class 类名 extends 父类名 {
* 类体：属性+方法
* }
*
* java当中的继承只支持单继承，一个类不能继承很多类，只能继承一个类，但是c++中支持多继承。
* 可间接地多继承
* C extends B{
* }
* B extends A{
* }
* A extends T{
* }
* 其中C类直接继承B类，但间接继承A类和T类。
*
* 假设一个类没有显式的继承任何类，那么该类默认继承JavaSE库中提供的java.lang.Object类
*
* B类继承A类
* A类称为：父类，基类，superclass
* B类称为：子类，派生类，subclass
*
* 子类继承父类，但父类的构造函数不能被继承，其他的都可以被继承。注意：私有的不支持继承
*
*/
public class ExtendsTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
ExtendsTest et = new ExtendsTest();
String s = et.toString();
System.out.println(s);
CreditAccount act = new CreditAccount();
act.setActno("act-001");
act.setBalance(-10000.0);
act.setCredit(0.99);
System.out.println(act.getActno() + "," + act.getBalance() + "," + act.getCredit());
}
}
-
方法覆盖override
package com.bjpowernode.javase;
/**
* 动物类
* @author Wrapping
*
*/
public class Animal {
//动物都可以移动
public void move() {
System.out.println("动物在移动");
}
}
package com.bjpowernode.javase;
/**
* 飞禽类
* @author Wrapping
*
*/
public class Bird extends Animal{
//对父类中的move()进行重写
public void move() {
System.out.println("鸟儿在飞翔");
}
public void fly() {
System.out.println("鸟儿用翅膀飞翔");
}
}
package com.bjpowernode.javase;
/**
* 猫科类
* @author Wrapping
*
*/
public class Cat extends Animal{
//对父类中的move()进行重写,这就叫override
public void move() {
System.out.println("猫在走猫步");
}
//子类特有的行为
public void catchMouse() {
System.out.println("猫抓老鼠");
}
}
package com.bjpowernode.javase;
/**
* 母鸡类
* @author Wrapping
*
* 生成继承父类的子类: 右键package-> new -> class -> superclass -> Browse -> 父类
*
*
*/
public class Hen extends Bird {
//生成子类的而覆盖方法: 右键-> Source -> Override/Implement Methods -> 勾选 -> OK
@Override
public void move() {
// TODO Auto-generated method stub
System.out.println("母鸡飞不起来");
}
}
-
多态
package com.bjpowernode.javase;
/**
* 多态测试类
* @author Wrapping
*
* 多态中的概念：
* 向上转型：upcasting 子类型转换为父类型 自动类型转换
* 向下转型：downcasting 父类型转换为子类型 强制类型转换
* 无论是向上转型还是向下转型，两种类型之间必须要有继承关系，如果没有继承关系，则程序无法编译通过
*
* java程序永远都分为编译阶段和运行阶段，先分析编译阶段，再分析运行阶段，编译没通过，则根本是无法运行的
* 编译阶段编译器检查a2这个引用的数据类型为Animal，由于Animal.class字节码中有move()方法，所以编译通过，该过程称为静态绑定，编译阶段绑定。只有静态绑定成功之后才有后续的运行
*
* 在程序运行阶段，JVM堆内存当中真实创建的是Cat对象，所以程序在运行阶段会调用Cat对象的move()方法，此时发生了程序的动态绑定
*
* 如果Cat中没有重写的方法，则调用的是Cat继承的Animal中的move()方法，这个move()方法被继承后就属于Cat
* 无论Cat类有没有重写move方法，运行阶段调用的一定是Cat'的move方法，因为底层真实对象就是Cat对象
*
* 父类型引用指向子类型对象这种机制导致程序存在编译阶段绑定和运行阶段绑定两种不同的形态，这种机制可以称为一种多态语法机制。
*
*
* 当调用的方法是子类中特有的，在父类中不存在，则必须进行向下转型downcasting
* Animal->Cat
*
*
* instanceof运算符 执行结果是布尔类型
* 语法格式：
* (引用 instanceof 数据类型名)
*
* 假如:(a instanceof Animal)
* true表示：a这个引用指向的对象是一个Animal类型
* false表示：a这个引用指向的对象不是Animal类型
*
*/
public class PmpTest {
public static void main(String[] args) {
//使用多态语法机制
//Cat is Animal.合法
Animal a2 = new Cat(); //子类型转换为父类型，向上转型upcasting，自动类型转换
a2.move(); //调用的是Cat的move()方法
//a2.catchMouse();//但是这样会报错
//编译阶段编译器检查到a2的类型是Animal，从Animal.class字节码文件中查找catchMouse()方法，最终没有找到该方法，导致静态绑定失败，也就是编译失败。
Cat c2 = (Cat)a2;//父类型转化为子类型
c2.catchMouse();
Animal a3 = new Bird();
if(a3 instanceof Cat) {
Cat c3 = (Cat)a3;
c3.catchMouse();
}else if(a3 instanceof Bird){
Bird b2 = (Bird)a3;
b2.fly();
}
//Cat c3 = (Cat)a3;
//编译没有任何问题，但是在运行阶段会出现异常，因为JVM堆内存当中真实存在的对象是Bird，Bird对象无法转化为Cat对象，两种类型之间不存在任何继承关系
//出现了著名的异常java.lang.ClassCastException异常，这种异常总是在 向下转型 时候发生（强制类型转换）
//使用instanceof运算符可以避免出现以上的异常
}
}
-
final关键字
package com.bjpowernode.javase;
/**
* final关键字测试类
* @author Wrapping
*
* final是一个关键字，表示最终的，不可变的
* final修饰的类无法被继承
* final修饰的方法无法被覆盖
* final修饰的变量一旦赋值之后，不可重新赋值
* final修饰的实例变量必须手动赋值，不能使用系统默认值。一般与static联合使用public static final double PI = 3.141592657;被称为常量
* final修饰的引用，一旦指向某个对象之后，不能再指向其他对象，那么被指向的对象无法被垃圾回收器回收。
*
* package机制
* 在java源程序第一行编写package语句，一个package只能编写一个语句
* 语法：package + 包名;
* 包名的命名规范：
* 公司域名倒序 + 项目名 + 模块名 + 功能名;
* 采用这种方式重名的几率比较低。因为公司域名具有全球唯一性
* 例如：com.bjpowernode.oa.user.service
* 使用了package之后，类名变了
* com.bjpowernode.oa.user.service.Test
* import用来导入其他类，同一个包下的类不需要导入，不在同一个包下需要手动导入
* import语句需要编写在package语句之下，class语句之上
* java.lang.*;不需要手动引入，系统自动引入
* 因为language包是java的核心类，不需要手动引入
* 如果想在一个包内使用另一个包内的类，则需要import
* eclipse快捷键ctrl + shift + o,快捷地将另一个包内的类所在的包导入。
*
* 访问控制权限修饰符
* public 表示公开的，在任何位置都可以访问
* protected 同包，子类可以访问 某个数据只希望子类使用，使用protected进行修饰
* 缺省 同包下可以访问
* private 表示私有的，只能在本类中访问
*
* 类只能采用public和缺省的修饰符进行修饰【内部类除外 内部类：在类中再定义一个类】
*
*
*
*/
public class FinalTest {
}
