java基础语法和面向对象
注释、标识符、关键字
// 单行注释
/* */ 多行注释
/**
*
*/ 文档注释
所有的标识符都应该以字母、￥、_ 开始
关键字就是常用的int、double等等
数据类型
基本类型
byte(-128~127)
short(-32768~32767)
int(-2147483648~2147483647)
long(-9223372036854775808~9223372036854775807)
float、double、char、boolean
1字节(byte) = 8位(bit)
1KB = 1024B
1M = 1024KB
1G = 1024M
二进制0b、八进制0、十六进制0x开头
010等于8、0x10等于16
float f = 0.1f; double d = 1.0 / 10; f 和 d 不相同
BigDecimal 表示银行业务，不可以用浮点数
类型转换
从低到高：(byte、short、char)、int、long、float、double
int i = 128; byte b = (byte)i; //从高到低，强制转换，b等于-128，内存溢出
int i = 128; double b = i; //从低到高，自动转换
注意：
1.不能对布尔值进行转换。
2.不能把对象类型转化为不相干类型。
3.转换的时候可能存在内存溢出或者精度问题
引用类型
类、接口、数组
变量、常量、作用域
变量命名规范：
类成员变量：首字母小写和驼峰原则，monthSalary
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线，MAX_VALUE
类名：首字母大写和驼峰原则，Man、GoodMan
方法名：首字母小写和驼峰原则，run()、runRun()
数据类型 变量名 = 值; //可以用逗号隔开来声明多个同类型变量
new Demo01+alt+回车+回车 //快捷键
public class Demo01 {
//常量，final是修饰符，不区分前后顺序
static final double PI = 3.14;
//类变量，从属于类
static double salary = 1800;
//实例变量，从属于对象，自动初始化为0，除了8个基本类型其他都是null
String name;
int age;
//main方法
public static void main(String[] args) {
//局部变量，必须声明和初始化值
int i = 10;
System.out.println(i);
Demo01 demo01 = new Demo01();
System.out.println(demo01.age + " " + demo01.name + " " + salary + " " + PI);
}
//其他方法
public void add(){
}
}
运算符
算术运算符：+、-、*、/、%、++、–
赋值运算符：=
关系运算符：>、<、>=、<=、==
逻辑运算符：&&、||、！
位运算符：&、|、^、~、>>、<<、>>>
条件运算符：? :
扩展赋值运算符：+=、-=、 *=、/=
包机制
包的本质就是文件夹，防止命名空间重复
一般利用公司域名倒置作为包名，com.baidu.www
package pkg1; //定义包 ，要放在import上面
import package1; //导入包
import com.duan.base.*; //导入这个包下所有的类
JavaDoc
百度搜jdk帮助文档
@author 作者名
@version 版本号
@param 参数名
@return 返回值情况
@throws 异常抛出情况
/**
* @author duanyq
* @version 1.0
* @since 1.8
*/
用户交互Scanner
需要导入包：import java.util.Scanner;
Ctrl+左键点击类，可以看到源码
package base;
import java.util.Scanner;
public class Demo03 {
public static void main(String[] args) {
//创建一个扫描器对象，用于接收键盘数据
Scanner s1 = new Scanner(System.in);
Scanner s2 = new Scanner(System.in);
System.out.println("使用next方式接收：");
//判断用户有没有输入字符串，不读取空格
if(s1.hasNext()){
String str1 = s1.next();
System.out.println(str1 + "真滴帅！");
}
//读取一行，包括空格
if(s2.hasNextLine()){
String str2 = s2.nextLine();
System.out.println(str2 + "真滴漂亮！");
}
//关闭IO流的类
s1.close();
s2.close();
}
}
顺序结构、选择结构、循环结构
package base;
import java.util.Scanner;
public class Demo05 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入内容：");
String s = scanner.nextLine();
//equals，判断字符串是否相等
if(s.equals("Hello")){
System.out.println(s);
}
Scanner scanner1 = new Scanner(System.in);
int score = scanner1.nextInt();
if(score < 60){
System.out.println("不及格");
}else if(score < 80){
System.out.println("良好");
}else{
System.out.println("优秀");
}
char grade = 'A';
switch (grade){
case 'A':
System.out.println("优秀");
break;
case 'B':
System.out.println("良好");
break;
default:
System.out.println("挂科");
break;
}
int sum = 0;
while(sum < 100){
sum += 25;
System.out.println(sum);
}
for(int i = 0; i < 100; i++){
if(i % 10 == 0){
//终止这次循环
continue;
}
if(i == 55){
//终止整个循环
break;
}
System.out.println(i);
}
//定义一个数组
int[] nums = {1, 2, 3};
//增强for循环
for(int x : nums){
System.out.println(x);
}
scanner.close();
scanner1.close();
}
}
九九乘法表
package base;
public class Demo06 {
public static void main(String[] args) {
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(i + " * " + j + " = " + i * j + "\t");
}
System.out.println();
}
}
}
方法
java只有值传递，没有引用传递
方法的定义和调用
修饰符、返回值类型、方法名、参数类型、方法体
import java.util.Scanner;
public class Demo07 {
//main方法
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int a = scanner.nextInt();
int b = scanner.nextInt();
int sum = add(a, b);
//类 对象 方法
System.out.println(sum);
test();
}
//加法
public static int add(int a, int b) {
return a + b;
}
public static void test(){
System.out.println("我是真滴帅！");
}
}
方法的重载
一个类中，有相同的函数名称，但是参数不同
package base;
public class Demo08 {
public static void main(String[] args) {
test(10);
test(11, 12);
}
//加法
public static void test(int a, int b) {
System.out.println(a + b);
}
//重载，参数不同
public static void test(int a){
System.out.println("你是头猪！");
}
}
递归
package base;
public class Demo09 {
public static void main(String[] args) {
System.out.println(f(5));
}
public static int f(int n) {
if(n == 1) {
return 1;
}else {
//递归调用
return n * f(n - 1);
}
}
}
数组
四个基本特点
1.长度是确定的，数组一旦被创建，大小就不可以改变
2.元素必须是相同类型
3.元素可以是基本类型和引用类型
4.数组变量属于引用类型，数组也可以看成是对象，数组的每个元素就是该对象的成员变量。java中对象是在堆中的，所以数组对象本身是在堆中的
java内存分析
堆区：存放new的对象和数组，可以被所有的线程共享，不会存放别的对象引用
栈区：存放基本变量类型（包含这个基本类型的具体数值），引用对象的变量（会存放这个引用在堆里面的具体地址）
方法区：可以被所有的线程共享，包含了所有的class和static变量
package base;
import java.util.Arrays;
public class Demo10 {
public static void main(String[] args) {
//声明数组，在栈区，并不存在
int[] nums;
int num[];
//创建数组，可以存放10个int类型数字，默认值是0，在堆区，才存在，可用下标0~9
nums = new int[10];
//获取数组长度
int n = nums.length;
System.out.println(n);
//静态初始化：创建 + 赋值
int[] a = {5, 2, 3};
//动态初始化：包含默认初始化
int[] b = new int[3];
//计算所有元素的和
int sum = 0;
for(int i = 0; i < 3; i++){
sum += a[i];
}
System.out.println(sum);
//二维数组
int[][] c = new int[10][10];
for(int i = 0; i < 10; i++){
for(int j = 0; j < 10; j++){
c[i][j] = i + j;
System.out.println(c[i][j]);
}
}
//Arrays类
Arrays.sort(a);
System.out.println(Arrays.toString(a));
}
}
面向对象
三大特性：封装、继承、多态
方法的调用
package oop.demo01;
public class Student {
//static静态方法可以直接通过类调用
public static void say(){
System.out.println("学生来了");
}
}
package oop.demo01;
public class Demo01 {
public static void main(String[] args) {
//直接通过类调用方法
Student.say();
Student student = new Student();
//通过对象调用方法
student.say();
}
}
类与对象的创建
package oop.demo01;
public class Student {
//属性
String name;
int age;
//方法
public void study(){
//this表示这个类的方法和属性
System.out.println(this.name + "在学习");
}
}
package oop.demo01;
public class Demo02 {
public static void main(String[] args) {
//类是抽象的，实例化后会返回一个对象
Student xiaoming = new Student();
xiaoming.name = "小明";
System.out.println(xiaoming.name);
xiaoming.study();
}
}
构造器
快捷键：Alt + Insert
1.使用new关键字，本质是在调用构造器
2.用来初始化值
package oop.demo01;
public class Person {
String name;
//显示的定义构造器，无参构造，不写的话也有个默认的
public Person(){
}
//有参构造，定义了有参构造，无参构造必须是显示定义
public Person(String name){
this.name = name;
}
}
创建对象内存分析
封装
1.提高程序的安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护性增加
package oop.demo02;
public class Student {
//属性私有，封装起来
private String name;
private int id, age;
private char sex;
//提供一些可以操作这些属性的方法
//public的get、set方法，快捷键alt + insert
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
}
package oop.demo02;
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("小青年");
s1.setAge(20);
System.out.println(s1.getName() + ":" + s1.getAge());
}
}
继承
对某一类的抽象，extends的意思是扩展，java中类只有单继承，没有多继承
继承是类和类之间的一种关系，除此之外还有依赖、组合、聚合
一个为子类（派生类），一个为父类（基类），子类继承父类
四个访问修饰符：public、protected、default(默认)、private
快捷键查看继承关系：ctrl + h，Object是所有类的父类
package oop.demo03;
//父类
public class Person {
public int money = 10000;
public void say(){
System.out.println("说了一句话");
}
}
package oop.demo03;
//子类
public class Student extends Person{
}
package oop.demo03;
public class Application {
public static void main(String[] args) {
Student student = new Student();
子类继承父类的属性和方法
student.say();
System.out.println(student.money);
}
}
this、super和构造器
package oop.demo03;
//父类
public class Person {
public Person(){
System.out.println("父类的无参构造");
}
public String name = "小青年";
}
package oop.demo03;
//子类
public class Student extends Person{
public Student(){
//隐藏代码：调用了父类的构造器，如果要显示表示，则必须在第一行
//super();
System.out.println("子类的无参构造");
}
private String name = "小屁孩";
public void test(String name){
//传进的参数
System.out.println(name);
//调用自己的属性
System.out.println(this.name);
//调用父类的属性，如果是私有的属性或方法，则无法继承
System.out.println(super.name);
}
}
package oop.demo03;
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.test("小学生");
}
}
方法的重写
需要满足：子类继承父类，子类重写父类的方
修饰符范围只能扩大：public > protected > default > private
package oop.demo03;
//父类
public class Person {
public void test(){
System.out.println("父类");
}
}
package oop.demo03;
//子类
public class Student extends Person{
//重写方法，只和非静态方法有关系
public void test(){
System.out.println("子类");
}
}
package oop.demo03;
public class Application {
public static void main(String[] args) {
Student student = new Student();
Person student1 = new Student();
//方法的调用只和左边定义的数据类型有关
student.test();
//父类的引用指向子类，调用的子类重写的方法
student1.test();
}
}
多态
多态是方法的多态，必须存在继承关系，方法需要重写，父类引用指向子类对象
A instanceof B：判断对象A属不属于类B
package oop.demo04;
public class Person {
public void run(){
System.out.println("父类");
}
}
package oop.demo04;
public class Student extends Person{
public void run(){
System.out.println("子类");
}
public void eat(){
System.out.println("我在吃东西");
}
}
package oop.demo04;
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的，可以指向的引用类型不确定
new Person();
new Student();
//多态
Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();
s1.run();
//子类重写了父类的方法，执行子类的方法，但是不能调用子类独有的方法
s2.run();
//强制转换，高转低
((Student)s2).eat();
}
}
static作用
package oop.demo05;
public class Student {
//静态变量，和类一起加载
private static int age;
private double score;
public void eat(){
System.out.println("我在吃饭");
}
public static void run(){
System.out.println("我在跑");
}
public static void main(String[] args) {
Student s1 = new Student();
System.out.println(s1.age);
System.out.println(s1.score);
//通过对象访问
new Student().eat();
//通过类可以直接访问静态变量和静态方法，属于类，可以被所有成员共享，多线程
System.out.println(Student.age);
Student.run();
//直接访问
run();
}
}
package oop.demo05;
public class Person {
{
//第二
System.out.println("匿名代码块");
}
static {
//第一，只执行一次
System.out.println("静态代码块");
}
//第三
public Person(){
System.out.println("无参构造方法");
}
public static void main(String[] args) {
new Person();
System.out.println("========");
new Person();
}
}
抽象类
1.不能new抽象类，只能靠子类实现
2.抽象类中可以写普通方法
3.抽象方法只能在抽象类中
package oop.demo06;
//抽象类
public abstract class Action {
//抽象方法，只有方法名字，没有方法实现
public abstract void doSomething();
public void hello(){
System.out.println("Hello");
}
}
package oop.demo06;
//继承了抽象类，必须实现他的所有方法
public class A extends Action{
public void doSomething() {
}
}
package oop.demo06;
public class Application {
public static void main(String[] args) {
new A();
}
}
接口
是一种约束，可以多继承，关键字interface
不能实例化，没有构造方法
package oop.demo07;
//接口
public interface UserService {
//接口中所有定义都是抽象的 public
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
package oop.demo07;
public interface TimeService {
void time();
}
package oop.demo07;
//实现接口，必须重写接口中的方法，可以多继承
public class UserServiceImp implements UserService, TimeService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void time() {
}
}
内部类
在一个类中定义一个类
1.成员内部类
2.静态内部类
3.局部内部类
4.匿名内部类