0
提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档
前言
提示:这里可以添加本文要记录的大概内容:
例如:随着人工智能的不断发展,机器学习这门技术也越来越重要,很多人都开启了学习机器学习,本文就介绍了机器学习的基础内容。
提示:以下是本篇文章正文内容,下面案例可供参考
一、基础语法
- 分号、花括号之类的和C语言差不多
- 严格区分大小写
常量:
C: const int a = 4;
java: final static double PI=3.1415;
注意:final 和static 都是修饰词,不分前后
关于switch:
switch (xxx)
{
case "xxx1"{statements();break;}
}
java11 的switch 记得一定要加一个break.
package 包类 比如要用scanf ,就要导入
import java.util.Scanner;//导入scanner包,就类似于include
public class one {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
String a = input.nextLine();
System.out.println(a);
String b = input.next();
System.out.println(b);
}
}
(import 就好比include 导入了后就方便使用很多已有的东西
**方法**,类似于C语言里面的函数
二、使用步骤
1.概念
首先明确一个概念:
数组也是一种数据类型,平行于整型int、浮点数double存在
除了八大基本类型,其他的都是引入类型:数组、类、接口…
java里面的数组和C有相同但也有不同:
先说我觉得的最大不同:内容可以不一样
这主要是java有类 和 继承的概念。
也可以说,不一样是指子类不一样,父类得一样。
—《疯狂java讲义 第四版》
可以理解为:对于数组内容限制放宽了,C语言必须是香蕉。但是JAVA只要提前说好是水果就行
2.初始化
写法和C:
可以相同,但是不提倡:
int a[]虽然也可以,但是据说这样有歧义,让人会认为两个方括号也是数组名字。
所以 java 和后来的一些语言如C# 这样定义:int [] a;先把数组的方括号放在前面
import java.util.Scanner;//导入scanner包,就类似于include
public class one {
public static void main(String[] args){
//静态赋值,就是程序员自己给初始化,穷举
int[] array;
array = new int[10];
//动态赋值,给了大小就别管了
int[] Dynamic = new int[5];
for(int i =0;i<5;i++)
Dynamic[i]=2*i;
for(int i=0;i<5;i++)//遍历输出
System.out.println(Dynamic[i]);
System.out.println(Dynamic.length)//显示长度
for(int temp:Dynamic)
{//foreach遍历,不用你管数组长度
System.out.println(temp);
}
}
}
静态:穷举法加入内容,你写多少,长度就是多少
动态:给长度,但不准一开始加内容
System.out.println(Dynamic.length)
数组名字.length 获取数组长度,类似于strlen()
## 3.引用类型数组 内存 在java内部,八大基本类型和引用类型(比如数组)是不一样的。
int a=10;
int b=a;
//输出b 显示10
int b=20;
//输出a 10、b 20
这是基本类型,很容易理解
但是引用类型就不一样了
a[0]={12};
b[0]=a[0];
//输出a[0]、b[0]都是12
b[0]=20;
重点来了,此时输出 a[0],也是 20!!!
基本类型,各过各的。
引用类型,实际上是互相关系着的。
从哪有关系?—内存
Java里可以简单分为 栈内存、堆内存。
栈比较小,在一个方法里暂时存在;堆内存大,贯穿整个程序都存在。
很明显的看到,数组赋值在内存中的实际情况;
此时修改b的内容,就等同于修改a的内容
失去的引用的就是垃圾,占用内存,等待回收。
类
类:可以理解为按需要给一些东西分类
对象:理论上来说可以是一切事物
修饰符:static、abstract和final 选其一
类名:合法即可
注意事项
构造器就是模板,其他的四个东西到底模板还是具体的东西,就靠static区分。
static 虚、泛,模板、未分化的
非static 具体的例子、高度分化的
所以实的具体的、已经分化的不可能调用虚的
private是私有类,只有类内部可以调用,外部不能进行直接调用
public是公有类,可以根据类的对象直接调用类所拥有的变量(extern)
protected是保护类,只有继承该类的类才可以调用变量
final是最终类型使得变量不可以被修改,也就是所所谓的常量(const)
this
public class person{
public void jump(){XXXX};//先弄出一个方法
public void run(){
this.jump();
};//现在这个第二个方法,需要调用第一个方法,咋办?
}
这里面的this 其实就是自己这个person类,直接把上面出现过的 拿过来用就好了。
而其实也可不加这个this,在一个方法内部,默认这么用就行。
X调用A方法,那么A方法中提到的this 就是X
加了static的方法A,那么就不可以用this代指;
简而言之:要想调用static的东西,就用 模板调用,别用具体实例。
方法加static—所有干细胞的后代都有;不带static,这个具体的特定细胞有的方法
构造器
如果不写,自动带一个
如果写了,就可以初始化以下模板,比模板定好初始内容,不一定全是NULL;
也分为 有参构造、无参构造
当你需要new一个玩意,本质就是调用 构造器
不可以只有参、缺无参。 不想用无参也得留着,否则真的想用了会报错
构造器重载:
可以有俩名字一样的构造器,但是形参列表不同。
this的调用:this(形参列表) 这里是调用重载构造器,到底调用哪个,会根据形参列表自动判断
重点:有(A,B)参数的构造器,以及有(A,B,C)参数的构造器
咋用的?
构造器(A,B,C)
{
this(A,B);这里面的this就是上面那个(A,B)
}
方法重载
一个类里面,方法名可以一样,只要参数表不同;
但是返回值不能区分
变量
实例变量其实也可以反向影响 类,所以定了就别改。
关于static在类和实例的变量
局部变量:
java里面,不仅仅是for这种有代码块的区域限制
简单的花括号、哪怕啥关键字也没,也算一块局部。
{
int a=4;
xxxx
}//在这里a消失了
System.out.println(a);
//这里提示报错,因为a没了
封装
就是把一些东西打包起来
比如person类的年龄,不需要你管,根据年岁增加,每年加一就行了,别乱动。
封起来就是怕你乱动。
访问控制符
- private 内置好了,不允许在外面改
- public 可以在外面改
- protected 子类可以用(尤其是方法)
一个新的java文件里,但凡有一个 class被加了public,那么这个.java必须同名
包
可以理解为 函数库
一个类到底在哪,就要看package 后面的内容AAA.BBB.CCC
那么就必须AAA\BBB\CCC 位置。且这种情况下,AAA文件夹和.java文件同级别
父包使用子包,必须包含全名,不可省略
-import
必须放在package后、类定义前。
可以多个import,但只能一个package
继承
public 子类 extends 父类
{
}
下面这个是父类–水果
这个是子类==水果
要是有个子类特殊点,比如Birds类都可以飞,但是Ostrich鸵鸟不同。
所以要重写父类
重写就是父子类里面方法的说法
重载就是一个类内部 同名方法的说法
super限定
刚才的鸵鸟自己有一个fly,和常规的鸟类不同了。也就是"I can fly"这个内容被覆盖了,但是要是想要拿回来之前的呢?
super关键字可以帮找回来,事实上,你在覆盖父类老内容、加了自己的新内容的时候,不是真的覆盖了,是新开了一段内存而已。所以super等于找回来了老内存
调用父类构造器
可以看出super类似于this,相当于复制了一遍代码下来。
此外,要是子类啥也不说,就默认用父类的隐式构造器。
这是一个三层结构,一步步往回走。
提示:以下是本篇文章正文内容,下面案例可供参考
多态
因为父子类的出现,然后又有了覆盖方法这个东西。
所以导致:
同意一个类型的实例、同一个方法,执行的时候也会体现出多种行为特征—故此称之为多态
向上转型:
父类 p=new 子类();这个是可以的子类对象可以直接赋值给父类变量
向下转型:
父类变量赋值给子类变量,强制转换 (类型)变量名
为何出现多态?
Bird类的fly():“I can Fly!”
鸵鸟的fly()重写了:“I can just walk!”
麻雀的fly()是正常的"I can Fly"
b1=鸵鸟;
b2=麻雀;
b1.fly() 显示"I can just walk!"
b2.fly() 显示"I can Fly"
明明都是Birds类的fly方法,却出现了不同的内容。 这就是多态!
父类
{
father();
}
子类{
son();
}
父类 p1= new 子类() ;
p1.father();//可以
p1.son();//反而不可以了。
因为编译器只认编译阶段的,运行阶段的不认
instanceof
变量名字 + instanceof + 类(父类);
用来判断是否可以强制转换,要是可以就返回true
只能在 编译时具有继承关系的变量之间判断
比如 int 和 char 这些不是继承关系的类,压根判断不了!
组合复用
子类继承了父类后,可以直接用父类的方法;
组合的话就是,子类内部再一次new一个父类的变量,然后通过这个变量用 父类的方法。
继承表达的“是xxx”,组合表达的是“有xxx”
初始化块
最多一个 static 前缀,没有名字。
内部想干啥干啥
String name;
{
name = "Liyipeng";
}
实际上 初始化块是一个假象
在真正编译的时候,这代码是不存在的。
只不过是
实例初始化块:
类初始化块:
总结
面向对象上在这里截至,接下来是第七章 面向对象 下