java 源代码运行必须先用javac编译生成字节码文件 XXX.class
运行 java XXX 进行运行
环境变量
classpath:已编译的字节码文件搜索路径
--临时配置：
set classpath=D:\JavaStudy //只在设置路径找类文件
set classpath=D:\JavaStudy; //先设置路径找类文件，找不到去当前路径找分号后可以加多个路径
--查看是否已存在环境变量：
set classpath
2-2关键字：public static void main class ... 特点小写蓝色
//示例代码： //文件名 Hello.java class Hello { //注释：class的名称要和文件名一致 public static void main(String[] args) { System.out.print("Hello World !"); } }
2-3 标识符
1、就是一个名字：对类名、变量名称、方法名称、参数名称等的修饰
2、命名规则
---以字母、下划线_或者$开头，其后可以是字母、数字、下划线或者$
3、命名规范：
---要求：见名知意例如单次password
---要求：变量名称、方法名称、参数名等采用“驼峰”命名法
-例如：firstName,getInfo,
---要求：不超过15个字符 简写例如arguments 简写为：args 参数
2-4 字面量(数据类型)
1、根据当前的值(数据)可以得到当前值对应的数据类型
2、常见字面量：
---整数类型
---浮点数
---布尔类型：true、false
---字符类型：'a' '我'单个
---字符串类型："this is a dog"
2-5 进制见转换
2-6 字符编码
1、ASCII
'a' --- > 97
'A' --- > 65
'0' --- > 48
' ' --- > 32
2、GBK/GB2312:中文编码
3、Unicode: 万国码
注意：Java 源代码采用的是unicode 字符编码
2-7 变量
1、存放数据
2、常用数据类型：见字面量
int
double
bool
String
char
3、声明变量：
--- 语法：数据类型 变量名称
如 int a;
int a;
int b;
double c; //浮点数
String d;
4、赋值语法
变量名称 = 值
a = 5;
b = 6;
c = 3.14;
d = "我爱北京天安门";
5、简化赋值语法
格式：数据类型 变量名 值
int a = 8;
int b = 2018;
double c = 3.14;
String d = "我爱北京天安门";
//使用
System.out.println("年份：" + b );
System.out.println("文字："+ d);
System.out.println("圆周率：" + c);
6、简化语法二
//变量声明和赋值，简化语法，一行搞定
int a = 8, b = 2018;
double c = 3.14;
String d = "我爱北京天安门";
System.out.println("年份：" + b + "\n" + "文字："+ d + "圆周率：" + c );
2-8 转义序列符
\n 表示换一行
\t 制表符tab 键盘
\\ 表示输出一个\
\" 输出一个"
\' 输出一个'
\u0000 输出一个空格 :表示Unicode编码取值
2-9 变量的分类
---按作用范围：
局部变量：方法中的变量都是局部变量
成员变量：在类中，方法外声明的
---按数据类型：
基本数据类型变量:内存中存放的值
例如：int double char ....
引用数据类型变量:内存中变量存储的是0x开头的内存地址
例如：String ...
【内存分析】
当程序运行后，JVM会自动分配内存空间
---内存分析图：
-栈：存放方法以及方法中的局部变量
-堆：存放对象
-方法区：代码片段、常量池(例如字符串的值)、静态属性
释义：
---栈：数据出入走栈顶
---堆：
---【4大类基本数据类型】
--- 整数类型
--- 浮点类型
--- 字符类型
--- 布尔类型
--------整数类型：
子类型 占用空间 存储范围
---byte： 1字节 -128~127
---short： 2字节 -2的15次方~2的15次方-1
---int： 4字节 2 正负32次方范围 【默认】
---long： 8字节 2 的正负63次方范围
--------浮点类型：
子类型 占用空间 存储范围
float 4个字节 -3.403E38 ~3.403E38
double 8个字节 -1.798E3.08 ~ 1.798E3.8
注意：范围小的类型不能直接赋值
float x = 3.14;//报错：错误: 不兼容的类型: 从double转换到float可能会有损失
---解决方法一：
float x = 3.14f;//数字后面加f //自动类型转换
---解决方法二：
float y = (float)3.14; //强制类型转换：数字前面括号数据类型，进行强制类型转换
-------字符类型：char
注意：char类型只能存储一个字符。必须用单引号
类型 占用空间
char 2个字节
---赋值可以和数字相互赋值，取值为ASCII对应的值
char ch = 'a';
ch = 97; //字符类型取值范围0-65535
System.out.println(ch);
int i = 99;
i = 'A';
System.out.println(i);
-------布尔类型：boolean
类型 占用空间 取值范围
boolean 一个字节 true/false
枚举数据类型：
package Vehicle;
/**
* @author: Zhangmingda
* @description：自定义车型：两箱、三箱，SUV、MPV 等，
* 可以看做是一组常量的组合，类似一年只有四个季度
* date: ${DATE}.
*/
public enum CarType {
HATCHBACK,THREECOMPARTMENT, SUV, MPV
//分别代表两箱，三箱，SUV，MPV(商务车)
}
2-11 类型之间转换
---自动类型转换：隐式
---强制类型转换：强制
byte i = 1;
short j = i;//自动类型转换
int k = i;
long k2 = k;
float x = k2;
System.out.println(x);
float a = (float)1.0;//强制类型转换
int b = (int)9.9;//有损失b实际被赋值为9
2-12 类型转换6条规则
---针对基本数据类型转换，除了boolean 类型外剩余7中基本数据类型之间进项相互转换
---取值范围小的类型可直接给取值范围大的类型赋值，称为自动类型转换，也叫隐式类型转换
byte < short < char < int < long float < double
1字节 2字节 2字节 4字节 8字节 4字节 8字节
---取值范围大的不能直接给取值范围小的类型直接赋值，需要进行强制类型转换，可能存在精度丢失，比如9.9 变成9
---当对byte short char 类型赋值时，则没有超出该类型范围是可以直接赋值的。
---当对byte short char 类型混合运算时，则先转为int。
---当对多种类型进行混合运算时，类型最终为取值范围最大的那个类型。
2-13 算数运算符
+ - * / %(取余数)
++ --
//+
//当两个数中有一个为非数值类型则做连接(从左到右)，最终为String类型
int a = 3, b = 4;
int sum = a + b;
System.out.println("sum =" + sum);
System.out.println("sum = " + a +b );
System.out.println("sum = " + (a +b ));
//-
//++
//--
int m = 5, n = 10;
n = m--; //m = 4 n = 5
System.out.println("m = " + m + "\tn = " + n);
int x = 5 ,y = 6;
x = --y; //x = 5 y = 5 注：y自身已经减去1，再赋值给x，所以y先变成了5，x重新赋值5，
System.out.println("x = " +x +"\ty = "+ y);
int a = 3, b = 4 ;
b = a-- +2; // a = 2 b = 5 注：a做完运算才自身减去1 b 等于原来的a(3) + 2 = 5
System.out.println("a = " + a + "\tb = " + b);
2-14 连接运算符
+
2-15 赋值运算符
=
扩展
+= -= *= /= %=
//赋值运算符
int sum = 0;
//sum = sum +1 ;//sum = sum + 1
int i = 3;
//sum = sum *10 + i % 10; //sum = 3;
sum *= 10 + i % 10; //sum = 0 即【sum = 0 * (10 + 3)】
2-16 关系运算符
> < >= <= == !=
注意：
1、优先级别：算数运算符 > 关系运算符
2、关系运算符最终结果为boolean 类型值
2-17 逻辑运算符
符号 意义
逻辑与& 并且
逻辑或| 或者
逻辑异或^
逻辑非!
短路与&& 并且
//短路与、逻辑与在执行结果上相同,执行过程不同，短路与效率更高，第一个为faslse，直接为false
System.out.println(10 > 1 && 6 != 7); //true
System.out.println(10 > 1 & 6 != 7); //ture
//当使用短路&& 第一个判断条件为fasle 则直接判断为false；
System.out.println(0 > 5 && 8 < 80 ); //false
System.out.println(0> 5 & 8 < 80 ); //false
System.out.println(6 >= 6 && 3 >= 4 ); //false
System.out.println(6 >= 6 & 3 >= 4); //false
短路或 ||
//短路或||
//总结：短路或、逻辑或 在执行结果上相同，单执行过程短路或更高。第一个条件为true 直接为true
System.out.println(1 <= 2 || 4 != 9); //true 当左边满足条件后边的就不判断了
System.out.println(1 <= 2 | 4 != 9); //tru
2-18 逻辑运算符区别
&与&&：/短路与、逻辑与在执行结果上相同,执行过程不同，短路与效率更高，第一个为faslse，直接为false
|与||：短路或、逻辑或 在执行结果上相同，单执行过程短路或更高。第一个条件为true 直接为true
2-19 三目运算符
也叫条件运算符
语法格式： 条件 ？代码1： 代码2
类似Python的三元运算
String s = 1 > 10 ? "是":"否"; //条件满足取值:前，不满足取值:后
System.out.println("s = " + s);
//简写
int num = 23;
System.out.println(num > 0 && num < 99 ? "是两位数":"不是两位数");
//多个条件组合
2-20 接收键盘输入
import java.util.Scanner;//导入软件包
//创建Scanner(扫描仪) 对象
Scanner input = new Scanner(System.in);
//提示语
System.out.print("请输入一个数");
//键盘接收用户输入
int num = input.nextInt();
System.out.println("num = " + num);
//组合判断赋值
System.out.println("num = " + ( num % 2 == 0 ? "偶数" : "奇数")); //先算出后面的字符串再 组合所以要括起来
String s = input.next(); //Java中不能接收字符类型，需要接收字符串再从字符串中取0位
char sex = s.charAt(0);
3-1 程序流程控制三大结构
循序结构：顺序执行
选择结构：
循环结构：
3-2 选择结构if
if(条件){
代码块
}
if(score >= 95){
System.out.println("O(∩_∩)O哈哈~！ 恭喜");
}
else if(80 < score && score < 95){
System.out.println("及格！");
}
else{
System.out.println("不及格哦");
}
三目运算/三元运算：
System.out.println(score > 95 ? "O(∩_∩)O哈哈~！ 恭喜" : score >= 80 ? "恭喜及格！": "很遗憾，继续努力哦");
3-3 字符串比较
== 是比较内存地址
String.equals(); 是对比值
if ("第一名".equals(info)){
System.out.println("奖励十万");
}
3-4 switch case
适用于等值操作
switch(info){
case "第一名":
System.out.println("奖励10W");
break;
case "第二名":
System.out.println("奖励5W");
break;
default:
System.out.println("无奖励！");
break;
注意事项：
1、case值的顺序可以颠倒。
2、default 位置先和都可以，建议编写在最后
3、case 后面的break必须有，否则会穿透。
3-5 多重if 和switch case
---多重if 选择结构：可以做区间操作+ 等值操作
---switch case 只能做等值操作
4 循环结构
4-1
重复事情：
好处：减少代码
特点：循环条件、循环体
常用循环：
for、while、do while
4-2 for 循环
语法：
for(表达式1;表达式2;表达式3){
循环体语句
}
注意：
表达式1 完成变量初始值，如int i = 1；
表达式2 完成循环条件判断，如果添加为true，执行循环体，否则结束for循环；如i <= 5;
表达式3 完成变量值的更改(更新)
循环体 重复做的事儿
【注意】
1、表达式1、2、3 都可以省略，但是;不可省略
2、表达式1省略，可以在for循环前定义
3、省略表达式2、3、出现死循环。
4、省略表达式3、可以在循环体中补充。
示例1：
for(int i = 1; i <= 8 ; i++){
System.out.println("第" + i + "遍 Hello world！");
}
示例2://循环结合附加条件-中间换行
int count = 0;
for (int i = 100;i <= 999 ; i++ )
{
if (i % 7 == 0)
{
System.out.print(i + "\t");
count += 1;
if(count % 5 == 0 ){
System.out.println();
}
}
}
4-3 while循环
语法格式：
while(循环条件){
循环体
}
代码示例：
while(i <= 100){
//System.out.println( i % 5 == 0 ? i: null);
if(i % 4 == 0){
System.out.print(i + "\t");
count++;
if (count % 5 == 0 ){
System.out.println();
}
}
i++;
}
4-4 do while循环
语法格式
do{
循环体
}whil(循环条件)
执行流程
先执行循环体，后进行循环条件判断
示例代码：
Scanner input = new Scanner(System.in);
String info ; //循环体外声明条件判断变量，否则while判断时编译错误
do{
System.out.println("编写代码");
System.out.println("老师检查");
info = input.next();
}while("不合格".equals(info));
System.out.println("合格");
4-7 三种循环异同点
1、格式
2、循环次数：
次数固定：建议for
次数不固定：建议while do while
先判断再循环：while
先循环再判断：do while
3、例：
第一次为false
---for 0次循环
---while 0次执行循环体
---do while 1次执行循环体
总结：
for: 0----N次
while：0 ---N次
do while 1--- N次
4-8 break ,continue
...
4-9 break 与 continue 的区别
---场景
break : switch case,以及循环中都可以用
continue 只能在循环中使用
---作用不同
break：表示中断，结束当前整个循环，或者结束switch case 语句
continue：结束当次循环，继续下一次循环...
5 方法
5-1 方法分类定义
定义：也叫函数
分类：系统方法、用户自定义方法
5-2 自定义方法(函数)
语法格式：
[修饰符] 返回类型 方法名称([参数列表]){
方法体
}
场景1：无参数、无返回。
返回类型写 void
注意一：
1、[] 中的内容可有可无，暂时修饰符 编写为public static
2、返回类型：
第一种，无返回类型，写void
第二种，有返回类型，也就是编写为目前所学 9 中数据类型之一
3、方法(函数)名称：
注意二：
1、方法要编写再类中
2、必须包含main方法
在main方法中调用自定义方法
例如：Method01.print();
class Method01{
/*
[修饰符] 返回类型 方法名称([参数列表]){
方法体
}
*/
public static void print(){
//方法内输出5遍HelloWorld
for (int i = 1; i <= 5 ;i++ )
{
System.out.println("第" + i + "遍Hello World！");
}
}
//在main方法中调用方法
public static void main(String[] args){
Method01.print();
}
}
方法调用：
格式: 类名.方法名()
注意: 本类中的类名.可以省略
调用过程：
1、方法执行，需先进栈
2、方执行完毕，方法出站。
3、栈特点，先进后出。
示例代码一：无参数有返回
public static int sum(){
Scanner input = new Scanner(System.in);
System.out.print("请输入第一个数字：");
int i1 = input.nextInt();
System.out.print("请输入第二个数字：");
int i2 = input.nextInt();
int s = i1 + i2;
return s; //返回
}
示例代码二：有参数，有返回
public static int sum(int i1,int i2){ //形参
return i1 + i2;
}
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.print("请输入第一个数字：");
int i1 = input.nextInt();
System.out.print("请输入第二个数字：");
int i2 = input.nextInt();
int count = Method04.sum(i1,i2);
System.out.println(count);
}
示例代码三：返回boolean值
//水仙花计算水仙花数有哪些
class Method04{
public static boolean isFlower(int num){
//判断百位、十位、各位数分别是什么：十位数计算只有需注意/10 再取余数兼容两位数和三位数
int bw = num /100,sw = num / 10 % 10,gw = num % 10;
int sum = bw * bw * bw + sw * sw * sw + gw * gw * gw;
return sum == num; //返回true or false
}
}
class Method05{
public static void main(String[] args){
for(int i = 1;i <= 999 ; i++){
if (Method04.isFlower(i)) //直接用返回值是true就执行打印
{
System.out.println(i);
}
}
}
}
5-3 总结break 、 continue 、 return 区别
break：中断
continue：循环中跳过当次
return：只能在方法中使用，{ ......; return }
【return】无返回方法(void) 中可以使用return; 但不能返回任何值
【return】后，不能再写其他语句，否则编译错误：无法访问的语句
5-4 方法的重载
一个类中，多个重名方法。
条件：方法名必须相同，单参数列表必须不同(个数、类型、顺序)，与返回值无关
示例代码：
class MethodRepeat{
public static void main(String[] args){
//计算两个值中哪个大
System.out.println(max(123,234));//使用于都是int或者都是double类型的判断
}
//max 方法重载
public static int max(int x,int y){ //第一个max 参数int类型
return x > y ? x : y ;
}
public static double max(double x , double y){ //第二个max 参数double类型
return x > y ? x :y ;
}
}
6 面向对象==============================封装、继承、多态===========================
6-1 概念：
1、同一类事物的抽象描述，不是具体的
2、类和对象的关系：
类 是抽象的。
对象 是具体的。
3、对象的体征，称为“属性”
4、多个 对象的方法 + 属性 相同 构成一类
6-2 类的编写构成。
第一步 语法：
[修饰符] class 类名 {
}
注意： 1、修饰符可有可无，如果写，类名和文件名必须相同。
2、类名驼峰命名法。
第二步：类的属性-即 成员变量。
语法格式：
[修饰符] 数据类型 属性名称
注意： 1、修饰符可有可无
2、驼峰命名法
3、不同数据类型，声明后有默认值(仅在成员变量中)。
默认值
整数类型：0
浮点类型：0.0
字符类型：\u0000 就是空格
布尔类型：false
引用类型：null
6-3 编写测试类.即包含main方法的类
6-4 创建对象
语法：类名 引用名称(实例名称) = new 类名()
访问对象中的属性和方法：实例名称.属性名称
示例代码：
class Student{
//属性变量的默认值
String name; //null
int age; //0
double weight; //0.0
char sex; //\u0000
public void print(){
System.out.println(age);
}
/*
public static void main(String[] args){
print(); //错误: 无法从静态上下文中引用非静态 方法 print()
}*/
}
//编写测试类
class StudentTest
{
public static void main(String[] args){
Student s1 = new Student();
s1.print();//调用对象的方法
System.out.println(s1.weight);//调用(访问对象属性)
}
}
访问对象中的方法：实例名称.方法名称();
示例代码：
class Student{
//属性变量的默认值
String name; //null
int age; //0
double weight; //0.0
char sex; //\u0000
public void print(){
System.out.println(age);
}
/*
public static void main(String[] args){
print(); //错误: 无法从静态上下文中引用非静态 方法 print()
}*/
}
//编写测试类
class StudentTest
{
public static void main(String[] args){
Student s1 = new Student();
s1.print();//调用对象的方法
System.out.println(s1.weight + s1.name + s1.sex + s1.weight);//调用(访问对象属性)
}
}
类中变量区别：
--成员变量：没有赋值时有默认值，数据类型不同，则默认值不同。
--局部变量：没有初始值，也就是说必须先声明，在赋值，然后才能使用//否则编译错误
----局部变量名可以和成员变量同名，方法内调用时就近原则
示例代码：
class Car{
String id ;
String color ;
public void show(){
String id = "冀H D8888";
System.out.println("局部变量：" + id);
System.out.println("实例变量：" + this.id); //方法中引用成员变量，使用this
}
}
class CarTest{
public static void main(String[] args){
Car c1 = new Car(); //实例化类
c1.show();
c1.id = "京 A 00000";
c1.show(); //给实例变量赋值
}
}
6-5 构造方法：对成员变量赋值
语法格式：
public 类名([参数列表]){
完成对成员变量赋值
}
注意： 1、构造方法名必须和类名一致。
2、必须没有返回值类型，也就是不编写任何返回值类型
示例：
3、构造方法，创建对象时自动执行
4、分类：
-------隐式构造方法：在一个类中，如果没有手动编写构造方法，则系统会提供一个默认的无参 的构造方法
-------显式构造方法: 手动编写的构造方法。如果手动编写了，则系统不会提供无参的构造方法
建议：手动编写构造方法之前，先编写无参构造方法，再编写需要的构造方法
5、构造方法重载：
同一个类中，同名，参数不同的多个构造方法
代码示例：
class Dog{
//有参构造方法,完成对成员变量(类的属性)的赋值
public Dog(String strain,String color,int age,String name){
this.strain = strain;
this.color = color;
this.age = age;
this.name = name;
}
//无参数构造方法
public Dog(){
}
//类的属性定义(成员变量)
String strain;
String color;
int age;
String name;
//类的方法，
public void jiao(){
System.out.println(this.name + ": \t汪汪汪.......");
}
//类的方法
public void show(){
System.out.println("品种:"+ this.strain + "\n颜色："+ this.color + "\n狗龄："+ this.age + "\n名字：" + this.name );
}
}
//测试类
class DogTest{
public static void main(String[] args){
//测试有参构造方法创建实例
System.out.println("============有参数构造方法 创建的中华田园犬===============");
Dog d = new Dog("中华田园犬","黄",2,"旺财");
d.show();
d.jiao();
//测试无参数构造方法创建实例
System.out.println("============无参数构造方法 创建的默认狗===============");
Dog d2 = new Dog();
d2.show();
d2.jiao();
}
}
6-6 变量按数据类型分类：
---基本数据类型变量，在内存中存放真正的值。4大类 8种
---引用数据类型变量，在内存中存放地址(引用) 如String 自定义类型变量
引用类型数据变量
6-7 空指针异常
实例化一个类，然后赋值为null。再调用报错：
Dog d2 = new Dog();
d2.show();
d2.jiao();
System.out.println("=================狗=null; 再 show()报空指针异常========================");
d2 = null;
d2.show();
6-8 封装：this关键字
目的：避免不符合实际意义的【成员变量赋值】
关键步骤：
1、将类属性设置为 private 私有的 (类中的)，只能在当前类中使用
2、编写对应属性的赋值get和取值get方法
注意：
this关键字代表当前对象
this可以访问本类/父类中的实例方法
this(参数列表...)对构造方法复用，访问本类中的其他构造方法，而且必须必须在构造方法中的第一条语句
----否则出现递归调用。
6-9 对象作为参数传递。
对象的值被改变则原始值也被改变
测试代码：
class Student{
String name;
int age;
public Student(){}
public Student(String name, int age){
this.name = name;
this.age = age;
}
}
//引用对象进行赋值，实际是将内存地址进行赋值，两个对象实际是一个。
class StudentTest{
public static void change(Student s,String name){
System.out.println("改变对象 s.name " + s.name +"===>" + name);
s.name = name;
}
public static void main(String[] args){
Student stu = new Student("小赵",23);
System.out.println("stu.name = " + stu.name);
change(stu,"小唐");
System.out.println("stu.name = " + stu.name);
}
}
6-10 static 干啥的？
多个对象，有重复的属性&值相同，则只需要存储一次，所有对象中都可以直接访问。
代码中如何编写？
答：【使用static 修饰】
例如：static String address = "北京"; //静态属性将放到“方法区”当中
特点：
---【静态属性】
1、所有对象都可以访问
2、使用static 关键字修饰后是静态属性，也称为类属性
3、静态属性与类同生死
4、访问静态属性：以下方法都可以访问
类名.属性名称
引用名称.属性名称
(含引用名称 = null场景)
5、类优先于对象
---【静态方法】也叫做类的方法
静态方法访问：
类名.方法名称(参数列表)
对象.方法名称(参数列表)
---【静态方法中只能使用静态属性和静态方法】
---非静态方法：可以访问静态属性和静态方法，也可以访问实例属性和实例方法
6、static{}静态代码块
//静态代码块对静态属性赋值
static{
address = "北京市";
System.out.println("执行了静态代码块");
}
//测试静态代码块赋值过程
Student s2 ; //作为类型时没有执行静态代码块
//s2 = new Student();//实例化时执行了静态代码块
System.out.println(Student.address); //或者被调用
7类的继承
修饰符 class 子类名 extends 父类名{
}
自定义类默认隐藏式继承了Object类
class Cat {
...
}
等价于如下
class Cat extends Object{
.........
}
注意：
1、没指定继承哪个父类，默认继承Object
2、在Java中Object类是所有类的父类
3、子类继承父类时，不能继承父类的构造方法【这一点不如Python】
4、父类叫做基类，子类叫做派生类
5、满足条件is a
6、一个类只能继承一个直接父类
7、类继承具有传递性。
7-1 重写父类方法
---子类的方法名、参数列表、修饰符一致
---子类的返回类型一致或父类方法返回类型的子类型：
例如：String 是Object的子类型
int 是 Double的子类型
注意事项：
1、super.方法/变量。直接访问父类的资源
2、如果不写，默认为访问本类中资源即隐含了this.
3、如果子类重写父类的方法体中，有调用被重写的方法，则只能使用super
4、访问父类中的实例变量可以是this. 也可以是super. 但是范围子类独有的实例变量/方法 只能用this
5、super(); super([参数列表])完成对父类构造方法赋值
7-2 父类中含有构造方法
在子类中重写
public 类名([参数列表]){
完成对成员变量赋值;
super(参数); //完成对父类构造方法赋值
}
示例代码：
class Persion{
String name;
char sex;
int age;
//无参构造
public Persion(){}
//有参构造
public Persion(String name, char sex, int age){
this.name = name;
this.sex = sex;
this.age = age;
}
public void sayHi(){
System.out.print("Hi 大家好！我的名字:" +this.name+ "\t性别：" + this.sex + "\t年龄："+ this.age );
}
}
class Student extends Persion{
//子类特有属性
int id;
String grade;
//子类的无参构造方法，执行父类无参构造
public Student(){
super();
}
public Student(String name, char sex, int age, int id, String grade){
//执行父类构造方法
super(name,sex,age);
//对子类特有属性赋值
this.id = id;
this.grade = grade;
}
//重写父类方法
public void sayHi(){
super.sayHi();//调用父类的方法
System.out.println("\t学号：" + this.id + "\t班级：" + this.grade);//合并自己的特有输出
}
}
class StudentTest{
public static void main(String[] args){
Student s = new Student();
s.sayHi();
Student s2 = new Student("唐东",'男',22,1234,"金山班");
s2.sayHi();
}
}
7-3 实例化子类过程中发生了什么？
子类名obj = new 子类();
执行了父类对应构造
如果不执行super(name,sex,age)，而子类构造方法中直接执行对父类的成员变量赋值，例如如下：
/*this.name = name; 则默认会执行super()父类无参构造一次
则：需注意,构造方法无参的无用也要写上避免出现错误
7-4 多态特性 (向父类转型)
语法：
父类类名 引用名称 = new 子类类名();
注意，引用名称.只能访问父类的实例属性和实例方法，如果子类重写了父类的方法，则优先访问子类的方法。
效果：多个对象，调用同一个方法，输出不同的结果
Vehicle v = new Car();
System.out.println("小汽车默认租金"+ v.getSumRent(1));
v = new Bus();
System.out.println("大汽车默认租金"+ v.getSumRent(1));
满足条件：
子类必须继承父类
子类必须重写父类方法
满足语法: 子类类名 引用名称 子类类型
典型示例代码：
//宠物类，作为父类，都会吃
class Pet{
public void eat(){
System.out.println("宠物正在吃东西....");
}
}
class Dog extends Pet{
public void eat(){
System.out.println("正在吃狗粮");
}
}
class Cat extends Pet{
public void eat(){
System.out.println("正在吃猫粮");
}
}
//各种宠物吃的不同...省略
class Master{
public void feed(Pet pet){
pet.eat();
}
}
class MasterTest
{
public static void main(String[] args){
Master m = new Master();
Cat c = new Cat();
Dog d = new Dog();
//效果，主人直接用一个喂方法喂不同的宠物。
m.feed(c);
m.feed(d);
}
}
向子类强制转型(父类创建对象，引用子类变量/方法)：
语法：子类类型 引用名称 = (子类类型) 父类对象
示例
Pet c = new Cat();
Cat c1 = (Cat)c ;
c1.catching();
7-5 抽象类
使用abstract 修饰的类就是抽象类，方法抽象，则所在类必须为抽象类
子类继承了抽象类，必须重写抽象类的方法，否则子类也要定义为抽象类
抽象类不能失礼话对象，抽象类定义的引用(变量)需要复制子类对象胡总匿名内部类对象
抽象类虽然不能实例化对象，但是有构造方法，可以再抽象类中定义失礼方法，静态变量，静态方法，实例变量
//抽象方法，只有方法声明，没有方法体，抽象方法所在的类必须为抽象类
举例： public abstract void eat();
7-6 匿名内部类对象：
抽象类名 引用名称 = new 抽象类名{
@Override
public void eat(){
抽象方法体....
}
}
注意：
抽象
8 接口
定义方法：
[修饰符] interface 接口名 {
功能用方法表示，接口洪方法默认 public abstract 修饰
}
示例代码：
//Flyable.java
package interfaces;
public interface Flyable {
//定义一个接口，功能用方法描述 默认public abstract
void fly();
}
使用接口方法
[修饰符] class 类名 implements 接口 {
类实现了接口，需要重写接口的抽象方法
}
示例代码
//Plane.java
package interfaces;
public class Plane implements Flyable {
//重写接口的抽象方法
@Override
public void fly() {
System.out.println("飞机在天上飞");
}
}
//Bird.java
package interfaces;
/*
小鸟有飞行功能，消息实现Flyable接口
需要重写接口的抽象方法
*/
public class Bird implements Flyable {
@Override
public void fly() {
System.out.println("小鸟会飞");
}
}
//测试类
//Test.java
package interfaces;
public class Test {
public static void main(String[] args) {
//接口是引用数据类型，不能实例化对象
//Flyable f = new Flyable();
//【接口引用需要赋值实现类对象】
Flyable b = new Bird();//通过接口引用调用抽象方法时，实际执行的是实现类对象的方法，实际是多态
b.fly();
Flyable p = new Plane();
p.fly();
//也可以实现匿名类对象使用
new Flyable() {
@Override
public void fly() {
System.out.println("猪在飞");
}
}.fly();
//f.fly();
}
}
接口注意：
//接口引用赋值实现类对象
//接口中的字段默认为认public static final 修饰 所以调用直接使用接口名称调用
//接口的静态方法只能直接通过接口名称调用
//default方法没有是用static修饰只能通过对象访问
示例代码：
//Myinterface.java
package interfacecontent;
public interface MyInterface {
//接口中 方法默认public abstract 修饰
void m1();
//接口中字段，默认public static final 修饰
int xx = 123;
//在JDK8 中可以定义static 静态方法
static void sm(){
System.out.println("在JDK8 中可以定义静态方法");
}
default void dm(){
System.out.println("在JDK8 中可以定义default 方法，在实现类中可以重写，可以不重写");
}
}
//Myclass.java
package interfacecontent;
public class Myclass implements MyInterface{
//实现类中必须重写接口的抽象方法：static 和 default方法除外
@Override
public void m1() {
System.out.println("重写了接口的抽象方法");
}
}
//Test.java
package interfacecontent;
//使用接口的抽象方法
public class Test {
public static void main(String[] args) {
//
MyInterface m = new Myclass();//接口引用赋值实现类对象
m.m1();//通过接口引用调用抽象方法，实际执行的是实现类对象的方法
//接口中的字段默认为认public static final 修饰 所以调用直接使用接口名称调用
System.out.println(MyInterface.xx);
//接口的静态方法只能直接通过接口名称调用
MyInterface.sm();
System.out.println(Myclass.xx);
//default方法没有是用static修饰只能通过对象访问
m.dm();
}
}
8-1 接口说明：
1、接口可以简单看做功能的封装，功能用方法表示，接口中方法默认public abstract 修饰
2、类实现了接口，扩展接口功能，需要重写接口的抽象方法，如果没有重写，则该类需要定义为抽象类
3、接口是一种引用数据类型，单接口不能实例化对象，接口的引用赋值实现类对象或者匿名内部类对象，通过接口引用嗲用抽象方法时，实际执行的是实现类对象的方法 也叫接口多态
4、接口内容：接口方法 默认public abstract 修饰，接口字段(属性)默认public static final 修饰
5、在JDK8中，接口还可以定义static 静态方法和 default 方法. 静态方法与default方法主要用于接口功能的扩展上。
6、接口支持继承，并且支持多继承
public interface RunnableFuture<V> extends Runnable,Future<V>{}
7、一个类在继承父类的同事可以实现多个接口，需要重写所有接口的所有抽象方法
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.ioSerializable {}
8-2 接口和抽象类的区别
相同点：
都可以定义抽象方法
都不能实例化对象
不同点；1、接口 是功能的封装，解决对象能干什么；抽象类是事物的抽象，解决对象到底是什么；
2、内容不同，接口
抽象类含构造方法、实例变量实例变量/方法，静态变量/方法
3、接口支持多继承，类只允许单继承
4、扩展功能优先选择接口
8-3 接口的应用
1)封装某个功能
2)或者看做一组操作规范
3)某种程度上可以解决类的多继承问题
【提倡面向接口编程】
1、接口使用灵活，一个类在继承父类同时，可以实现多个接口
2、面向接口编程可以体现面向抽象思想，降低类的偶合度。
3、接口可以使项目分层，实现代码的可插拔
8-4 类与类之间的关系
用类图表示
是一种UML图 ()
继承：子类继承父类。
实现：类实现了接口
依赖：在A类中使用B类定义方法返回值类型，参数类型，局部变量类型，称为A类依赖B类。
比如A类中写了一个方法，方法中的形参为B类对象
关联：在A类中使用B类定义了成员变量，称为A类关联B类
聚合：在A类中包含了若干的B类，但是A类不能决定B的生命周期，称A类为聚合类
例子：公司和员工的关系