一、循环语句
1、for循环
声明部分:只执行一次
条件部分:每次都会执行,从而控制循环体与迭代部分的代码执行
格式:
for(声明部分;条件部分;迭代部分){
循环体
}
第一次执行:声明部分》条件部分且为true》循环体》迭代部分
for (int i=0; i<10; i++){
System.out.println("1");
}
1.1、for循环练习题
{
public static void main(String[] args) {
t1();
t2();
t3();
t4();
}
public static void t1() {
/*
声明部分:只执行一次
条件部分:每次都会执行,从而控制循环体与迭代部分的代码执行
for(声明部分;条件部分;迭代部分){
循环体
}
第一次执行:声明部分》条件部分且为true》循环体》迭代部分
*/
//打印100之内的奇数和
int sum = 0;
for (int i = 1; i < 101; i++) {
if (i % 2 != 0) {
sum += i;
}
}
System.out.println("100之内的和为:" + sum);
}
//打印100之内所有是7的倍数的整数个数和总和
public static void t2() {
int sum=0;
int count=0;
for (int i=1;i<101;i++){
if (i%7==0){
sum+=i;
count+=1;
}
}
System.out.println("总和为:"+sum);
System.out.println("个数为:"+count);
}
//打印100之内所有是7的倍数的整数个数和总和
public static void t3() {
int sum=0;
int count=0;
for (int i=1;i<101;i++){
if (i%7==0){
sum+=i;
count+=1;
}
}
System.out.println("总和为:"+sum);
System.out.println("个数为:"+count);
}
//打印水仙花数
public static void t4() {
//取车百位、十位、各位
for (int i=1;i<=999;i++){
int b=i/100;
int s=i%100/10;
int g=i%10;
if (i==b*b*b + s*s*s + g*g*g){
System.out.println("i:"+i);
}
}
}
}
2、while循环
int j=0;
while (j<100){
System.out.println(j);
j++;
}
3、do-while循环
int k=100;
do{
System.out.println(j);
}while (k<100); //最后必须使用分号结束
4、循环的嵌套
内循环的执行次数:外循环执行次数*内循环执行次数
package com.company;
public class circle_1 {
public static void main(String[] args) {
t2();
}
public static void t2(){
for (int i = 1; i < 10; i++) {
for (int j=0;j<10;j++){
System.out.println("j");
break; //结束j循环
}
}
}
}
4.1、循环嵌套实现九九乘法表
package com.company;
public class circle_1 {
public static void main(String[] args) {
t2();
}
public static void t2(){
for (int i = 1; i < 10; i++) {
for (int j=1;j<i+1;j++){
System.out.print(j+"*"+i+"="+i*j+"\t");
}
System.out.println();
}
}
}
二、流程控制语句
1、break
package com.company;
public class circle_1 {
public static void main(String[] args) {
t0();
}
public static void t0(){
for (int i = 1; i < 10; i++) {
System.out.println(i);
if (i == 5) {
break;
}
}
}
}
2、continue
package com.company;
public class circle_1 {
public static void main(String[] args) {
t1();
}
public static void t1(){
for (int i = 1; i < 10; i++) {
if (i == 5) {
continue; //当代码成立:continue或者break后面的代码不会执行
}
System.out.println(i);
}
}
}
三、数组
数组可以存储多个值
1、数组定义
1.1、静态数组
当数组的值在定义的时候就已经确定了,那么就是静态数组
格式:
数据类型 数组名称 = new 数据类型{值1,值2}
数据类型 数组名称 = {值1,值2}
package com.company;
public class array {
public static void main(String[] args) {
t1();
}
public static void t1(){
//静态数组
int[] a1=new int[]{1,3,5,7,9};
int[] a2={1,3,5,7,9};
System.out.println(a1); //[I@5594a1b5
}
}
1.2、动态数组
在java中 动态数组在定义的时候,必须定义长度
a3中所有的元素都是以数据类型的默认值填充
索引是从0开始的,最后一个元素的索引为数组的长度-1
获取数组的长度 数组名.length
索引超出范围,就会引起数组越界异常 ArrayIndexOutOfBoundException
package com.company;
public class array {
public static void main(String[] args) {
t1();
}
public static void t1(){
//动态数组
int[] a3=new int[5]; //在java中 数组在定义的时候,必须定义长度
//a3中所有的元素都是以数据类型的默认值填充
for (int i=0;i<5;i++){
System.out.println(a3[i]);
}
}
}
修改数组
a3[0]=1; 修改数组中的值
a3[1]=2;
定义数组并且初始化
int[] a4; //定义一个整型的数组,名为a4,但是没有初始化
a4=new int[10]; //对a4数组进行初始化
1.3、练习求数组的和
package com.company;
public class array {
public static void main(String[] args) {
t1();
t2();
}
public static void t2(){
int[] scores={100,90,80,70,60};
int sum=0;
for (int i=0;i<scores.length;i++){
sum+=scores[i];
}
System.out.println(sum);
}
}
2、练习交换2个变量的值
public static void swap(int x,int y){
int temp;
temp=x;
x=y;
y=temp;
System.out.println(x+" , "+y);
}
3、Math数学类常用方法
public class MathDemo {
public static void main(String[] args) {
System.out.println(Math.random()); //随机数
System.out.println(Math.abs(9-100)); //求绝对值
System.out.println(Math.ceil(1.1)); //向上取整
System.out.println(Math.floor(1.1)); //向下取整
System.out.println(Math.floor(1.6)); //向下取整
System.out.println(Math.round(1.6)); //四舍五入
System.out.println(Math.round(1.4)); //四舍五入
}
}
数组访问元素:
通过索引访问:数组名称[索引]
访问第一个元素:数组名称[0]
数组遍历通过for循环实现
4、数组反转:
public class array {
public static void main(String[] args) {
revsese();
}
public static void revsese(){
int[] oldarr = {10,20,30,40,50};
//新数组
int[] newarr=new int[oldarr.length];
//遍历
for (int i=0;i<=newarr.length-1;i++){
newarr[i]=oldarr[oldarr.length-1-i];
System.out.println(newarr[i]);
}
}
四、方法
是语句集合;执行某个特定任务,将结果返回给调用者;必须是某个类的一部分。
方法的优点:
使程序变得更简短而清晰
利于程序维护
提高开发效率
提高代码的重用性
1、方法声明
修饰符 返回值类型 方法名(参数类型 参数名){
方法体
return 返回值;
}
修饰符:定义访问权限类型,是可选的
返回值类型:
- 如果没有返回值,则为数据类型名称
- 如果有返回值,则为void
方法名
- 是方法的实际名称
参数列表
- 当方法被调用时,传递值给参数
返回值
- 通常使用return关键字
public class methodDemo {
//声明方法
public static int sum(int a,int b){
int result = a + b; //方法体
return result; //返回值
}
}
2、方法调用
第一种方法直接调用:方法名称(参数)
第二种调用方法:打印调用
第三种调用方法:赋值
//方法的调用
public class methodcall {
public static void main(String[] args) {
//第一种方法直接调用
sum(3,4);
//第二种调用方法;打印调用
System.out.println(sum(5,10));
//第三种调用方法:赋值
int number=sum(5,6);
System.out.println(number);
}
//声明方法
public static int sum(int a,int b){
System.out.println("方法开始执行了");
int result = a + b; //方法体
return result; //返回值
}
}
3、方法调用过程
4、方法重载
是指在一个类中可以定义多个方法名相同,但是参数列表不同的方法。
调用时,会根据不同的参数自动匹配对应的方法。
构成方法重载的条件
public class methodload {
//需要计算2个数字的和
public static void main(String[] args) {
System.out.println(sum(6, 6));
System.out.println(sum(1, 4, 5));
}
public static int sum(int a, int b) {
System.out.println("有2个参数");
return a + b;
}
public static int sum(int a, int b, int c) {
System.out.println("有3个入参");
return a + b + c;
}
}
5、注意事项
五、面向对象编程
使用一个可以满足需求的对象,完成我的功能。
package com.company;
import java.util.Arrays;
public class object {
public static void main(String[] args) {
//声明数组
String[] nameArray={"张三","李四","王五"};
//利用面向对象思想,使用Arrays类中的toString方法将数组转换为字符串。
System.out.println(Arrays.toString(nameArray));
}
}
1、面向对象语言的三大特征
- 封装
- 继承
- 多态
2、类的概念
类是一种属性与行为的集合,它将数据以及这些数据上的操作封装到一起,可以看做事物的模板。
- 属性:类的成员变量(事物的状态信息)
- 行为:类的方法(事物能做什么?)
Persion
- 属性(类的成员变量):身高、年龄
- 行为(类的方法):睡觉、吃饭
3、类的格式
package com.company;
public class Persion {
//属性
Integer height; //身高
String name; //姓名
Integer age; // 年龄
//构造方法
public Persion(){
}
//行为
public void sleep(){
System.out.println("睡觉了");
}
public void eat(){
System.out.println("吃饭了");
}
public void meet(String meetPersionName){
System.out.println(name + "遇见了" + meetPersionName);
}
}
4、对象的概念
是一类事物具体的实现,是一个类具体的实例。
对象有自己的内部数据,并且彼此独立(每个对象在内存中都有唯一的地址)
5、对象的格式
实例化对象:类名 对象名 = new 类名();
访问对象的成员变量:对象名.成员变量;
调用对象的成员方法:对象名.成员方法();
package com.company;
public class Persion {
//属性
Integer height; //身高
String name; //姓名
Integer age; // 年龄
//构造方法
public Persion(){
}
//行为
public void sleep(){
System.out.println("睡觉了");
}
public void eat(){
System.out.println("吃饭了");
}
public void meet(String meetPersionName){
System.out.println(name + "遇见了" + meetPersionName);
}
}
public class PersionDemo {
public static void main(String[] args) {
//通过Persion类创建张三对象
Persion zs = new Persion();
System.out.println(zs.name);
zs.name="张三";
zs.height=180;
zs.age=18;
System.out.println(zs.name);
//访问方法
zs.eat();
zs.meet("李四");
}
}
6、成员变量与局部变量
成员变量:是在类范围内方法外定义的变量
局部变量:方法内定义的变量
成员变量的默认值代码展示
package com.company.oop;
import com.company.oop.Persion;
public class BasicType {
//成员变量
byte bytex;
short shortx;
int intx;
long longx;
char charx;
//引用类型
Persion person;
}
package com.company.oop;
public class BaseTypeTest {
public static void main(String[] args) {
//创建对象
BasicType demo = new BasicType();
// 访问对象的属性
System.out.println(demo.bytex);
System.out.println(demo.intx);
//引用类型
System.out.println(demo.person); //初始值为null
}
}
0
0
null
六、面向对象之封装
类的数据和代码不应该被随意访问或修改
通过公共方法访问或者修改这些属性
1、private关键字
权限修饰词:私有,只能在类中访问
可用于修饰成员变量、方法
格式:private 数据类型 变量名;
代码展示:Student类
package com.company.encap;
public class Student {
private String name;
private int age;
private String gender;
public String zone;
}
Demo类:只能访问zone属性,不能访问private修饰的属性
2、getter和setter方法
使用private修饰了成员变量之后,外部无法直接调用
getter:代表获取成员变量
setter:代表设置成员变量
this代表所在类的当前对象的引用,即对象自己的引用
package com.company.encap;
public class Student {
private String name;
private int age;
private String gender;
public String zone;
//name:getter方法
public String getName(){
//this调用成员方法
this.show();
return this.name;
}
//name:setter方法
public void setName(String name){
//访问成员变量
this.name=name;
}
//定义一个成员方法
public void show(){
System.out.println("这是成员方法");
}
}
package com.company.encap;
public class Demo {
public static void main(String[] args) {
Student st = new Student();
st.setName("kobe");
System.out.println(st.getName());
}
}
这是成员方法
kobe
七、构造方法
构造方法是用于对象的初始化
给对象的成员变量赋初始值
无需添加返回值类型
无参构造和有参构造:
Java有两个构造方法:无参构造、有参构造。
如果没有定义构造方法,Java会给出无参构造方法。
如果定义了构造方法,Java不再提供无参构造方法。
构造方法实例1
package com.company.construction;
public class StudentWithages {
//声明成员变量
private String name;
private int grade;
// 定义有参构造方法
public StudentWithages(String name, int grade){
this.name=name;
this.grade=grade;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getGrade() {
return grade;
}
public void setGrade(int grade) {
this.grade = grade;
}
}
package com.company.construction;
public class Demo {
public static void main(String[] args) {
StudentDefault st = new StudentDefault();
StudentNoArgs st1 = new StudentNoArgs();
System.out.println(st1.getName());
StudentWithages st2 = new StudentWithages("123",1);
System.out.println(st2.getName());
System.out.println(st2.getGrade());
}
}
执行结果:
123
1
构造方法实例2:
package com.company.construction;
public class Student {
private String name;
private int grade;
//无参构造方法
public Student(){
System.out.println("没有参数");
}
//一个参数的构造方法
public Student(String name){
System.out.println("只有一个参数");
this.name=name;
}
//2个参数的构造方法
public Student(String name,int grade){
System.out.println("2个参数的构造方法");
this.name=name;
this.grade=grade;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getGrade() {
return grade;
}
public void setGrade(int grade) {
this.grade = grade;
}
}
package com.company.construction;
public class StudentDemo {
public static void main(String[] args) {
Student st= new Student();
System.out.println(st.getName());
Student st1= new Student("kobe");
System.out.println(st1.getName());
Student st2= new Student("kobe",8);
System.out.println(st2.getName());
System.out.println(st2.getGrade());
}
}
输出结果
没有参数
null
只有一个参数
kobe
2个参数的构造方法
kobe
8
八、继承
提取公共特征到Person类
学生类和老师类都来继承Person类
子类继承父类的属性和行为,使得子类对象具有与父类相同的属性、相同的行为。
子类可以直接访问父类中的非私有的属性和行为。
1、格式
class 子类 extends 父类{
}
2、不采用继承
老师类
package com.company.inheri;
public class Teacher {
public String name;
public void eat(){
System.out.println(this.name+"吃饭");
}
public void teach(){
System.out.println(this.name+"讲课");
}
}
学生类
package com.company.inheri;
public class Student {
public String name;
public void eat(){
System.out.println(this.name+"吃饭");
}
public void teach(){
System.out.println(this.name+"讲课");
}
}
3、采用继承
package com.company.inheri;
public class Person {
//父类公开的成员变量
public String name;
//成员方法
public void eat(){
System.out.println(this.name+"吃饭");
}
}
package com.company.inheri;
public class Teacher extends Person {
public String name;
public void teach(){
System.out.println(this.name+"讲课");
}
}
package com.company.inheri;
public class Student extends Person {
public void teach(){
System.out.println(this.name+"讲课");
}
}
4、继承规则
子类可以直接访问父类中的非私有的变量和方法。
子类不能直接访问父类如果使用 private修饰成员变量和方法。
如果子类和父类的成员变量重名,那么会优先子类。
子类无法继承父类的构造方法。
RuleBase类
package com.company.inheri;
public class RuleBase {
public String name; //公开的
private int money; //私有的
//公开方法
public void eat(){
System.out.println(this.name+"吃饭");
}
//父类私有方法
private void showMoney(){
System.out.println(this.money+"钱");
}
}
子类
package com.company.inheri;
public class RuleSub extends RuleBase{
}
实例化子类
package com.company.inheri;
public class RuleMain {
public static void main(String[] args) {
//实例化子类对象
RuleSub sub = new RuleSub();
sub.name="子类";
sub.eat();
}
}
4、继承-成员变量重名
如果子类和父类的成员变量重名,那么会优先子类。
package com.company.inheri;
public class HiddenBase {
public String name="父类的name变量";
}
package com.company.inheri;
public class HiddenSub extends HiddenBase{
//子类重名的变量,会导致父类重名的变量被隐藏
public String name = "子类的name变量";
}
package com.company.inheri;
public class HiddenMain {
public static void main(String[] args) {
//实例化子类对象
HiddenSub sub = new HiddenSub();
//访问变量
System.out.println(sub.name);
}
}
执行结果
子类的name变量
5、继承-super关键字
super代表父类的存储空间标识,是父类的引用。
如果出现重名,则可以通过super.成员变量明确访问父类的成员变量。
可以通过this明确访问自己的成员变量
package com.company.inheri;
public class HiddenBase {
public String name="父类的name变量";
}
package com.company.inheri;
public class HiddenSub extends HiddenBase{
//子类重名的变量,会导致父类重名的变量被隐藏
public String name = "子类的name变量";
public void showSuper(){
System.out.println("super:" + super.name);
}
public void shouThis(){
System.out.println("this"+this.name);
}
}
package com.company.inheri;
public class HiddenMain {
public static void main(String[] args) {
//实例化子类对象
HiddenSub sub = new HiddenSub();
//访问变量
System.out.println(sub.name);
//指定访问父类的变量,使用super
sub.showSuper();
//指定访问子类的变量 使用this
sub.shouThis();
}
}
执行结果
子类的name变量
super:父类的name变量
this子类的name变量
6、继承-成员方法重名
子类出现与父类同名的方法,叫做方法的重写(Override)
方法重写:子类出现与父类相同的方法
- 返回值类型相同
- 方法名相同
- 参数列表相同
子类方法重写父类方法,必须要保证权限大于等于父类权限。
package com.company.inheri;
public class OverrideBase {
//父类的成员方法
public void live(){
System.out.println("父类方法:老家");
}
}
package com.company.inheri;
public class OverrideSub extends OverrideBase{
public void live(){
System.out.println("子类方法:新家");
}
//明确访问父类方法
public void doSupper(){
super.live();
}
// 明确访问自己方法
public void doThis(){
this.live();
}
}
package com.company.inheri;
public class OverrideMain {
public static void main(String[] args) {
OverrideSub sub = new OverrideSub();
//访问子类重写后的live方法
sub.live();
sub.doSupper();
sub.doThis();
}
}
Java只支持单继承、不支持多继承
java支持多层继承