java基础(Study notes)
Posted 再吃一个橘子
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java基础(Study notes)相关的知识，希望对你有一定的参考价值。
我决定了要成为海贼王便要为此而战，我必须变的更强。———路飞
此阶段大致梳理Java核心基础知识点，旨在明晓语法基础的同时透彻领悟Java的思想方法，为后续精益求精，Java进阶做铺垫
目录
1.用面向对象的思想模拟<<海贼王>>中索隆上阵杀敌的技能:
学到这很棒啦！！记得回顾总结Lesson16~38面向对象章节哟
JAVA基础学到这基本上完成，后续此内容需要补充的会不定时滚动补充，也欢迎各位大佬留言指正。
Lesson1(变量和-int)
*变量
电话号码：
仇某:18852525252
仇某:19263636363
�0�2
变量:就是可以发生改变的量
变量的意义:把程序运行过程中产生的值，保存起来，方便后面使用
�0�2
变量的声明:
数据类型 变量 = 值
�0�2数据类型:人对数据进行分类，告诉计算机可以执行的操作
�0�2
java的数据类型:
1.int 整数
2.double 小数
3.boolean布尔值
4.String字符串
�0�2
-int
public class Lesson1 {
public static void main(String[] args) {
/* //先声明一个变量
int a = 10;
System.out.println(a);//10
a = 20;//a前面不能再写int,此处是使用变量
System.out.println(a);//20
*/
int a = 10;
int b = 20;
System.out.println(a + b);
System.out.println(a - b);
System.out.println(a * b);
System.out.println(a / b);//如果运算两端都是int，结果就是int，整除 10 / 20 = 0......10
System.out.println(a % b);//计算余数
System.out.println(10 % 3);//10个苹果平均分给3个小朋友，最后剩几个？
}
}
int 整数：数学的算术运算
+�0�2 �0�2-�0�2 *�0�2 /�0�2 %
%计算余数
Lesson2(-double)
-double
(1)double类型的操作基本和int类型一样，不同的是double计算的结果一般是double类型
(2) = 是赋值操作，把等号右边的结果赋值给等号左边的变量
public class lesson2 {
public static void main(String[] args) {
double price = 1.25;
System.out.println(price);
price = price + 0.6;//=表示赋值
System.out.println(price);
double total = price*2;//double类型的计算，得到的一般都是double类型，若定义为int total = price*3；则报错
System.out.println(total);
}
}
Lesson3(-boolean)
-boolean
这个世界，不光有数字，文字等这些东西，还有一种东西，它表示状态。
在计算机里，则用boolean表示状态
�0�2
boolean布尔值，保存的是一个状态，成立(ture),不成立(false)
取值范围:
ture成立->真
false不成立->假
命题：真命题，假命题
boolean布尔值主要用来做条件判断的
public class lesson3 {
public static void main(String[] args) {
double money = 1000;
double price = 20000;
System.out.println(money > price);//false
System.out.println(money < price);//ture
//= 是赋值，不是数学上的判断
//==条件判断，判断等号左右两端值是否相等
System.out.println(1000 == 1000);//ture
System.out.println(1000 == 999);//false
}
}
Lesson4(-String)
-String
在Java里字符串String里S是大写，在Java中用“ ”表示字符串
字符串拼接
public class lesson4 {
public static void main(String[] args) {
//字符串的拼接
String s1 = "周杰伦";
String s2 = "昆凌";
System.out.println(s1 + s2);//+ 两端只要有一个是字符串，最终都会实现字符串的拼接--->周杰伦昆凌
System.out.println(1 + 1 + s1);//从左到右，先算数字1+1，得2，再用2和s1拼接
}
}
public class lesson4 {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("a + b = "+ a + b);//a + b = 1020
System.out.println("a + b = "+ (a + b));//a + b = 30
//运算过程和数学上一样，从左到右，先算括号
}
}
�0�2
字符串可以执行+操作，表示字符串的拼接
字符串的拼接注意点：
(1)+ 两端只要有一个是字符串，最终都会实现字符串的拼接
(2)字符串运算过程和数学上一样，从左到右，先算括号
Lesson5(-用户输入)
-用户输入
Scanner：扫描器
Scanner是JDK提供的一个类，在 Java中用的时候要导包(两种方式)：
(1)import java.util.Scanner;
(2)光标停在输入的Scanner上，Alt+回车
�0�2
先创建扫描器-->记住要导包：alt+回车
Scanner sc = new Scanner(System.in);获取数据：
sc.nextInt();//整数类型
sc.nextDouble();//小数类型
sc.nextLine();//字符串类型�0�2
�0�2
参照程序：
import java.util.Scanner;
public class lesson5 {
public static void main(String[] args) {
//1.创建一个扫描器
Scanner sc = new Scanner(System.in);
//2.使用扫描器获取到用户输入的内容
int a = sc.nextInt();//获取到整数
System.out.println(a+1);//控制台出来等待输入界面，例如：输入666，出来667
double d = sc.nextDouble();//获取到小数
System.out.println("d = "+d);//控制台出来等待输入界面，例如：输入666，出来d = 666
String s = sc.nextLine();//获取到字符串
System.out.println(s);//控制台出来等待输入界面，例如：输入周杰伦，出来周杰伦
}
}
�0�2
《小小计算器》：
要求用户输入两个数：a,b，程序自动输出a + b的值
import java.util.Scanner;
public class lesson5 {
public static void main(String[] args) {
//1.创建一个扫描器
Scanner sc = new Scanner(System.in);
//2.使用扫描器获取到用户输入的内容
int a = sc.nextInt();
int b = sc.nextInt();
System.out.println("a + b = "+(a+b));//控制台出来等待输入界面，例如：输入1 3 ，输出a + b = 4
}
}
Lesson6(-if)
-if语句
�0�2
用来做条件判断的
if语句的语法:
if(条件){
�0�2 �0�2 �0�2xxxxxx
}
逻辑：
判断条件是否为真(ture)，就去xxxxxx
�0�2
import java.util.Scanner;
public class lesson6 {
public static void main(String[] args) {
System.out.println("告诉我你兜里的钱：");
Scanner sc = new Scanner(System.in);
//获取到钱
double money =sc.nextDouble();
//买手办要用的钱
double price = 100;
if(money > price)
{
System.out.println("你可以去买手办了！！");
}
System.out.println("学习！！");
}
}
/*告诉我你兜里的钱：
88
学习！！
*/
/*告诉我你兜里的钱：
999
你可以去买手办了！！
学习！！
*/
if-else语句
if(条件){
�0�2 �0�2 �0�2xxxxxx
}
else{
�0�2 �0�2 yyyyyy
}
逻辑：
如果条件为真，则xxxxxx，否则yyyyyy
import java.util.Scanner;
public class lesson6 {
public static void main(String[] args) {
System.out.println("告诉我你兜里的钱：");
Scanner sc = new Scanner(System.in);
//获取到钱
double money =sc.nextDouble();
//买手办要用的钱
double price = 100;
if(money > price)
{
System.out.println("你可以去买手办了！！");
}
else{
System.out.println("你攒钱了！！");
}
System.out.println("学习！！");
}
}if-else多条件分支语句
if(条件1){
�0�2 �0�2 �0�2 xxxxxx
}else if(条件2){
�0�2 �0�2 �0�2yyyyyy
}else if(条件3){
�0�2 �0�2 �0�2zzzz
}else {
�0�2 �0�2 �0�2nnnnnn
}
逻辑：
判断条件1是否成立，如果成立，执行xxxxx，否则如果条件2成立，执行yyyy，否则如果条件3成立，执行zzzz，若都不成立，则最终执行nnnnnnn
从上到下判断，一个条件成立则执行完就跳出，后面不再执行
Lesson7(-while循环)
-while循环
在Java中一共提供了3种循环：
1.while循环
2.for循环
3.do-while循环
while循环
while(条件){
�0�2 �0�2 �0�2 �0�2xxx(循环体)�0�2
}
循环逻辑：
判断条件是否为真，如果条件真，执行循环体，再次判断条件是否为真，如果条件为真，继续执行循环体。
public class lesson7 {
public static void main(String[] args) {
/*
//死循环
while(ture) {
System.out.println("滚去学习！");
}
*/
//改变条件：喊10次
int i = 1;
while(i <= 10) {
System.out.println("滚去学习！");
i = i + 1;
}
}
}
/*滚去学习！
滚去学习！
滚去学习！
滚去学习！
滚去学习！
滚去学习！
滚去学习！
滚去学习！
滚去学习！
滚去学习！
*/�0�2
习题-1
�0�2使用本章学习的知识点，完成猜数游戏
首先，我得先给出各位一段代码，这段代码可以帮我们产生一个随机数
Random rd = new random();
int n = rd.nextInt(100);//n是一个随机数，范围是[0，99]
System.out.println(n);//打印看看
OK，我们可以产生随机数了，剩下的请看要求：
让用户输入一个数字a，判断用户输入a与n之间的关系：
1.如果用户猜大了.提示 猜大了.继续猜.
2.如果用户猜小了.提示 猜小了.继续猜.
3.如果用户猜对了.提示 猜对了.结束循环.
�0�2
import java.util.Random;
import java.util.Scanner;
public class Homework1 {
public static void main(String[] args) {
Random rd = new Random();
int n = rd.nextInt(100);//n是一个随机数，范围是[0，99]
System.out.println(n);//打印看看
boolean flag = true;
while(flag) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个数字：");
int a = sc.nextInt();
//判断
if(a > n) {
System.out.println("对不起，猜大了！");
}
else if(a < n){
System.out.println("对不起，猜小了！");
}
else {
System.out.println("恭喜你，猜对了！");
flag = false;
}
}
}
}
�0�2
Lesson8(基本数据类型详解_)
1.基本数据类型详解_整数
(1)byte是在Java程序中最小的数据单元，8bite�0�2 �0�2 �0�2-128~127之间
(2)int�0�2 �0�2整数�0�2 �0�232bit�0�2 4byte�0�2 �0�2 �0�2-21亿~21亿之间
(3)short�0�2 短整数�0�2 16bit�0�2 2byte�0�2 �0�2 �0�2 �0�2-32768~32767之间
(4)long�0�2 �0�2长整数�0�2 �0�2 64bit�0�2 8byte�0�2 �0�2�0�2
public class Test1 {
public static void main(String[] args) {
byte score = 90;
System.out.println("小学数学："+score);
short gaokao_score = 387;
System.out.println("高考分数："+gaokao_score);
int people_num = 1300000000;//13亿
System.out.println("我国人口有："+people_num);
long people_world = 6000000000L;//60亿 长整数一般数字最后用L结尾
System.out.println("全国人口有："+people_world);
}
}
注意：long长整数类型�0�2 �0�2 一般数字最后用L结尾
2.基本数据类型详解_小数
(1)double 64bit 8byte�0�2 双精度小数，精度高，准确性高
(2)float�0�2 32bit�0�2 �0�24byte�0�2 �0�2单精度小数
public class Test2 {
public static void main(String[] args) {
float a = 0.1234567890123456f;
System.out.println(a);//输出0.12345679 最多保留小数点后8位
double b = 0.1234567890123456789;
System.out.println(b);//输出0.12345678901234568 最多保留小数点后17位
}
}
注意：(1)float类型�0�2 一般数字最后用f结尾
�0�2 �0�2 �0�2 �0�2 �0�2 �0�2(2)float类型�0�2 最多保留小数点后8位
�0�2 �0�2 �0�2 �0�2 �0�2 �0�2(3)double类型�0�2 最多保留小数点后17位
3.基本数据类型详解_字符
字符：单一的文字符号
char�0�2 �0�2 16bit�0�2 �0�2unicode标准(万国码)
char类型可以存放数字，存放的数字实际上是字符
public class Test3 {
public static void main(String[] args) {
char a = '爱';//必须是单一字符，必须用单引号引起来
System.out.println(a);
char b = 20210;
System.out.println(b);
}
}
注意：char类型中�0�2 �0�2必须是单一字符，必须用单引号引起来。
4.基本数据类型详解_boolean
boolean
取值范围：true�0�2 �0�2false
8bit�0�2 �0�21byte
5.基本数据类型小结
整数：
1.byte�0�2 �0�2 字节�0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 8bit
2.short�0�2 �0�2短整数�0�2 �0�2 2byte�0�2 �0�2 16bit
3.int�0�2 �0�2 �0�2 �0�2整数�0�2 �0�2 �0�2 �0�24byte�0�2 �0�2 �0�232bit
4.long�0�2 �0�2长整数�0�2 �0�2 8byte�0�2 �0�2 �0�264bit
小数：
1.float�0�2 �0�2 �0�2 �0�2 单精度小数�0�2 �0�2 4byte�0�2 �0�2 32bit
2.double�0�2 �0�2 双精度小数�0�2 �0�28byte�0�2 �0�2 �0�264bit
字符：
char单一文字符号�0�2 �0�2 �0�22byte�0�2 �0�216bit
必须用单引号括起来
布尔：
boolean�0�2 在计算机中�0�2 1byte�0�2 8bit
true�0�2 �0�2false
6.基本数据类型转换
(类似于：大杯子小杯子装水)
int�0�2 �0�2 �0�2 �0�24byte�0�2 �0�2 32bit
long�0�2 �0�2 8byte�0�2 �0�2 64bit
顺序：数据量的大小
byte->short，char->int->long->float->double
小数据类型->大数据类型：安全的，直接转化
大数据类型->小数据类型：不一定安全，可能会出现溢出，必须强转
(转换之后的数据类型) 变量
public class Test4 {
public static void main(String[] args) {
int a = 10;
long b = a;//安全的
System.out.println(b);
long c = 10000000000000L;
int d = (int) c;
System.out.println(d);//如果程序产生溢出，程序就不可控了，则结果毫无意义
}
}
7.基本数据类型之间的运算
1.相同数据类型之间：
相同数据类型之间运算，结果一定是该数据类型
int�0�2 +�0�2 int�0�2 =�0�2 int
int a = 3;
int b = 6;
System.out.println(a/b);//还是int型2.不同数据类型之间：
int + long = long
首先把小的数据类型自动转换成大的数据类型，然后再进行运算，得到的结果一定是大的数据类型
int a = 43;
long b = 20;
long c = a + b;//若定义成int类型，会报错
System.out.println(c);
3.特殊的byte，short，char
在计算的时候，首先会转换成int类型再进行运算，这样是安全的
byte + byte = int
结果至少是 int
byte a = 10;
byte b = 10;
int c = a + b;//若定义成byte类型，则容易超过byte范围，报错
System.out.println(c);short s1 = 1;
//short s2 = s1 + 1;//程序会报错：数据类型不匹配
short s2 =(short)(s1 + 1);//强制转换
System.out.println(s2);�0�2
Lesson9(_break和_continue)
while(条件){
�0�2
}
�0�2
for(;条件;){
�0�2
}
除了改变while，for循环里的条件以外，还有有其他方式可以让循环停止吗？
—>break�0�2 �0�2 �0�2�0�2
—>continue
�0�2
break :
终止，终止一个循环的执行
continue：
中断，停止当前本次循环，继续执行下一循环
�0�2break �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2
public class lesson9 {
public static void main(String[] args) {
for(int i=1;i<=20;i++){
if(i==10) {
break;//彻底终止循环
}
System.out.println(i);
}//
}
}
continue
public class lesson9 {
public static void main(String[] args) {
for(int i=1;i<=20;i++){
if(i==10) {
continue;//打印时跳过i=10，其他照常打印
}
System.out.println(i);
}//
}
}
�0�2
Lesson10(_数组)
数组：具有相同数据类型的集合
java中数组：
类型[ ] 数组名 = new 类型[大小]；
类型[ ] 数组名 = {数据，数据，数据....}
类型[ ] 数组名 = new 类型[ ]{数据，数据，数据.....}
怎样用数组：
数组必须配合数组的小标使用
数组的小标从0开始
�0�2
如何查看数组中所有的数据：
�0�2 �0�2 �0�2 �0�2 �0�2 �0�2 数组的遍历
length表示数组的长度
for(int i=0;i<arr5.length;i++) {//arr5.length表示数组中有多少个数据 —>数组的长度
System.out.print(arr5[i]);
}public class lesson10 {
public static void main(String[] args) {
int[] arr1 = new int[5];
int[] arr2 = {33,23,42,66,87};
int[] arr3 = new int[] {33,23,42,66,87};
int[] arr4 = {45,87,90,42};
System.out.println(arr4[1]);//通过下标获取第2位置的数字 —>87
arr4[1] = 88;//通过下标修改数组中的数据
System.out.println(arr4[1]);//—>88
int[] arr5 = {33,87,96,20,18};
for(int i=0;i数组的长度
System.out.print(arr5[i]);
}
}
}
�0�2
Lesson11(_方法的概述)
方法：
1.打开电脑
2.打开B站
3.点开up猪视频儿
4.下次一定
�0�2
通俗：多次用到这个步骤，次数多了重复的步骤太多，又不能用循环(循环在程序存在时时会用到)，而我们打开电脑不是只干这一件事，所以不适合用循环，而我们想要的是，想看的时候才去打开B站，我们把这一件事情拿出来整理成一套方案，只在需要的时候拿出来运行一下，这就是方法。
�0�2
方法：对功能或动作的封装，在需要的时候调用
�0�2
Lesson12(_方法的定义)
方法的定义：
public static void 方法名(){
�0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2方法体
}
方法的调用：
方法名()；
�0�2
public static void 先照着写
方法体：这件事到底应该怎么做
注意：不可以在方法里定义方法
public class lesson12 {
/*
* 定义一个方法“看”
* 只是定义方法，还没有调用
*
*/
public static void kan() {
System.out.println("1.打开电脑");
System.out.println("2.打开B站");
System.out.println("3.点开up猪视频儿");
System.out.println("4.下次一定");
}
//主方法，主函数，程序的入口
public static void main(String[] args) {
System.out.println("我要看上B站看视频！");
kan();//调用方法
System.out.println("白嫖真香！！！！！！");
}
}
�0�2
Lesson13(_方法的返回值)
返回值：执行方法之后得到的结果
public�0�2 static�0�2 返回值类型�0�2 方法名(){
�0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2方法体
�0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 return�0�2 值；
}
注意：
- 返回值类型与返回值必须匹配
- 如果写了返回值类型就必须写返回值、
- 如果写了返回值就必须写返回值类型
- 没有返回值，返回值类型要写void，方法体里可以不写return或者return后面不跟返回值
- return 之后不可以再写代码了
以上5点都要遵守
public class lesson13 {
public static String buy() {
System.out.println("我要去买烟了！！");
//需要用return进行返回值
return "中华香烟";
}
public static void main(String[] args) {
//buy();//没有接收返回值
//返回值返回给调用方法
String yan = buy();//接收返回值
System.out.println("得到的返回值是"+yan);
}
}
�0�2
Lesson14(_方法的参数)
参数：在方法执行的时候，给方法传递的信息
public static void 方法名(形参){
�0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 �0�2 方法体
}
�0�2
方法名(实参)；
形参：接收数据
实参：传递数据
单向传递：实参—>形参
注意：
- 在方法中可以有多个参数
- 参数的个数必须匹配
- 参数的数据类型必须匹配
public class lesson14 {
public static void kan(String tools,int num) {
System.out.println("1.打开"+tools);
System.out.println("2.打开B站");
System.out.println("3.点开up猪"+num+"视频儿");
System.out.println("4.下次一定");
}
public static void main(String[] args) {
//用手机打开一次B站，再用电脑打开一次B站
kan("手机",1);
kan("电脑",2);
}
}
�0�2
习题2(_方法练习)
1.写方法，给方法传递两个整数a，b，返回a和b中比较大的那个数
2.写方法，把传入的数组翻转并返回
(注意点：方法的参数，方法的返回值)
第一题：
public class Test5 {
public static int compare(int a,int b) {
if(a > b) {
return a;
}
else{
return b;
}
}
public static void main(String[] args) {
//int c = compare(1,6);
//System.out.println(c);
System.out.println(compare(1,6));//变量c只用一次，没必要专门定义
}
}
还可以中间if语句换成三目表达式，三目运算符：�0�2x?y:z
if(a > b) {
�0�2�0�2 �0�2�0�2�0�2 �0�2return a;
�0�2�0�2 �0�2}
�0�2�0�2 �0�2
�0�2�0�2 �0�2else{
�0�2�0�2 �0�2�0�2�0�2 �0�2return b;
�0�2�0�2 �0�2}
改后：
int m = (a > b) ? a:b;
return m;
第二题：
public class Test6 {
public static int[] reverse(int[] arr) {
//返回的是一个数组
int[] ret = new int[arr.length];
//0 1 2 3 4
//22 5 78 16 9
int index = 0;//ret数组的下标
for(int i = arr.length - 1;i >= 0;i--) {//反着拿数据
ret[index] = arr[i];//正着往里装
index++;
}
return ret;
}
public static void main(String[] args) {
int[] a = {22,5,78,16,9};
int[] b = reverse(a);
for(int i = 0;i < b.length;i++) {
System.out.println(b[i]);
}
}
}
�0�2
Lesson15(_方法的重载)
重载：方法的名字相同，参数的个数或者类型不同
和返回值没有关系
在执行的时候，程序会自动根据你的参数去找对应的方法，执行
�0�2
重载的作用：让我们省去起名字的烦恼(做大型项目的时候，起名字是个问题)
public class lesson15 {
//吃
public static void chi(String fan) {
System.out.println("吃"+fan);
}
public static void chi(String fan,String cai) {
System.out.println("吃"+fan);
System.out.println("吃"+cai);
}
public static void main(String[] args) {
chi("大米饭");
chi("小米饭");
chi("米饭","花菜");
}
}
测试：计算a + b的和
public class Test7 {
public static void add(int a,int b) {
System.out.println("这是int类型");
System.out.println(a + b);
}
public static void add(double a,double b) {
System.out.println("这是double类型");
System.out.println(a + b);
}
public static void main(String[] args) {
add(1,2);
add(1.2,3.6);
}
//——>结果
/*这是int类型
*3
*这是double类型
*4.8
*/
}
�0�2
Lesson16(_面向对象概述)
本章要学的相对重要的知识点：
- 类与对象
- 构造方法
- 访问权限
- 继承
- 多态(最重要)
- 抽象与接口
- 内存分析
这几个知识点相对重要，其他未罗列的也重要
�0�2
Lesson17(_面向过程和面向对象)
面向对象：侧重的是过程
优点：想起来简单，写起来也简单
缺点：代码量大的时候，维护成本高，可维护性差
�0�2
面向对象：侧重的是对象。上帝视角：创建一个大象，告诉大象你要进冰箱( 具体怎么进不管！)
优点：可扩展性非常强，维护成本低
缺点：新手上手难
�0�2
Lesson18(_类与对象)
造车：
1.画图纸
(1)定义车的属性信息：color，speed，seat
(2)定义车的动作：跑
2.拿着图纸找工厂生产车
�0�2
面向对象的世界里：
类：就是图纸
属性：这一类事物拥有的共同属性
动作：这一类事物共同能执行的功能
对象：使用类创建的具体的某个东西
�0�2
对象能干什么?�0�2 完全取决于类是如何定义的
�0�2
写代码：
类要使用class来定义
属性：用成员变量来描述，直接写在类中的变量
动作：就是成员方法，不写static就是成员方法
public class Car {
//成员变量
String color;//颜色
int speed;//速度
int seat = 5;//座位
//成员方法
public void run() {//——>动作：成员方法，不写static就是成员方法
System.out.println("车能跑");
}
public static void main(String[] args) {
//int a = 10;//写在方法里的变量，称为局部变量
//创建对象:——> 类 引用 = new 类();
//int a = 10;
//在面向对象的世界里，变量是没有市场的，这种变量称为引用
//在java中数据类型分为两种：1.基本数据类型 2.引用数据类型——>String和我们创建的所有类
Car c = new Car();//创建对象， 创建了一辆车，后面想用这辆车，就需要用c来访问
//让车去跑
//对象或者引用.方法();
c.run();//.表示调用“ . ” ——> “的”
c.color = "绿色";
c.speed = 120;
//c.seat = 5;
//c.pailiang = 1.5;//类中没有定义的内容不可使用
System.out.println(c.color);
Car c2 = new Car();
c2.color = "红色";
c2.speed = 130;
//c2.seat = 5;
System.out.println(c2.color);
System.out.println(c.seat);
System.out.println(c2.seat);
}
}
�0�2
Lesson19(_this关键字)
this：
(1)this当前类的对象
(2)this可以在方法内部获取到对象中的属性信息
(3)this可以区分成员变量和局部变量
�0�2
验证一下this关键字执行过程：
public class Car {
String color;
int speed;
int seat = 5;
public void run() {
//默认会有一个this：当前正在执行这个方法的对象
//想在run()方法里得到车的颜色，速度，但是不想用传参，此时可以用this关键字
System.out.println(this);
System.out.println("车能跑");
}
public static void main(String[] args) {
Car c = new Car();
c.color = "红色";
c.speed = 120;
c.run();//在调用方法的时候，java会自动把对象传递给方法，在方法中由this来接收对象
System.out.println(c);
}
}
//结果如下:
/*Car@2ff4acd0
*车能跑
*Car@2ff4acd0
/
�0�2
this是随动的：
public class Car {
String color;
int speed;
int seat = 5;
public void run() {
System.out.println(this.color);
System.out.println(this.speed);
System.out.println("车能跑");
}
public static void main(String[] args) {
Car c = new Car();
c.color = "红色";
c.speed = 120;
c.run();
Car c2 = new Car();
c2.color = "绿色";
c2.speed = 160;
c2.run();
}
}
//结果
/*红色
120
车能跑
绿色
160
车能跑
*/
变量的查找顺序：先找自己的方法内，如果没有，再去this里面找：
public class Car {
String color;
int speed;
int seat = 5;
public void fly() {
//System.out.println(this.color + "颜色的车会飞");
System.out.println(color + "颜色的车会飞");//此时访问的也是成员变量
//变量的查找顺序：先找自己的方法内，如果没有，就去this里面找
}
public static void main(String[] args) {
Car c = new Car();
c.color = "绿色";
c.fly();
}
}
//结果：
/*
绿色颜色的车会飞
*/�0�2
public class Car {
String color;
int speed;
int seat = 5;
public void fly(String color) {
System.out.println(color + "颜色的车会飞");
//变量的查找顺序：先找自己的方法内，如果没有，就去this里面找
}
public static void main(String[] args) {
Car c = new Car();
c.color = "绿色";
c.fly("黑色");
}
}
//结果：
/*
黑色颜色的车会飞
*/this可以帮我们区分成员变量和局部变量：
�0�2
public class Car {
String color;
int speed;
int seat = 5;
public void fly(String color) {
System.out.println(this.color + "颜色的车飞" + color + "在颜色的云彩里");
//变量的查找顺序：先找自己的方法内，如果没有，就去this里面找
}
public static void main(String[] args) {
Car c = new Car();
c.color = "绿色";
c.fly("黑色");
}
}
//结果：
/*
* 绿色颜色的车飞黑色在颜色的云彩里
*/
�0�2
Lesson20(_构造方法)
构造方法：
在创建对象的时候，自动调用的方法
public 类名(传参){
�0�2
}
注意：1.没有返回值这一项
�0�2 �0�2 �0�2 �0�2 �0�2 �0�22.在我们new的时候，自动调用构造方法
�0�2
最大的作用：在创建对象的时候，给对象设置属性信息
�0�2
java会自动的赠送给每一个类一个无参数的构造方法，如果你自己定义了构造方法，java就不赠送给你了
public class Car {
String color;
int speed;
int seat = 5;
//java会自动的赠送给每一个类一个无参数的构造方法
/*
* public Car() {
*
* };
*/
//如果你自己定义了构造方法，java就不赠送给你了
//在创建对象的时候，自动调用构造方法
public Car(String color,int speed) {
this.color = color;
this.speed = speed;
}
public void run() {
System.out.println(color + "颜色的车在跑" );
}
public static void main(String[] args) {
Car c1 = new Car("绿色",120);//默认调用的是构造方法
//c1.color = "绿色";
//c1.speed = 120;
Car c2 = new Car("红色",160);
//c2.color = "红色";
//c2.speed = 160;
c1.run();
c2.run();
}
}
�0�2
Lesson21(_构造方法的重载)
构造方法也是方法，也可以进行重载
作用：可以有更多的方式去创建对象
�0�2
当几个构造方法里的代码一样的时候，避免重复，可以使用this，来访问其他的构造方法
this( );
习题3(面向对象_练习)
1.用面向对象的思想模拟<<海贼王>>中索隆上阵杀敌的技能:
public class Hero {
String name;
String skill_q;
String skill_w;
String skill_e;
String skill_r;
public Hero(String name) {
this.name = name;
}
public Hero(String name,String skill_q,String skill_w,String skill_e, String skill_r) {
this(name);//调用当前类中的其他构造方法
this.skill_q = skill_q;
this.skill_w = skill_w;
this.skill_e = skill_e;
this.skill_r = skill_r;
System.out.println(this.name = name);
System.out.println(this.skill_q = skill_q);
System.out.println(this.skill_w = skill_w);
System.out.println(this.skill_e = skill_e);
System.out.println(this.skill_r = skill_r);
}
public void fight() {
System.out.println(this.name+"在上阵杀敌！");
}
public static void main(String[] args) {
Hero h = new Hero("索隆","鬼斩" ,"龙卷风","一刀流 居合“狮子歌歌”","三刀流奥义.三千世界");
h.fight();
}
}
//结果——>
/*索隆
鬼斩
龙卷风
一刀流 居合“狮子歌歌”
三刀流奥义.三千世界
索隆在上阵杀敌！
*/
�0�2
2.用面向对象的思维模拟植物大战僵尸:
(稍微复杂)包含:植物,僵尸,场景(客户端)
不一定所有代码都写在一个类里
�0�2
public class ZhiWu {
String name;
int hp;
int attack;
public ZhiWu(String name,int hp,int attack) {
this.name = name;
this.hp = hp;
this.attack = attack;
}
//植物打僵尸
public void fight(JiangShi js) {
System.out.println(this.name + "在打" + js.name);
//僵尸掉血
js.hp -= this.attack;
System.out.println("僵尸的血量剩余" + js.hp);
}
}
public class JiangShi {
String name;
int hp;
int attack;
public JiangShi(String name,int hp,int attack) {
this.name = name;
this.hp = hp;
this.attack = attack;
}
//僵尸吃植物
public void eat(ZhiWu zw) {
System.out.println(this.name + "在吃" + zw.name + "植物");
//植物掉血
zw.hp -= this.attack;
System.out.println("植物的血量剩余" + zw.hp);
}
}
�0�2
public class Client {
public static void main(String[] args) {
//创建植物和僵尸
ZhiWu zw = new ZhiWu("豌豆",1000,5);
JiangShi js = new JiangShi("铁桶僵尸",800,20);
zw.fight(js);
js.eat(zw);
}
}
�0�2
Lesson22(_static静态)
static静态
�0�2
有多人就要改多少次,麻烦!
�0�2
静态的内容在内存中是保留一份的,并且各个对象之间进行共享
使用p1.country = "民 以上是关于java基础(Study notes)的主要内容，如果未能解决你的问题，请参考以下文章 Beginning Scala study note Scala and Java Interoperability [20-04-26][Self-study Notes 12]Java Powerball [20-04-23][Self-study Notes 9]Java Array of Objects