Java的工作方式:
编写源代码->编译器进行编译->输出->JVM(Java虚拟机也就是Java环境)对于输出内容进行读取和执行
循环语句:
数据类型
类型 | 字节数 | 长度 |
byte | 1 | -128~127 |
short | 2 | -32768~32767 |
int | 4 | -2147483648~2147483647 |
long | 8 | -9223372036854775808L~9223372036854775807L |
float | 4 | +/-3.4E+38F（6~7 个有效位） |
double | 8 | +/-1.8E+308 (15 个有效位） |
char | 2 | ISO 单一字符集 |
boolean | 2 | true 或 false |
Java中的数据类型
Java数据类型将上面的所有类型称为八大基本数据类型,具体细分分为数值类型,char类型和boolean类型.其中所谓的数字类型就是具体的数字类型,即前面六个值.
其中char表示Unicode字符,同时也是无符号数据类型.其实就是一个字符而已.而boolean类型则为布尔类型也就只有true和false两个值.
While语句
while这个语句即是指在满足某条件时可以一直执行,其格式为:
while(condition){
solution code
}If语句,又称分支语句
if语句，与前者较为类似，但是多了一个不满足条件时所执行的代码，也就意味着可以包含多个条件，所以它既可以想前者一样用:
if(condition){
solution code
}它也可以写一个条件和不满足该条件的解决方法:
if(condition){
solution code1
}else{
solution code2
}它还可以写多种情况的:
if(condition1){
solution code1
}else if(cndition2){
solution code2
}...
else if(conditionN){
solution codeN
}else{
solution code(N+1)
}For语句
这是一个很常用的语句，与前者的区别就是它是真正的能实现循环的语句，就和第一个while一样，如果它的条件一直未被满足，则程序就会卡在该语句直至世界终结…它的结构是这样的:
for（num=N;condition;num++ or num--）{
Solution code
}Switch语句
这个语句是指在某种情况下我们执行某条语句的，这也就意味着它与if语句比较类似，其格式为:
switch(expression){
case result1:
solution;
break;
case result2:
solution;
break;
case result3:
solution;
break;
...
case resultN:
solution;
break;
}关于对象的概念
Java是面向对象的变成，所以对象至于Java就是水之于🐟一样，非常重要。Java用对象描述整个世界，所以我们需要理解对象这一概念：
所谓对象即世间任意一个事物的描述的总和，因而每一个对象都包括了两个部分:对象的属性(特征)和对象的方法(动作)，比如对于生物来说:一个人可以包含的属性就包括了姓名，年龄，性别，身高，体重，长相等等，而他的动作可以包含吃饭，喝水，睡觉，唱歌写代码等等。即使对于石头来说我们也可以以对象的形式对他进行描述:属性方面可以使用大小，密度，质量，形状以及颜色等，而动作方面我们可以使用滚动，掉落，碰撞等等。所以说我们使用对象可以对于世间万物进行描述。
既然我们陈述了文字的基本认识，现在我们来研究一下它的代码表达:
class Person{
String name;
String sex;
int age;
void code(){
...
}
}以上是一个类，(前三个即为属性，而void code()即为我们的方法)实际上也就是对象的本体，其class代表的也就是它是可以代表一个类型的事物，正如例子中写的人这个类，它便可以表示人这个整体的类型(毕竟其他生物不会编程吧)，当我们为它实例化后它便变成了对象，此时它代表的就不是整个类型了而是一个单独的，具体的对象，它的实例化即：
Person p1=new Person();//创建了一个p1对象
p1.name="Rongxin Yang";
p1.sex="Male";
p1.age=22;
p1.code();于是我们便创建了一个名为Rongxin Yang的22岁的性别为男的人。然后我们还可以调用它的编程方法。
不过我们发现了一个问题，即虽然这样先创建一个对象p1然后为它的属性逐个赋值很难受，于是乎便诞生了构造方法这个概念。所谓构造方法首先是个方法，而这个方法又定义了一个格式，通过构造方法这个规定的格式我们便可以将一个对象的属性一参数的形式将其传递到创建对象之中。如:
public Person(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
//此时若我们想要创建该类型的对象
Person p1=new Person("Rongxin Yang","Male",22);由此我们发现我们在实例化的过程中就可以实现将对象信息注入对象之中的目的。但是要注意构造方法只是针对属性而言的，不涉及到方法。除此之外我们还要注意一点:在我们不为一个类添加构造方法时，它会默认为其添加一个空的参数的构造方法，但是由于是默认的，所以就隐藏了。这也是为什么我们刚开始实例化对象时可以没有参数。而一旦当我们为一个类创建了构造方法，则该空参数的构造方法便会被移除，故此时我们不能再创建一个空参数的对象了，如果我们想继续构造空参数的实例化对象，则需单独声明这个空参数的构造方法。
关于Getter和Settter方法
所谓Getter和Setter就是获取和设置。它们的作用也是如此，之所以有这两个方法是因为如果我们想要设置一个对象的属性是最容易想到的的方法便是:
p1.age=20;此时我们发现我们首先是调用了这个对象的属性然后在将值赋给了该属性，就有一点麻烦，加入我们有一个方法来简化这个过程呢，此时我们用setter则为:
p1.setAge(20);此时过程便有所简化，而getter则是：
System.out.println(p1.getAge());更重要的一点就是，使用方法来设置和获取属性更加能够体现面向对象这一过程。
当然这个getter和setter也不是凭空出现的，我们首先得在类中设置：
public String getName() {
return name;
}
public String getSex() {
return sex;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setSex(String sex) {
this.sex = sex;
}
public void setAge(int age) {
this.age = age;
}关于继承和复写
所谓继承就是两个类之间存在父子的关系，我们也可以理解为是遗传。其使用的关键字是extnds。如:
class Person extends Animal{
...
}这也就表示我们的Person类继承了一个Animal类，此时我们的Person类便存在了Animal的基因，这也就意味者它可以直接使用父类中的属性和方法。如:
<!-- 父类 -->
package review;
public class Animal {
String wildness;
public Animal() {
}
void sleep(){
System.out.println("Sleeping!");
}
}
<!-- 子类 -->
package review;
public class Person extends Animal{
String name;
String sex;
int age;
public Person(String name, String sex, int age,String wildness) {
this.wildness=wildness;
this.name = name;
this.sex = sex;
this.age = age;
}
void output(){
super.sleep();
System.out.println(super.wildness);
}
}
<!-- 测试类 -->
package review;
public class Review_1 {
public static void main(String[] args) {
Person p1=new Person("Rongxin Yang","Male",22,"lust");
System.out.println(p1.wildness);
p1.output();
}
}此时我们发现了输出结果分别为:
lust
Sleeping!
lust首先这说明了一个问题:我们的子类在继承了父类后，它便可以调用父类的方法和父类的属性。此外我们发现我们发现偶们可以使用关键字super来作为一个父类的指针指向父类。事实上除此之外我们的子类不仅可以继承父类的方法，还就可以覆写父类的方法。也就是说，当我们的子类有一个方法名与父类一致的方法，那么此时我们子类再对这个方法进行调用时所执行的就是子类自己的同名方法了。
向上转型和向下转型
所谓向上转型就是我们的子类实例传递给父类对象，而向下转型则相反。其中向上转型是不需要强制类型转换的，因为父类必然包括了子类，这也就意味着子类实例一定是属于父类的对象的，说简单点就是狗必然属于是动物。但是相反的我们也能推导出向下转型是不一定正确的，故向下转型必须进行强制类型转换(强行指鹿为马)，而且还有一点我们在向下转型之前必须提前进行向上转型，否则将无法正常执行。这是因为直接new一个父类的对象，那么这个对象到底是什么并无定论，此时便不能将它直接判定是一个属于狗的对象，那么一个狗的引用等于一个非狗的对象就完全错误了。为了证明该说法，我们可以创建一个猫的类，然后创建一个猫类的向上转型，此时用这个对象等于狗的引用，则是同样的错误。以下为我们的示例代码:
<!-- 父类 -->
package review;
public class Animal {
String wildness;
String type;
public Animal(String type) {
this.type = type;
}
public Animal() {
}
void intro(){
System.out.println("This is an animal!");
}
}
<!-- 子类 -->
<!-- 狗类 -->
package review;
public class Animal {
String wildness;
String type;
public Animal(String type) {
this.type = type;
}
public Animal() {
}
void intro(){
System.out.println("This is an animal!");
}
}
<!-- 猫类 -->
package review;
public class Cat extends Animal{
}
<!-- 实现类 -->
package review;
public class Review_1 {
public static void main(String[] args) {
Animal i=new Dog("Shiba Inu");
Animal c=new Cat();
Animal a=new Dog("Labrador retriever");
// Dog d=(Dog) C; 证明
Dog d=(Dog) i;
a.intro();
((Dog) a).bark();
d.bark();
d.intro();
System.out.println(((Dog) a).type);
System.out.println(d.type);
}
}
