目录
一.js部分
1.JSON对象
json字符串和js对象的转化
形式："{\"name\":\"xxx\",\"age\":18,\"sex\":\"man\"}"
let user = {
name: "xxx",
age: 18,
sex: "man"
}
let jsonUser = JSON.stringify(user) //转化为json字符串
let obj = JSON.parse("{\"name\":\"xxx\",\"age\":18,\"sex\":\"man\"}");//转化为对象2.面向对象class继承
function student(name) {
this.name = name;
}
student.prototype.hello = function () {
alert('hello');
}//给student增加一个方法
3.BOM
对话框
- alert()：显示在浏览器上边的显示框，带有信息。
- prompt()：显示可提示用户输入内容的对话框。
- confirm()：显示带有一段消息以及确认按钮和取消按钮的对话框。
页面加载事件
- onload
window.onload = function () {
// 当页面加载完成运行
// 当页面完全加载所有内容运行
};
- onunload
window.onunload = function () {
// 当用户退出页面时运行
};
浏览器尺寸
可获取浏览器的宽高
let width = window.innerWidth;
document.documentElement.clientWidth;
document.body.clientWidth;
let height = window.innerHeight;
document.documentElement.clientHeight;
document.body.clientHeight;
二.Java部分
1.Java文件名要与主类名一致
2.书写形式
public static void main(String[] args) {
System.out.println("hello world");
}3.关键字
关键字的字母全部小写
4.常量
字符串、整数、小数、字符、布尔
public static void main(String[] args) {
System.out.println("hello world");
String name = "xiao";
System.out.println("创智");
//整数常量
System.out.println(888);
System.out.println(-81);
//小数常量
System.out.println(213.32);
System.out.println(-5.21);
//字符常量
System.out.println('A');
System.out.println('8');
System.out.println('我');
//布尔常量
System.out.println(true);
System.out.println(false);
}
}运行结果如下
5.数据类型
网上找的就不自己打了
6.标识符
- 规则：由数字、字母、下划线(_)、美元符($)组成
- 不能以数字开头
- 不能是关键字
- 区分大小写
7.运算符
基本上与c语言类似
字符串+操作
public static void main(String[] args) {
System.out.println("你" + "hao");
System.out.println("hello-" + "world");
System.out.println(666 + "hao");
}运行结果
8.循环、判断与c语言类似
三.面向对象思想
1.类与对象
类就是同一类事物的总称，例如我是一个人，世界上还有很多像我一样的人，那么就将我这样一样的人为类，而每个人就是个实例，叫做对象。就像在我们平常中也有很多分类，什么动物，植物但是我们不能通过一个类区分这个东西是什么，所以就会有对象，就是具体指某一个。每个对象都会有属性，属性分为静态属性和动态属性。静态属性指这个对象在现实中的存在状态，比如尺寸、材质等等。而动态属性指功能之类的属性，比如这个对象可以干什么。当认识到这个对象的属性后，就可以定义这个对象。由此可见，类实质上就是封装对象属性和行为的载体，而对象则是类抽出来的一个实例。
2.面向对象三大特性
- 封装
封装的基本原理就是我把一些东西封起来不让别人看见，不过其他人可以通过整个东西来简单使用被封装的代码的功能。
比如说一个类最简单的封装就是把属性隐藏起来，只提供 get和set 方法进行操作：
public class Student {
//姓名
private String name;
//年龄
private int age;
//get方法获取年龄
public int getAge() {
return age;
}
//set方法修改年龄
public void setAge(int age) {
if(age<0 ||age>100){
return;
}
this.age = age;
}
//get方法获取姓名
public String getName() {
return name;
}
//set方法修改年龄
public void setName(String name) {
this.name = name;
}
}
- 继承
简单来说，继承顾名思义就是继承某个东西的属性，比如对于一个基础的四边形，可以分为正方形、长方形、菱形，他们不但继承了四边形的特征，也具有属于自己的特征，这就是一种继承的关系。
// 定义一个父类
class ParentClass {
public void parentMethod() {
System.out.println("这是父类的方法");
}
}
// 定义一个子类，继承自父类
class ChildClass extends ParentClass {
public void childMethod() {
System.out.println("这是子类的方法");
}
}
public class InheritanceExample {
public static void main(String[] args) {
// 创建子类的实例
ChildClass child = new ChildClass();
// 调用父类的方法
child.parentMethod();
// 调用子类的方法
child.childMethod();
}
}// 定义一个父类
class ParentClass {
public void parentMethod() {
System.out.println("这是父类的方法");
}
}
// 定义一个子类，继承自父类
class ChildClass extends ParentClass {
public void childMethod() {
System.out.println("这是子类的方法");
}
}
public class InheritanceExample {
public static void main(String[] args) {
// 创建子类的实例
ChildClass child = new ChildClass();
// 调用父类的方法
child.parentMethod();
// 调用子类的方法
child.childMethod();
}
}在上述代码中，我们定义了一个父类 ParentClass 和一个子类 ChildClass ，子类 ChildClass 继承了父类 ParentClass 。在子类中，我们可以使用 super 关键字来访问父类的方法和属性。 在 InheritanceExample 类的 main 方法中，我们创建了子类的实例 child ，并通过该实例调用了父类的方法 parentMethod 和子类的方法 childMethod 。
- 多态
多态指同一个实体同时具有多种形式，类的多态其实就是一个继承关系。
多态首先是建立在继承的基础上的，先有继承才能有多态。
举个小栗子
// 定义一个父类
class Animal {
void makeEat() {
System.out.println("动物会进食。");
}
}
// 定义一个子类，继承自父类
class Dog extends Animal {
@Override
void makeEat() {
System.out.println("狗吃狗粮。");
}
}
public class PolymorphismExample {
public static void main(String[] args) {
// 创建父类的对象
Animal animal = new Dog();
// 调用父类的方法，但实际上会执行子类的方法
animal.makeEat();
}
}在这个例子中，我们定义了一个父类 Animal 和一个子类 Dog ，子类 Dog 继承了父类的方法 makeEat 。在 main 方法中，我们创建了一个 Animal 类型的对象 animal ，但实际上它是一个 Dog 对象。当我们调用 animal.makeEat() 方法时，由于多态性的存在，实际执行的是子类 Dog 的方法。
3.抽象类
概念：
在面向对象的概念中，所有的对象都是通过类来描绘的。但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
抽象类的大致使用如下
// 定义一个抽象类
abstract class Shape {
// 抽象方法，计算形状的面积
abstract double calculateArea();
}
// 定义一个圆形类，继承自抽象类 Shape
class Circle extends Shape {
private double radius;
public Circle(double radius) {
this.radius = radius;
}
@Override
double calculateArea() {
return Math.PI * radius * radius;
}
}
public class AbstractClassExample {
public static void main(String[] args) {
// 创建圆形对象
Circle circle = new Circle(5.0);
// 调用计算面积的方法
double area = circle.calculateArea();
System.out.println("圆形的面积为: " + area);
}
}在这个例子中，我们定义了一个抽象类 Shape ，其中包含一个抽象方法 calculateArea ，用于计算形状的面积。然后，我们定义了一个具体的圆形类 Circle ，继承自 Shape 类，并实现了 calculateArea 方法，用于计算圆形的面积。
4.接口
接口就是一种公共的规范标准，比如插座，U盘口都属于接口。
接口类用interface关键字，子类用implements关键字实现、重写所有接口类抽象方法。
// 定义一个接口
interface Movable {
void move();
}
// 定义一个实现了 Movable 接口的类
class Car implements Movable {
@Override
public void move() {
System.out.println("汽车在移动。");
}
}
public class InterfaceExample {
public static void main(String[] args) {
// 创建一个 Car 对象
Car car = new Car();
// 调用 move 方法，因为 Car 实现了 Movable 接口
car.move();
}
}我们定义了一个名为 Movable 的接口，其中包含一个 move 方法。然后，我们定义了一个名为 Car 的类，该类实现了 Movable 接口，并在 move 方法中实现了具体的移动行为。
接口与抽象类的区别以及其注意事项
- 接口是抽象类
- 接口不可以拥有非抽象方法
- 接口可以拥有变量
- 接口方法默认为public，不能用private私有权限修饰符修饰方法
- 接口的非抽象实现类必须重写接口的所有方法，因为接口中所有方法都是抽象方法
- 子类可以多实现
- 接口中的变量不能修改，默认被public static final修饰
5.异常
异常是Java提供的用于处理程序中错误的一种机制
关键字：throws、throw、try、catch、finally
其基本用法为：
// 定义一个名为 MyException 的异常类
class MyException extends Exception {
public MyException(String message) {
super(message);
}
}
// 在主函数中抛出异常
public class ExceptionExample {
public static void main(String[] args) {
try {
// 可能会抛出 MyException 异常的语句
int a = 10 / 0;
} catch (MyException e) {
// 捕获并处理 MyException 异常
System.out.println("捕获到 MyException 异常： " + e.getMessage());
}
}
}通过以上实例，我们定义了一个名为 MyException 的异常类，它继承自 Exception 类。在主函数中，我们使用 try-catch 块来尝试执行可能会抛出 MyException 异常的语句。如果异常被抛出，它将被捕获并通过 catch 块进行处理，输出异常消息。
3924
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
