C/C++转型Java——笔记

C/C++转型Java——笔记

---------------------------------------------------------------------------基础部分---------------------------------------------------------------------------
一、概念的了解
1.JVM——Java虚拟机，跨平台翻译，Java Virtual Machine；
2.JRE——Java程序的运行环境，包含运行时所需的类库，Java Runtime Environment；
3.JDK——Java开发工具包，包括javac编译器、java运行工具，Java Development Kit；

二、数据、关键字、变量、标识符、逻辑运算等
与C++一样，不作具体描述，只有几个注意项：
1.关键字统统为小写字母，如/* public static void main(Array[] args){} / ;其为Java语言函数入口，void类型，有形参。
2.标识符的定义规则：数字不能开头，不能重名，不能与关键字相同（但大小写敏感，如int与Int不同）；
3.标识符命名约定：小驼峰如/ student / studentNum / —— 方法变量使用；
大驼峰如/ Student / StudentNum / —— 类使用；
4.逻辑符
C里的“&”是按位与，“&&”是与符号；
Java里“&”是与，即无论与否代码以此执行； “&&”是短路与，即条件一不成立后面条件不执行，谓之短路；
5.数据的外部录入
.Java采用的是用一个输入类Scanner用来接收键盘录入；
.要注意的是，既然Scanner是个类，那就要导入类名，类似于C/C++里的include"**"；
（1）导入包： import java.util.Scanner;//util的意思是多功能包，后面还会学到io包
（2）创建Scanner对象： Scanner sc = new Scanner(System.in);
（3）接收数据： int i = sc.nextInt();
6.Random——产生随机数的类
（1）导入包： import java.util.Random;
（2）创建Scanner对象： Random r = new Random();
（3）接收数据： int temp = r.nextInt(100);//随机生成 [0, 100) 的数，注意不包括100；

三、数据类型的定义差异
1.数组
定义数组方格式：
（1）int [] arr = new int[6];
（2）int arr[] = new int[6];
2.多数组指向同一堆区域
例有：int [] arr1 = new int[6];
int [] arr2 = arr1;//把arr1首地址赋给了arr2的首地址，因此俩数组都指向了同一堆区域，修改的是同一地方的值；
3.数组的两种定义方法
（1）动态定义
int [] arr = new int [6];
（2）静态定义
int [] arr = {x,x,x,…};
4.数组常犯的小错误
（1）指针越界，error：ArrayIndexOutOfBoundsException；
（2）null指针异常，error：NullPointerException；

四、方法
其实方法就是函数，与C/C++区别就是定义方法可以用public static…来修饰方法；
1.方法重载
同一个类里定义了多个方法，标识符（名称）都相同，但形参 或 数量 或 类型不相同；
2.方法形参引用传递
C++里用"&"引用符表示数据的引用，Java里以数组的形式进行引用，可能因为Java摒弃了指针的概念，只能用数组的索引的方式用作引用；
3.syso.println() 与 syso.print()区别是前者输出后换行，后者输出后不换行，例想想数组的打印；
五、类与对象简述
1.对象内存图——多个对象指向同一堆区域
例：Stu s1= new Stu();
Stu s2 = s1;
.从前面new对象可以看出，既然是new出来的，那么返回的一定就是地址，因此，s1赋值给s2就是把地址赋给了s2，s1与s2指向相同；
2.成员变量与局部变量
成员变量，方法外的变量；存在堆内存，随着对象的存在而存在、消失而消失，有默认初始值；
局部变量，方法内的变量；暂放在栈内存，方法调用即存在，调用结束就消失，没有默认的初始值；
3.构造函数
也称构造方法，例//* Stu s1 = new Stu(); */中的Stu()其为无参构造，跟C++相同，可以重载，默认构造在手动创建构造函数后系统不提供默认构造，*建议在创建有参构造后把默认构造加上去；
4.标准类的制作
（1）成员变量使用private修饰；
（2）提供多个构造方法的同时也要提供一个无参构造；
（3）为每个属性提供操作方法与获取方法，且提供显示方法；

六、API
1.API的概念
Application Programming Interface，应用程序接口，是提供各种功能的类，且类中定义好了各种方法；
Java API指的是JDK中提供的各种功能的Java类，这些类底层实现被封装了起来，只需学习如何使用即可，比如通过帮助文档学习；
2.如使用/* import java.util.Scanner；*/ 接口对输入String类型的实现；
Scanner sc = new Scanner(System.in);//System.in为Scanner对象的参数，IO章节会涉及；
String str = sc.nextLine();//Scanner对象里有nextLine()方法，用于接收系统String类型输入；

七、String对象
1.String的四种常见构造方法
（1）new String();
（2）new String(char[] chs);
（3）new String(byte[] byts);
（4）String str = “//”;
2.String对象特点
*public static void main(String[] args) {
char [] chs = {‘a’, ‘b’};
String s1 = new String(chs);//重新new了一个区域保存s1，s1 指向chs的首地址即参考chs的内容
String s2 = new String(chs);//重新new了一个区域保存s2，s2 指向chs的首地址即参考chs的内容
System.out.println(s1 == s2);//false，因为是指向两个不同的区域
String s3 = “abc”;
String s4 = “abc”;
System.out.println(s3 == s4);//true，s3与s4使用的是同一常量池里的内容
}
3.字符串的比较
（1）地址比较
如上代码，s1与s2都是指向new出来的对象，如用等于号进行比较的话，比较的是其地址；
（2）内容比较
内容比较可以用String对象的方法.equals(String )进行字符串的内容比较；
*4.字符串的单个字符获取方法 String.charAt(index);

八、StringBuilder对象
1.StringBuilder与String的差异
.String对象在进行修改字符串时，系统会new个新区域保存新的串值，然后改变原String对象的指向从而达到修改String值目的；
.StringBiulder修改的的是原区域的字符串，并不会创建新对象，所以称其为可变的字符序列，也可称为可变字串；
2.StringBiulder的添加与翻转
(1)添加append(“///”);
.可以理解为追加；因为append()方法返回的是StringBuilder本身，不需要新建另一个对象来保存；
.既然是返回的对象本身，那么就可以链式编程：StringBuilder.sppend(“Hello”).append(“World”).append(“!”);
(2)翻转reverse;
.直接用对象调用此方法可以就将StringBiulder的字串进行翻转操作，输出即可，注意返回的也是对象本身；
3. String与StringBuilder的互相转换
（1）String —> StringBuilder
StringBuilder obj = new StringBuilder(String obj);
（2）StringBuilder —> String
String = StringBuilder.toString();
4.练习1——int数组转String，以/* [1, 2, 3,…] */格式输出
思路 ：写一个方法，返回类型为String，参数为int [] 类型，通过字符串拼接方式添加，最终转为String对象并返回，注意格式。
5.练习2——键盘录入字串，反向打印输出
思路：录入后传入方法里，返回String类型，参数为String对象，通过转StringBuilder反转后再转回String返回（可用链式编程）；

九、继承
1.继承关键字extens；
2.变量使用优先级：方法内部变量 > 本类变量 > 父类变量，*注意，不会在爷爷类找；
3.this调用本类属性，super调用父类属性；
4.new子类时，会访问到父类的无参构造方法，这是规则；
5.方法重写
.如果子类所需的方法比父类多了某个功能时，就要重写父类方法；
.@Override — 此关键字是个注解，帮助检查重写的方法的正确性；
*注意，子类方法访问权限不能比父类更低，例如父类方法是protected，子类重写就不能设成private；
6.多继承
.Java不支持多继承，但支持多层继承；通俗来说就是不允许有双亲，但是能有爷爷；
7.类中public、protected、private权限修饰符的关系
（1）不同包 & 无父子关系：可互相访问public方法；
（2）不同包 & 有父子关系：能互访public与protected；
（3）同包 & 无父子关系：能互访默认、public、protected；
（4）同包 & 有父子关系：能互访默认、public与protected；
一家之言，直接记 public客厅（谁都可以坐），protected卧室(好朋友可以进)，private宝（只能我疼）；

十、包
.包其实就是文件夹，其作用是对类进行分类管理；
1.包的格式
package 包名//多级包要用 . 隔开；
2.rmd中创建包
.手动
(1)编译java文件 —— javac helloWorld.java
(2)创建文件夹 —— 在磁盘目录里创建文件夹src，再src中创建包（文件夹）
(3)把class文件放到包的最里面 —— 把HelloWorld.java放到**.//src//包名//.**中；
(4)带包执行 —— java com.包名.HelloWorld
.自动
直接rmd中写 —— javac -d . HelloWorld.java ——> java com.包名.HelloWorld‘
*注意，自动创建前提是在源码中有导入包的声明。

十一、final与static
1.final（最终的）
.修饰变量，该变量为最终变量，不可更改；
.修饰方法，该方法不可被重写；
.修饰类，该类为最终类，不允许存在子类；
.修饰地址，其地址指向不能北更改，指向的内容可更改；例final Stu s = new Stu();
*类似于C++的const限定符，指针常量与常量指针的区别
2.static（静态的）
.可以修饰成员方法或成员变量；
.如果成员方法或变量可为所有对象共有的，那么就可以用static修饰，例一个办公室公用饮水机，杯子是一人一个；
.static为类所有，不为对象所有；如静态变量赋值后，那么所有同类对象都用的是此值；
.一般用类名加点的方法赋值，不用对象赋值，如Stu.(static)name = “xxx”；
*注意，静态成员方法只能访问静态方法或成员。

十二、多态
1.多态的概念
.通过父类对象指向不同的子类，从而达到不同时刻有不同的形态，简称多态。
2.多态中的成员访问特点
.成员变量：编译看父类，运行看父类；
.成员方法：编译看父类，运行看子类；
*因为子类可能会重写父类方法，所以运行执行的是子类的方法，变量不能被重写，所以子类用的还是父类的成员变量；
3.多态的利弊端
.多态提高了程序的扩展性，定义方法时，使用父类作为参数，使用子类型进行操作；
.多态不能使用子类特有功能；因为父类没有；
4.多态的转型
.上面提到多态不能使用子类独有功能，但是可以通过父类向下转型子类再调用而实现；
.直接上代码：

					public static void main(String[] args){Animal a = new Cat();//向上转型a.eat();Cat c = (Cat) a;//向下转型，强制转换父类对象为Cat，赋给Cat对象c.playGame();//独有功能}

十三、抽象类
.abstract ：子类必须重写父类中的抽象方法；；
抽象类的特点：
（1）抽象类与成员方法用abstract关键字修饰；
（2）抽象类不一定有抽象方法，但有抽象方法的类必定是抽象类；
（3）抽象类不能直接创建，但是可以用多态的方式实例化；
（4）继承抽象类的子类要么重写父类所有的抽象方法，要么子类也声明为抽象类。
十四、接口
1.概述
.接口就是一种公共的规范标准，只要符合规范标准，大家都可以使用，Java的接口更多体现在对行为的抽象；
2.接口的特点
（1）接口用interface关键字修饰，例：public interface 接口名{}
（2）类实现接口用implements，例：public class 类名 implements 接口名{}
（3）接口不能实例化，与多态一样，通过实现类对象初始化；
（4）接口的实现类，要么重写接口的抽象方法，要么也修饰为抽象类。
（5）接口内的成员变量默认就是public static final类型的，其值不可更改；
（6）由于接口的成员变量是public static fanal类型，那么就可以直接通过接口名调用成员变量；成员方法为抽象public abstract类型;
（7）接口没有构造方法，但是因为所有类都继承了Object类，所以子类调用接口的无参构造默认调用的是Object的无参构造；
例： 当接口名为 Inter 时

				public class interImpl implements Inter{super();}//实现类接口，也可以写成public class interImpl extends Object implements Inter{super();}//既然接口没有构造方法，实现类用super()构造接口时，默认调用的是Object的无参构造。由此可见，接口的构造只能是抽象的，接口主要是对行为进行抽象的，可以直接用 接口名.方法 的方式调用。

3.接口关系
总的来说，接口就是为了规范化方法，实现类重写了接口方法且符合规范 就能直接（无继承关系）通过实现类调用次接口的方法。
（1）类与接口的关系
.类与接口的关系是类能实现接口，且类能在继承的同时实现多个类；例：public class Zi extends Fu implements Inter1,Inter2{}
（2）接口与接口关系
.接口之间可继承，且支持多继承。
（3）抽象类与接口的区别
.抽象类能对变量、方法抽象，而接口只要是针对方法；
.抽象类例可以有变量、常量、构造方法、抽象方法、非抽象方法；接口只有常量与抽象方法；
.怎么合理使用抽象类与接口呢？
例：定义一个抽象类与接口，其中都有开门和关门方法，如果要新增一个报警功能，此时如果把开门、关门、报警的方法全放在抽象类例，但是不是所有门都有报警功能，因此子类继承会错误的继承到报警方法；如果全放到接口里，实现接口要也要实现这三个功能，那么也会造成错误收到不要的接口。解决办法是把开关门这种共有的特性放在抽象类里，报警方法单独放在接口里，这样，哪种子类需要就直接实现报警接口就行。

十五、抽象类作形参或返回值
1.抽象类作形参
抽象类不能实直接例化，作形参时，其实需要的是抽象类的子类对象；
2.抽象类作返回值
抽象类作返回值时，也是需要返回该抽象类的子类对象；
例：
void test(Animal a){}
/*
Animal a = new Animal();
test(a);//error
*/
Animal a = new Cat();
test(a);//true
3.接口作为形参或返回值
与抽象类基本相同，要先创建实现类，实现接口，利用这个实现类创建一个对象，作返形参或回值；
十六、内部类
.内部类就是在一个类里创建另一个类，其为了类的隐蔽性；
（1）访问权限
内部类能直接访问外部类的属性和方法；外部类不能直接访问内部类的方法，可以通过写一个外部类方法，在方法体里new一个内部类对象，完成调用；
例：

//Out类为外部类，In为内部类public class Out{外部类private int age = 20;private class In{//内部类public void shou(){System.out.println(age);//可直接访问到外部类}} public getIn (){//外部类访问内部类方法In in = new In();in.show();}}`

十七、

---------------------------------------------------------------------------------泛型部分---------------------------------------------------------------------------------
一、ArrayList——集合(util)
.可直接理解为C++中的set容器；
1.ArrayList的常用方法
(1).添加方法：ArrayList.add();
该方法有多个重载，可查看jdk帮助文档获取重载的参数等；
(2).删除索引元素，返回是否成功——ArrayList.remove(val);
(3).删除索引元素，返回被删除元素——ArrayList.remove(index);
(4).修改索引元素，返回被修改元素——ArrayList.set(index, val)
(5).返回索引元素——ArrayList.get(index);
(6).返回容器个数——ArrayList.size();
2.遍历
ArrayList的遍历可用get(index)方法遍历，注意而不是用迭代器；
3.练习——用键盘输入学生类的姓名、学号、性别，存入ArrayList容器并打印输出；
4.项目练习——写一个系统，实现增删改查学生的信息，并同步到txt文件，可在学完IO后再做；

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！